TCS::AnomalyDetectionBDT Class Reference

#include <AnomalyDetectionBDT.h>

Inheritance diagram for TCS::AnomalyDetectionBDT:

Collaboration diagram for TCS::AnomalyDetectionBDT:

Public Member Functions
	AnomalyDetectionBDT (const std::string &name)
virtual	~AnomalyDetectionBDT ()
virtual StatusCode	initialize ()
virtual StatusCode	processBitCorrect (const std::vector< TCS::TOBArray const * > &input, const std::vector< TCS::TOBArray * > &output, Decision &decision)
virtual StatusCode	process (const std::vector< TCS::TOBArray const * > &input, const std::vector< TCS::TOBArray * > &output, Decision &decision)
unsigned int	numberOutputBits () const
void	setNumberOutputBits (unsigned int numberOutputBits)
DecisionAlg &	setHardwareBits (const unsigned int &bitNumber, const bool &valueDecision, const bool &valueOverflow)
	propagate the hardware decision bits for each output bit of this algo
DecisionAlg &	resetHardwareBits ()
	! reset all hardware bits for this algo
bool	getDecisionHardwareBit (const unsigned int &bitNumber) const
	! get one hardware decision bit from this algo
bool	getOverflowHardwareBit (const unsigned int &bitNumber) const
	! get one hardware overflow bit from this algo
DecisionAlg &	setFillHistosBasedOnHardware (const bool &value)
	! toggle m_fillHistosBasedOnHardware
bool	fillHistosBasedOnHardware () const
	! getter
DecisionAlg &	setSkipHistos (const bool &value)
	! toggle m_skipHistos (see TopoSteering::setOutputAlgosSkipHistograms)
bool	skipHistos () const
	! getter
bool	fillHistos () const
	whether the monitoring histograms should be filled
void	setClassName (const std::string &className)
void	setLegacyMode (bool isLegacyTopo)
const std::string &	name () const
const std::string &	className () const
std::string	fullname () const
unsigned int	algoId () const
StatusCode	reset ()
bool	isSortingAlg () const
bool	isDecisionAlg () const
bool	isCountingAlg () const
bool	isLegacyTopo () const
unsigned int	calcDeltaPhiBW (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcDeltaEtaBW (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcInvMassBW (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcTMassBW (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcDeltaR2BW (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned long	quadraticSumBW (int i1, int i2)
unsigned int	calcDeltaPhi (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcDeltaEta (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcInvMass (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcTMass (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
unsigned int	calcDeltaR2 (const TCS::GenericTOB *tob1, const TCS::GenericTOB *tob2)
const Parameter &	parameter (const std::string &parameterName) const
const Parameter &	parameter (const std::string &parameterName, unsigned int selection) const
const ParameterSpace &	parameters () const
void	setParameters (const ParameterSpace &)
void	setAlgoId (unsigned int algoId)
void	setL1TopoHistSvc (std::shared_ptr< IL1TopoHistSvc >)
	sets the external hist service
void	bookHistMult (std::vector< std::string > &regName, const std::string &name, const std::string &title, const std::string &xtitle, const int binx, const int xmin, const int xmax)
void	bookHistMult (std::vector< std::string > &regName, const std::string &name, const std::string &title, const std::string &xtitle, const std::string &ytitle, const int binx, const int xmin, const int xmax, const int biny, const int ymin, const int ymax)
void	bookHist (std::vector< std::string > &regName, const std::string &name, const std::string &title, const int binx, const int xmin, const int xmax)
void	bookHist (std::vector< std::string > &regName, const std::string &name, const std::string &title, const int binx, const int xmin, const int xmax, const int biny, const int ymin, const int ymax)
bool	msgLvl (const MSGTC::Level lvl) const
	Test the output level.
MsgStreamTC &	msg () const
	The standard message stream.
MsgStreamTC &	msg (const MSGTC::Level lvl) const
	The standard message stream.
const std::string &	getName () const
	name accessor

Protected Types
enum	AlgType { NONE , SORT , DECISION , COUNT }

Protected Member Functions
void	defineParameter (const std::string &name, TCS::parType_t value)
void	defineParameter (const std::string &name, TCS::parType_t value, unsigned int selection)
void	registerHist (TH1 *)
void	registerHist (TH2 *)
void	fillHist1D (const std::string &histName, double x)
void	fillHist2D (const std::string &histName, double x, double y)
bool	isocut (const std::string &threshold, const unsigned int bit) const
bool	isocut (const unsigned int threshold, const unsigned int bit) const

Protected Attributes
std::vector< std::string >	m_histAccept
std::vector< std::string >	m_histReject
std::vector< std::string >	m_histAcceptM
std::vector< std::string >	m_histRejectM
std::vector< std::string >	m_histAcceptX
std::vector< std::string >	m_histRejectX
std::vector< std::string >	m_histAcceptEta1Eta2
std::vector< std::string >	m_histRejectEta1Eta2
std::vector< std::string >	m_histAcceptEta2Eta3
std::vector< std::string >	m_histRejectEta2Eta3
std::vector< std::string >	m_histAcceptEta3Eta1
std::vector< std::string >	m_histRejectEta3Eta1

Private Member Functions
virtual StatusCode	doReset ()
void	defineParameter (const Parameter &)
std::string	ToString (const int val)

Private Attributes
std::vector< Tree >	m_trees
int	m_nVar {0}
int64_t	m_totalScore {0}
float	m_mu1_ptmin {0}
float	m_mu1_ptmax {0}
float	m_mu1_etamin {0}
float	m_mu1_etamax {0}
float	m_mu1_phimin {0}
float	m_mu1_phimax {0}
float	m_mu2_ptmin {0}
float	m_mu2_ptmax {0}
float	m_mu2_etamin {0}
float	m_mu2_etamax {0}
float	m_mu2_phimin {0}
float	m_mu2_phimax {0}
std::string	m_sim_mode
parType_t	p_ScoreThreshold [2] = { 0, 0 }
parType_t	p_minEt1 {0}
parType_t	p_minEt2 {0}
size_t	p_MaxTob {3}
unsigned int	m_numberOutputBits {1}
uint32_t	m_hardwareDecisionBits {0}
	! decision bits from hardware (assume the algo won't have >31 output bits)
uint32_t	m_hardwareOverflowBits {0}
	! overflow bits from hardware (assume the algo won't have >31 output bits)
bool	m_fillHistosBasedOnHardware {0}
	! fill accept/reject monitoring histos based on hdw decision
bool	m_skipHistos {0}
	! skip filling monitoring histos, used only when m_fillHistosBasedOnHardware==true
std::unique_ptr< ConfigurableAlgImpl >	m_impl
std::string	m_name {""}
std::string	m_className {""}
unsigned int	m_algoId {0}
ParameterSpace	m_parameters {""}
AlgType	m_algType
bool	m_isLegacyTopo
boost::thread_specific_ptr< MsgStreamTC >	m_msg_tls
	MsgStreamTC instance (a std::cout like with print-out levels)

Detailed Description

Definition at line 49 of file AnomalyDetectionBDT.h.

Member Enumeration Documentation

AlgType

enum TCS::ConfigurableAlg::AlgType

protectedinherited

Enumerator
NONE
SORT
DECISION
COUNT

Definition at line 32 of file ConfigurableAlg.h.

{ NONE, SORT, DECISION, COUNT };

Constructor & Destructor Documentation

AnomalyDetectionBDT()

TCS::AnomalyDetectionBDT::AnomalyDetectionBDT

(

const std::string &

name

)

Definition at line 383 of file AnomalyDetectionBDT.cxx.

: DecisionAlg(name) {
   defineParameter("MinET1",0);
   defineParameter("MinET2",0); 
   defineParameter("ScoreThreshold", 1, 0);
   defineParameter("ScoreThreshold", 1, 1);
   defineParameter("MaxTob",3);
   defineParameter("NumResultBits",2);
   setNumberOutputBits(2); // 2 decision bits for 2 different score thresholds
                           // (BDT Regression score is calculated internally)  
}

~AnomalyDetectionBDT()

TCS::AnomalyDetectionBDT::~AnomalyDetectionBDT ( )

virtual

Definition at line 396 of file AnomalyDetectionBDT.cxx.

{}

Member Function Documentation

algoId()

unsigned int TCS::ConfigurableAlg::algoId ( ) const

inlineinherited

Definition at line 53 of file ConfigurableAlg.h.

{ return m_algoId; }

bookHist() [1/2]

void ConfigurableAlg::bookHist ( std::vector< std::string > & regName, const std::string & name, const std::string & title, const int binx, const int xmin, const int xmax )

inherited

Definition at line 270 of file ConfigurableAlg.cxx.

                                                                                                                                                           {
  std::string xmin_str = ToString(xmin);
  std::string xmax_str = ToString(xmax);
  std::string newTitle = title;
  std::string newName = name;
 
  newTitle = xmin_str+title+xmax_str;
  newName = name+"_"+xmin_str+title+xmax_str;
  std::replace( newName.begin(), newName.end(), '-', 'n');
  std::replace( newName.begin(), newName.end(), ' ', '_');
 
  regName.push_back(m_name+"/"+newName);
 
  // Add units to axis labels
  std::string xTitle = title;
  if (m_isLegacyTopo) {
    if (title == "ETA" || title == "DETA" || title == "PHI" || title == "DPHI" || title == "DR") { xTitle = title+"#times10"; }
    if (title == "PT" || title == "ET" || title == "HT" || title == "INVM" || title == "MT")     { xTitle = title+" [GeV]"; } 
  } 
  else {
    if (title == "ETA" || title == "DETA" || title == "DR")                                  { xTitle = title+"#times40"; }
    if (title == "PHI" || title == "DPHI")                                                   { xTitle = title+"#times20"; }
    if (title == "PT" || title == "ET" || title == "HT" || title == "INVM" || title == "MT") { xTitle = title+" [100 MeV]"; } 
  }
 
  int xmin_new,xmax_new,binx_new=binx;
  if ( xmin > 0.0)
    { xmin_new=0.0; }
  else
    { xmin_new=1.5*xmin; }
 
  // if the maximum inv. mass cut defined by the menu over 4000 MeV,
  // set x-axis range maximum to 4000 MeV. This is only for legacy triggers,
  // phase1 does not exceed this limit- asonay 08/2022
  if (xmax > 4000 && m_isLegacyTopo) {
    xmax_new = 4000;
    binx_new = 200;
  }
  else {xmax_new = 1.5*xmax;}
  
  // if angular kinematics, use fixed range
  int eta_max = 50;
  int phi_max = 64;
  int dr_max = 30;
  if (not m_isLegacyTopo) {
    eta_max *= 4;
    phi_max *= 2;
    dr_max *= 4;
  }
 
  if ( title.find("ETA") != std::string::npos ){
    xmin_new=-eta_max;
    xmax_new=eta_max;
  }
  if ( title.find("PHI") != std::string::npos || title.find("DPHI") != std::string::npos ){
    xmin_new=0;
    xmax_new=phi_max;
  }
  if ( title.find("DETA") != std::string::npos || title.find("DR") != std::string::npos ){
    xmin_new=0;
    xmax_new=dr_max;
  }
 
  TH1 *h = new TH1F(newName.c_str(), newTitle.c_str(), binx_new, xmin_new, xmax_new);
  h->GetXaxis()->SetTitle(xTitle.c_str());
  m_impl->registerHist(h);
}

bookHist() [2/2]

void ConfigurableAlg::bookHist ( std::vector< std::string > & regName, const std::string & name, const std::string & title, const int binx, const int xmin, const int xmax, const int biny, const int ymin, const int ymax )

inherited

Definition at line 347 of file ConfigurableAlg.cxx.

                                                                                                                                                                                                           {
  auto usPos = title.find(" vs ");
  std::string xName = title.substr(0,usPos);
  std::string yName = title.substr(usPos+4);
  std::string xmin_str = ToString(xmin);
  std::string xmax_str = ToString(xmax);
  std::string ymin_str = ToString(ymin);
  std::string ymax_str = ToString(ymax);
  std::string newTitle = title;
  std::string newName = name;
 
  newTitle = xmin_str+xName+xmax_str+" vs "+ymin_str+yName+ymax_str;
  newName = name+"_"+xmin_str+xName+xmax_str+"_"+ymin_str+yName+ymax_str;
  std::replace( newName.begin(), newName.end(), '-', 'n');
  std::replace( newName.begin(), newName.end(), ' ', '_');
 
  regName.push_back(m_name+"/"+newName);
 
  // Add units to axis labels
  std::string xTitle = xName;
  std::string yTitle = yName;
  if (m_isLegacyTopo) {
    if (xName == "ETA" || xName == "DETA" || xName == "PHI" || xName == "DPHI" || xName == "DR") { xTitle = xName+"#times10"; }
    if (xName == "PT" || xName == "ET" || xName == "HT" || xName == "INVM" || xName == "MT")     { xTitle = xName+" [GeV]"; } 
 
    if (yName == "ETA" || yName == "DETA" || yName == "PHI" || yName == "DPHI" || yName == "DR") { yTitle = yName+"#times10"; }
    if (yName == "PT" || yName == "ET" || yName == "HT" || yName == "INVM" || yName == "MT")     { yTitle = yName+" [GeV]"; } 
  } 
  else {
    if (xName == "ETA" || xName == "DETA" || xName == "DR")                                  { xTitle = xName+"#times40"; }
    if (xName == "PHI" || xName == "DPHI")                                                   { xTitle = xName+"#times20"; }
    if (xName == "PT" || xName == "ET" || xName == "HT" || xName == "INVM" || xName == "MT") { xTitle = xName+" [100 MeV]"; } 
 
    if (yName == "ETA" || yName == "DETA" || yName == "DR")                                  { yTitle = yName+"#times40"; }
    if (yName == "PHI" || yName == "DPHI")                                                   { yTitle = yName+"#times20"; }
    if (yName == "PT" || yName == "ET" || yName == "HT" || yName == "INVM" || yName == "MT") { yTitle = yName+" [100 MeV]"; } 
  }
 
  int xmin_new,xmax_new,binx_new=binx;
  if ( xmin > 0.0)
    { xmin_new=0.0; }
  else
    { xmin_new=1.5*xmin; }
  
  // if the maximum inv. mass cut defined by the menu over 4000 MeV,
  // set x-axis range maximum to 4000 MeV. This is only for legacy triggers,
  // phase1 does not exceed this limit- asonay 08/2022
  if (xmax > 4000 && m_isLegacyTopo) {
    xmax_new = 4000;
    binx_new = 200;
  }
  else {xmax_new = 1.5*xmax;}
 
  int ymin_new,ymax_new,biny_new=biny;
  if ( ymin > 0.0)
    { ymin_new=0.0; }
  else
    { ymin_new=1.5*ymin; }
  
  // if the maximum inv. mass cut defined by the menu over 4000 MeV,
  // set y-axis range maximum to 4000 MeV. This is only for legacy triggers,
  // phase1 does not exceed this limit- asonay 08/2022
  if (ymax > 4000 && m_isLegacyTopo) {
    ymax_new = 4000;
    biny_new = 200;
  }
  else {ymax_new = 1.5*ymax;}
 
  
  // if angular kinematics, use fixed range
  int eta_max = 50;
  int phi_max = 64;
  int dr_max = 30;
  if (not m_isLegacyTopo) {
    eta_max *= 4;
    phi_max *= 2;
    dr_max *= 4;
  }
 
  if ( xName.find("ETA") != std::string::npos ){
    xmin_new=-eta_max;
    xmax_new=eta_max;
  }
  if ( yName.find("ETA") != std::string::npos ){
    ymin_new=-eta_max;
    ymax_new=eta_max;
  }
  if ( xName.find("PHI") != std::string::npos || xName.find("DPHI") != std::string::npos ){
    xmin_new=0;
    xmax_new=phi_max;
  }
  if ( yName.find("PHI") != std::string::npos || yName.find("DPHI") != std::string::npos ){
    ymin_new=0;
    ymax_new=phi_max;
  }
  if ( xName.find("DETA") != std::string::npos || xName.find("DR") != std::string::npos ){
    xmin_new=0;
    xmax_new=dr_max;
  }
  if ( yName.find("DETA") != std::string::npos || yName.find("DR") != std::string::npos ){
    ymin_new=0;
    ymax_new=dr_max;
  }
 
  TH2 *h = new TH2F(newName.c_str(), newTitle.c_str(), binx_new, xmin_new, xmax_new, biny_new, ymin_new, ymax_new);
  h->GetXaxis()->SetTitle(xTitle.c_str());
  h->GetYaxis()->SetTitle(yTitle.c_str());
  m_impl->registerHist(h);
}

bookHistMult() [1/2]

void ConfigurableAlg::bookHistMult ( std::vector< std::string > & regName, const std::string & name, const std::string & title, const std::string & xtitle, const int binx, const int xmin, const int xmax )

inherited

Definition at line 338 of file ConfigurableAlg.cxx.

                                                                                                                                                                                        {
 
  regName.push_back(m_name+"/"+name);
 
  TH1 *h = new TH1F(name.c_str(), title.c_str(), binx, xmin, xmax);
  h->GetXaxis()->SetTitle(xtitle.c_str());
  m_impl->registerHist(h);
}

bookHistMult() [2/2]

void ConfigurableAlg::bookHistMult ( std::vector< std::string > & regName, const std::string & name, const std::string & title, const std::string & xtitle, const std::string & ytitle, const int binx, const int xmin, const int xmax, const int biny, const int ymin, const int ymax )

inherited

Definition at line 457 of file ConfigurableAlg.cxx.

                                                                                                                                                                                                                                                                   {
 
  regName.push_back(m_name+"/"+name);
 
  TH2 *h = new TH2F(name.c_str(), title.c_str(), binx, xmin, xmax, biny, ymin, ymax);
  h->GetXaxis()->SetTitle(xtitle.c_str());
  h->GetYaxis()->SetTitle(ytitle.c_str());
  m_impl->registerHist(h);
}

calcDeltaEta()

unsigned int ConfigurableAlg::calcDeltaEta ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 173 of file ConfigurableAlg.cxx.

                                                                                  {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcDeltaEtaLegacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcDeltaEta(tob1,tob2);}
}

calcDeltaEtaBW()

unsigned int ConfigurableAlg::calcDeltaEtaBW ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 128 of file ConfigurableAlg.cxx.

                                                                                    {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcDeltaEtaBWLegacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcDeltaEtaBW(tob1,tob2);}
}

calcDeltaPhi()

unsigned int ConfigurableAlg::calcDeltaPhi ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 165 of file ConfigurableAlg.cxx.

                                                                                  {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcDeltaPhiLegacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcDeltaPhi(tob1,tob2);}
}

calcDeltaPhiBW()

unsigned int ConfigurableAlg::calcDeltaPhiBW ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 120 of file ConfigurableAlg.cxx.

                                                                                    {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcDeltaPhiBWLegacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcDeltaPhiBW(tob1,tob2);}
}

calcDeltaR2()

unsigned int ConfigurableAlg::calcDeltaR2 ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 191 of file ConfigurableAlg.cxx.

                                                                                 {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcDeltaR2Legacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcDeltaR2(tob1,tob2);}
}

calcDeltaR2BW()

unsigned int ConfigurableAlg::calcDeltaR2BW ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 152 of file ConfigurableAlg.cxx.

                                                                                   {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcDeltaR2BWLegacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcDeltaR2BW(tob1,tob2);}
}

calcInvMass()

unsigned int ConfigurableAlg::calcInvMass ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 181 of file ConfigurableAlg.cxx.

                                                                                 {
  return TSU::Kinematics::calcInvMass(tob1,tob2);
}

calcInvMassBW()

unsigned int ConfigurableAlg::calcInvMassBW ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 136 of file ConfigurableAlg.cxx.

                                                                                   {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcInvMassBWLegacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcInvMassBW(tob1,tob2);}
}

calcTMass()

unsigned int ConfigurableAlg::calcTMass ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 186 of file ConfigurableAlg.cxx.

                                                                               {
  return TSU::Kinematics::calcTMass(tob1,tob2);
}

calcTMassBW()

unsigned int ConfigurableAlg::calcTMassBW ( const TCS::GenericTOB * tob1, const TCS::GenericTOB * tob2 )

inherited

Definition at line 144 of file ConfigurableAlg.cxx.

                                                                                 {
  if (m_isLegacyTopo)
    {return TSU::Kinematics::calcTMassBWLegacy(tob1,tob2);}
  else
    {return TSU::Kinematics::calcTMassBW(tob1,tob2);}
}

className()

const std::string & TCS::ConfigurableAlg::className ( ) const

inlineinherited

Definition at line 49 of file ConfigurableAlg.h.

{ return m_className; }

defineParameter() [1/3]

void ConfigurableAlg::defineParameter ( const Parameter & parameter )

privateinherited

Definition at line 213 of file ConfigurableAlg.cxx.

                                                            {
   if( parameters().contains( parameter.name(), parameter.selection() ) ) {
      TCS_EXCEPTION("Duplicate parameter definition '" << parameter.name() << "' for algorithm '" << name() << "'");
   }
   m_parameters.addParameter(parameter);
}

defineParameter() [2/3]

void ConfigurableAlg::defineParameter ( const std::string & name, TCS::parType_t value )

protectedinherited

Definition at line 201 of file ConfigurableAlg.cxx.

                                                                           {
   defineParameter( Parameter(name, value) );
}

defineParameter() [3/3]

void ConfigurableAlg::defineParameter ( const std::string & name, TCS::parType_t value, unsigned int selection )

protectedinherited

Definition at line 207 of file ConfigurableAlg.cxx.

                                                                                                   {
   defineParameter( Parameter(name, value, selection) );
}

doReset()

TCS::StatusCode TCS::DecisionAlg::doReset ( )

privatevirtualinherited

Implements TCS::ConfigurableAlg.

Definition at line 11 of file DecisionAlg.cxx.

                        {
   return StatusCode::SUCCESS;
}

fillHist1D()

void ConfigurableAlg::fillHist1D ( const std::string & histName, double x )

protectedinherited

Definition at line 467 of file ConfigurableAlg.cxx.

                                                                     {
  m_impl->fillHist1D(histName,x);
}

fillHist2D()

void ConfigurableAlg::fillHist2D ( const std::string & histName, double x, double y )

protectedinherited

Definition at line 471 of file ConfigurableAlg.cxx.

                                                                               {
  m_impl->fillHist2D(histName,x,y);
}

fillHistos()

bool TCS::DecisionAlg::fillHistos ( ) const

inherited

whether the monitoring histograms should be filled

Either we are filling based on the simulated decision, or based on the hdw decision with skipHistos==false.

Definition at line 100 of file DecisionAlg.cxx.

{
    return (not m_fillHistosBasedOnHardware or not m_skipHistos);
}

fillHistosBasedOnHardware()

bool TCS::DecisionAlg::fillHistosBasedOnHardware ( ) const

inherited

! getter

Definition at line 84 of file DecisionAlg.cxx.

{
    return m_fillHistosBasedOnHardware;
}

fullname()

std::string TCS::ConfigurableAlg::fullname ( ) const

inlineinherited

Definition at line 50 of file ConfigurableAlg.h.

{ return m_className + "/" + m_name; }

getDecisionHardwareBit()

bool TCS::DecisionAlg::getDecisionHardwareBit ( const unsigned int & bitNumber ) const

inherited

! get one hardware decision bit from this algo

Definition at line 52 of file DecisionAlg.cxx.

{
    bool value = false;
    if(bitNumber<m_numberOutputBits){
        value = (m_hardwareDecisionBits >> bitNumber) & 1;
    } else {
        TRG_MSG_WARNING("Cannot get hardware decision bit "<<bitNumber
                        <<" > "<<m_numberOutputBits<<" N output bits "
                        <<" for algo "<<name());
    }
    return value;
}

getName()

const std::string & TrigConf::TrigConfMessaging::getName ( ) const

inlineinherited

name accessor

Returns

the name

Definition at line 101 of file TrigConfMessaging.h.

                                                           {
    return m_name;
  }

getOverflowHardwareBit()

bool TCS::DecisionAlg::getOverflowHardwareBit ( const unsigned int & bitNumber ) const

inherited

! get one hardware overflow bit from this algo

Definition at line 65 of file DecisionAlg.cxx.

{
    bool value = false;
    if(bitNumber<m_numberOutputBits){
        value = (m_hardwareOverflowBits >> bitNumber) & 1;
    } else {
        TRG_MSG_WARNING("Cannot get hardware overflow bit "<<bitNumber
                        <<" > "<<m_numberOutputBits<<" N output bits "
                        <<" for algo "<<name());
    }
    return value;
}

initialize()

TCS::StatusCode TCS::AnomalyDetectionBDT::initialize ( )

virtual

Reimplemented from TCS::ConfigurableAlg.

Definition at line 400 of file AnomalyDetectionBDT.cxx.

                                   {
   
   p_MaxTob = parameter("MaxTob").value(); 
   p_minEt1 = parameter("MinET1").value();
   p_minEt2 = parameter("MinET2").value();
   for (size_t i=0; i <numberOutputBits(); ++i) {
      p_ScoreThreshold[i] = parameter("ScoreThreshold", i).value();
   }
   TRG_MSG_INFO("ADBDT: Threshold set to " << p_ScoreThreshold);
   const std::string bdtfn = "TrigAnomalyDetectionBDT/2025-06-18/fwX-config_nomAD_Jun3_2pi200t20d.json";
   
   std::string fileLocation;
   
   #ifndef TRIGCONF_STANDALONE
   fileLocation = PathResolver::find_calib_file(bdtfn);
   #else
   return StatusCode::SUCCESS;
   #endif 
   // Reading in the config
   std::ifstream configFile(fileLocation); 
 
   if (!configFile.is_open()) {
      TRG_MSG_ERROR("Unable to open BDT configuration file." << fileLocation);
      return StatusCode::FAILURE;
   }
 
   nlohmann::json bdt_config;    // BDT configuration 
   configFile >> bdt_config;
   m_nVar = bdt_config["nDim"];
   m_mu1_ptmin = bdt_config["variable_float_ranges"]["flat_dimu_mu1_pt_100MeV"]["min"];
   m_mu1_ptmax = bdt_config["variable_float_ranges"]["flat_dimu_mu1_pt_100MeV"]["max"];
   m_mu1_etamin = bdt_config["variable_float_ranges"]["flat_dimu_mu1_eta"]["min"];
   m_mu1_etamax = bdt_config["variable_float_ranges"]["flat_dimu_mu1_eta"]["max"];
   m_mu1_phimin = bdt_config["variable_float_ranges"]["flat_dimu_mu1_phi_2pi"]["min"];
   m_mu1_phimax = bdt_config["variable_float_ranges"]["flat_dimu_mu1_phi_2pi"]["max"];
   m_mu2_ptmin = bdt_config["variable_float_ranges"]["flat_dimu_mu2_pt_100MeV"]["min"];
   m_mu2_ptmax = bdt_config["variable_float_ranges"]["flat_dimu_mu2_pt_100MeV"]["max"];
   m_mu2_etamin = bdt_config["variable_float_ranges"]["flat_dimu_mu2_eta"]["min"];
   m_mu2_etamax = bdt_config["variable_float_ranges"]["flat_dimu_mu2_eta"]["max"];
   m_mu2_phimin = bdt_config["variable_float_ranges"]["flat_dimu_mu2_phi_2pi"]["min"];
   m_mu2_phimax = bdt_config["variable_float_ranges"]["flat_dimu_mu2_phi_2pi"]["max"];
 
   for (auto& [treeName, tree] : bdt_config["trees"].items()) {
      m_trees.emplace_back(tree, m_nVar);
   }
 
   TRG_MSG_DEBUG("In initialize. There are " << m_trees.size() << " trees for AnomalyDetectionBDT.");
 
   //Setting simulation mode.
   //This can be set to "lut" or to "math" 
   //"lut" mimics exactly what is done in firmware
   m_sim_mode = "lut"; 
   TRG_MSG_INFO("The sim_mode is " << m_sim_mode);
 
   //Booking histograms
   for (size_t i=0; i<numberOutputBits(); ++i) {
      std::string hname_accept = "hAnomalyDetecionBDT_accept_bit"+std::to_string((int)i);
      std::string hname_reject = "hAnomalyDetecionBDT_reject_bit"+std::to_string((int)i);
   
      bookHist(m_histAccept, hname_accept, "AnomalyScore", 100, 0, 128);
      bookHist(m_histReject, hname_reject, "AnomalyScore", 100, 0, 128); 
   }
   return StatusCode::SUCCESS;
}

isCountingAlg()

bool TCS::ConfigurableAlg::isCountingAlg ( ) const

inlineinherited

Definition at line 64 of file ConfigurableAlg.h.

{ return m_algType == COUNT; }

isDecisionAlg()

bool TCS::ConfigurableAlg::isDecisionAlg ( ) const

inlineinherited

Definition at line 62 of file ConfigurableAlg.h.

{ return m_algType == DECISION; }

isLegacyTopo()

bool TCS::ConfigurableAlg::isLegacyTopo ( ) const

inlineinherited

Definition at line 66 of file ConfigurableAlg.h.

{ return m_isLegacyTopo; }

isocut() [1/2]

bool ConfigurableAlg::isocut ( const std::string & threshold, const unsigned int bit ) const

protectedinherited

Definition at line 484 of file ConfigurableAlg.cxx.

                                                                                {
  unsigned int value = 0;
  if (threshold == "None") {value = 0;}
  else if (threshold == "Loose") {value = 1;}
  else if (threshold == "Medium") {value = 2;}
  else if (threshold == "HadMedium") {value = 2;}
  else if (threshold == "Tight") {value = 3;}
  else {
    TRG_MSG_WARNING("No isolation defined as " << threshold);
  }
  
  if (bit >= value) {return true;}
  else {return false;}
}

isocut() [2/2]

bool ConfigurableAlg::isocut ( const unsigned int threshold, const unsigned int bit ) const

protectedinherited

Definition at line 500 of file ConfigurableAlg.cxx.

                                                                                  {
  if (bit >= threshold) {return true;}
  else {return false;}
}

isSortingAlg()

bool TCS::ConfigurableAlg::isSortingAlg ( ) const

inlineinherited

Definition at line 60 of file ConfigurableAlg.h.

{ return m_algType == SORT; }

msg() [1/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 86 of file TrigConfMessaging.h.

  {
    MsgStreamTC* ms = m_msg_tls.get();
    if (!ms) {
      ms = new MsgStreamTC(m_name);
      m_msg_tls.reset(ms);
    }
    return *ms;
  }

msg() [2/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( const MSGTC::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 96 of file TrigConfMessaging.h.

  {
    return msg() << lvl;
  }

msgLvl()

bool TrigConf::TrigConfMessaging::msgLvl ( const MSGTC::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 75 of file TrigConfMessaging.h.

  {
    if (msg().level() <= lvl) {
      msg() << lvl;
      return true;
    }
    else {
      return false;
    }
  }

name()

const std::string & TCS::ConfigurableAlg::name ( ) const

inlineinherited

Definition at line 48 of file ConfigurableAlg.h.

{ return m_name; }

numberOutputBits()

unsigned int TCS::DecisionAlg::numberOutputBits ( ) const

inlineinherited

Definition at line 39 of file DecisionAlg.h.

{ return m_numberOutputBits; }

parameter() [1/2]

const TCS::Parameter & ConfigurableAlg::parameter ( const std::string & parameterName ) const

inherited

Definition at line 243 of file ConfigurableAlg.cxx.

                                                                {
   return parameters().parameter(parameterName);
}

parameter() [2/2]

const TCS::Parameter & ConfigurableAlg::parameter ( const std::string & parameterName, unsigned int selection ) const

inherited

Definition at line 249 of file ConfigurableAlg.cxx.

                                                                                        {
   return parameters().parameter(parameterName, selection);
}

parameters()

const ParameterSpace & TCS::ConfigurableAlg::parameters ( ) const

inlineinherited

Definition at line 87 of file ConfigurableAlg.h.

{ return m_parameters; }

process()

TCS::StatusCode TCS::AnomalyDetectionBDT::process ( const std::vector< TCS::TOBArray const * > & input, const std::vector< TCS::TOBArray * > & output, Decision & decision )

virtual

Implements TCS::DecisionAlg.

Definition at line 615 of file AnomalyDetectionBDT.cxx.

                                                                    {
#ifdef TRIGCONF_STANDALONE
  return StatusCode::SUCCESS;
#endif
   TCS::StatusCode status = processBitCorrect(input,output,decision);
   if (!status.isSuccess()){
      return status;
   }    
    
   // Check if totalScore exceeds the bits that we expect
   if (m_totalScore >= (1L << 8)) {
      TRG_MSG_WARNING("ADBDT:The calculated anomaly score exceeds the allowed number of bits.");
   }
 
    return TCS::StatusCode::SUCCESS;
}

processBitCorrect()

TCS::StatusCode TCS::AnomalyDetectionBDT::processBitCorrect ( const std::vector< TCS::TOBArray const * > & input, const std::vector< TCS::TOBArray * > & output, Decision & decision )

virtual

Implements TCS::DecisionAlg.

Definition at line 466 of file AnomalyDetectionBDT.cxx.

                                                                 {
   
   if (input.size() != 1){
      TCS_EXCEPTION("ADBDT algorithm expects only one TOBArray input (muons), but got " << input.size());
   }
 
   const TCS::TOBArray* muons = input[0];
   
   //Reading in number of muons:
   TRG_MSG_DEBUG("There are " << muons->size() << " muons."); 
   
   if (muons->size() < 2) {
      TRG_MSG_DEBUG("There are less than 2 muons. Skipping event.");
      m_totalScore = 0;
      return StatusCode::SUCCESS;
   }
   
   bool hasAmbiguousInputs = TSU::isAmbiguousAnywhere(muons, p_MaxTob, std::min(p_minEt1, p_minEt2));
   
   int64_t maxScore = 0;
   
   size_t nMuons = p_MaxTob > 0 ? std::min(muons->size(), p_MaxTob) : muons->size();
   //We define muon pairs based on the 2-3 leading muons
   std::vector<std::pair<int, int>> muonPairs;
   for (size_t i = 0; i < nMuons; ++i) {
     for (size_t j = i+1; j < nMuons; ++j) {
       muonPairs.emplace_back(i, j);
     }
   }
   
   for (const auto& [i,j] : muonPairs) {
 
      std::vector<int64_t> eventValues;
    
      const auto& mu1 = (*muons)[i];
      const auto& mu2 = (*muons)[j];
      
      //ignore combinations failing minET cuts
      if ( parType_t( mu1.Et() ) <= p_minEt1 ) continue; 
      if ( parType_t( mu2.Et() ) <= p_minEt2 ) continue; 
      
      if (scale(mu1.Et(),m_mu1_ptmin, m_mu1_ptmax) != mapval(mu1.Et(), "pt") 
              || scale(mu1.eta()/40.0, m_mu1_etamin, m_mu1_etamax) != mapval(mu1.eta(), "eta")
          || scale(mu1.phi()/20.0, m_mu1_phimin, m_mu1_phimax) != mapval(mu1.phi(), "phi")
              || scale(mu2.Et(),m_mu2_ptmin, m_mu2_ptmax) != mapval(mu2.Et(), "pt")
          || scale(mu2.eta()/40.0, m_mu2_etamin, m_mu2_etamax) != mapval(mu2.eta(), "eta")
              || scale(mu2.phi()/20.0, m_mu2_phimin, m_mu2_phimax) != mapval(mu2.phi(), "phi")){
 
         TRG_MSG_WARNING("The math function for the mapping of Muon pt,eta,or phi does not match the LUT mapping. Check LUT, 'scale' function, or if illegal vartype was given to 'mapval' function");
      
      }  
     
      if (mapval(mu1.Et(), "pt") == int(mu1.Et()) || mapval(mu2.Et(), "pt") == int(mu2.Et())) {
     
         TRG_MSG_WARNING("No input transformation done by LUT for muon ET");
     
      }
      
      if (mapval(mu1.eta(), "eta") == mu1.eta() || mapval(mu2.eta(), "eta") == mu2.eta()) {
     
         TRG_MSG_WARNING("No input transformation done by LUT for muon Eta");
     
      }
 
      if (mapval(mu1.phi(), "phi") == mu1.phi() || mapval(mu2.phi(), "phi") == mu2.phi()) {
     
         
     TRG_MSG_DEBUG("No input transformation done by LUT for muon Phi"); //Not a warning, since current transformation for phi
                                        //does not change the value except for one input number
      }
 
      if (m_sim_mode == "math"){
         eventValues.push_back(scale(mu1.Et(), m_mu1_ptmin, m_mu1_ptmax)); // muon pT (100MeV)
         eventValues.push_back(scale(mu1.eta()/40.0, m_mu1_etamin, m_mu1_etamax)); // muon eta (25mrad)
         eventValues.push_back(scale(mu1.phi()/20.0, m_mu1_phimin, m_mu1_phimax)); // muon phi (50mrad)
         
         eventValues.push_back(scale(mu2.Et(), m_mu2_ptmin, m_mu2_ptmax)); // muon pT (100MeV)
         eventValues.push_back(scale(mu2.eta()/40.0, m_mu2_etamin, m_mu2_etamax)); // muon eta (25mrad)
         eventValues.push_back(scale(mu2.phi()/20.0, m_mu2_phimin, m_mu2_phimax)); // muon phi (50mrad)
      }
    
      else if(m_sim_mode == "lut"){
         eventValues.push_back(mapval(mu1.Et(), "pt")); 
         eventValues.push_back(mapval(mu1.eta(), "eta")); 
         eventValues.push_back(mapval(mu1.phi(), "phi")); 
         
         eventValues.push_back(mapval(mu2.Et(), "pt")); 
         eventValues.push_back(mapval(mu2.eta(), "eta")); 
         eventValues.push_back(mapval(mu2.phi(), "phi")); 
      }
      
      else{
         eventValues.push_back(scale(mu1.Et(), m_mu1_ptmin, m_mu1_ptmax)); // muon pT (100MeV)
         eventValues.push_back(scale(mu1.eta()/40.0, m_mu1_etamin, m_mu1_etamax)); // muon eta (25mrad)
         eventValues.push_back(scale(mu1.phi()/20.0, m_mu1_phimin, m_mu1_phimax)); // muon phi (50mrad)
         
         eventValues.push_back(scale(mu2.Et(), m_mu2_ptmin, m_mu2_ptmax)); // muon pT (100MeV)
         eventValues.push_back(scale(mu2.eta()/40.0, m_mu2_etamin, m_mu2_etamax)); // muon eta (25mrad)
         eventValues.push_back(scale(mu2.phi()/20.0, m_mu2_phimin, m_mu2_phimax)); // muon phi (50mrad)
      }
   
      // calculate the score as sum of score from all trees
      int64_t score = 0;
      for (Tree tree : m_trees) {
         score += tree.getTreeScore(eventValues);
      }
    
      // from all muon combinations keep the highest score 
      if (score > maxScore) {
         maxScore = score;
      }
   } 
    
   m_totalScore = maxScore; 
   TRG_MSG_DEBUG("Anomaly Score = " << m_totalScore);
 
   //Now, we compare and set the decision bit:
   for (size_t i=0; i<numberOutputBits(); ++i){
      bool accept = false;
      // const bool fillAccept = fillHistos() && (fillHistosBasedOnHardware() ? getDecisionHardwareBit(i) : accept);
      // const bool fillReject = fillHistos() && !fillAccept;
      // const bool alreadyFilled = decision.bit(i);
      
      if (m_totalScore > p_ScoreThreshold[i]) {
         accept = true;
         decision.setBit(i,true);
         for (size_t k = 0; k < 3 && k < muons->size(); ++k){
            output[i]->push_back((*muons)[k]);
         }
      }
      
      output[i]->setAmbiguityFlag(hasAmbiguousInputs);
      
      if(fillHistos()) {
         const bool fillAccept = fillHistosBasedOnHardware() ? getDecisionHardwareBit(i) : accept;
         if (fillAccept) {
            fillHist1D(m_histAccept[i], m_totalScore);
         } else {
            fillHist1D(m_histReject[i], m_totalScore);
         }
      }
 
      TRG_MSG_DEBUG("Decision for bit " << i << ": " <<(accept?"pass":"fail") << "with an anomaly score = " << m_totalScore << std::endl);    
   }
   return StatusCode::SUCCESS;
}

quadraticSumBW()

unsigned long ConfigurableAlg::quadraticSumBW ( int i1, int i2 )

inherited

Definition at line 160 of file ConfigurableAlg.cxx.

                                              {
  return TSU::Kinematics::quadraticSumBW(i1, i2);
}

registerHist() [1/2]

void ConfigurableAlg::registerHist ( TH1 * h )

protectedinherited

Definition at line 262 of file ConfigurableAlg.cxx.

                                          {
   m_impl->registerHist(h);
}

registerHist() [2/2]

void ConfigurableAlg::registerHist ( TH2 * h )

protectedinherited

Definition at line 266 of file ConfigurableAlg.cxx.

                                          {
   m_impl->registerHist(h);
}

reset()

StatusCode TCS::ConfigurableAlg::reset ( )

inlineinherited

Definition at line 58 of file ConfigurableAlg.h.

{ return doReset(); }

resetHardwareBits()

TCS::DecisionAlg & TCS::DecisionAlg::resetHardwareBits ( )

inherited

! reset all hardware bits for this algo

Definition at line 45 of file DecisionAlg.cxx.

{
    m_hardwareDecisionBits = 0;
    m_hardwareOverflowBits = 0;
    return *this;
}

setAlgoId()

void TCS::ConfigurableAlg::setAlgoId ( unsigned int algoId )

inlineinherited

Definition at line 93 of file ConfigurableAlg.h.

{ m_algoId = algoId; }

setClassName()

void TCS::ConfigurableAlg::setClassName ( const std::string & className )

inlineinherited

Definition at line 43 of file ConfigurableAlg.h.

{ m_className = className; }

setFillHistosBasedOnHardware()

TCS::DecisionAlg & TCS::DecisionAlg::setFillHistosBasedOnHardware ( const bool & value )

inherited

! toggle m_fillHistosBasedOnHardware

Definition at line 78 of file DecisionAlg.cxx.

{
    m_fillHistosBasedOnHardware = value;
    return *this;
}

setHardwareBits()

TCS::DecisionAlg & TCS::DecisionAlg::setHardwareBits ( const unsigned int & bitNumber, const bool & valueDecision, const bool & valueOverflow )

inherited

propagate the hardware decision bits for each output bit of this algo

These bits are used only to fill the monitoring histograms. They do not have any use in the L1TopoSimulation itself.

Definition at line 25 of file DecisionAlg.cxx.

{
    if(bitNumber<m_numberOutputBits){
        if(valueDecision)
            m_hardwareDecisionBits |= (1 << bitNumber);
        if(valueOverflow)
            m_hardwareOverflowBits |= (1 << bitNumber);
    } else if(bitNumber<32) {
        TRG_MSG_WARNING("Cannot set hardware bits for bit number "<<bitNumber
                        <<" > "<<m_numberOutputBits<<" N output bits "
                        <<" for algo "<<name());
    } else {
        TRG_MSG_WARNING("Cannot set hardware bits for bit number "<<bitNumber
                        <<" > 31 N output bits for algo "<<name());
    }
    return *this;
}

setL1TopoHistSvc()

void ConfigurableAlg::setL1TopoHistSvc ( std::shared_ptr< IL1TopoHistSvc > histSvc )

inherited

sets the external hist service

forwarding public interface

Definition at line 258 of file ConfigurableAlg.cxx.

                                                                            {
   m_impl->setL1TopoHistSvc(std::move(histSvc));
}

setLegacyMode()

void TCS::ConfigurableAlg::setLegacyMode ( bool isLegacyTopo )

inlineinherited

Definition at line 45 of file ConfigurableAlg.h.

{m_isLegacyTopo=isLegacyTopo;}

setNumberOutputBits()

void TCS::DecisionAlg::setNumberOutputBits ( unsigned int numberOutputBits )

inlineinherited

Definition at line 40 of file DecisionAlg.h.

{ m_numberOutputBits = numberOutputBits; }

setParameters()

void ConfigurableAlg::setParameters ( const ParameterSpace & parameters )

inherited

Definition at line 222 of file ConfigurableAlg.cxx.

                                                                {
   
   // check if parameterspace is for this algorithm
   if(name() != parameters.algName()) {
      TCS_EXCEPTION("Name of parameter set (" << parameters.algName() << ") do not match configurable name (" << name() << ")" );
   }
 
   // copy parameters
   for(const Parameter & p : parameters) {
      try {
         m_parameters.setParameter(p);
      }
      catch(const TCS::Exception& e) {
         TCS_EXCEPTION("Algorithm configuration failed for " << name() << "! Caught exception: " << e.what());
      }
   }
}

setSkipHistos()

TCS::DecisionAlg & TCS::DecisionAlg::setSkipHistos ( const bool & value )

inherited

! toggle m_skipHistos (see TopoSteering::setOutputAlgosSkipHistograms)

Definition at line 89 of file DecisionAlg.cxx.

{
    m_skipHistos = value;
    return *this;
}

skipHistos()

bool TCS::DecisionAlg::skipHistos ( ) const

inherited

! getter

Definition at line 95 of file DecisionAlg.cxx.

{
    return m_skipHistos;
}

ToString()

std::string ConfigurableAlg::ToString ( const int val )

privateinherited

Definition at line 475 of file ConfigurableAlg.cxx.

{
  const int val_int = static_cast<int>(val);
  std::ostringstream temp;
  temp << val_int;
  return temp.str();
}

Member Data Documentation

m_algoId

unsigned int TCS::ConfigurableAlg::m_algoId {0}

privateinherited

Definition at line 138 of file ConfigurableAlg.h.

{0};

m_algType

AlgType TCS::ConfigurableAlg::m_algType

privateinherited

Definition at line 142 of file ConfigurableAlg.h.

m_className

std::string TCS::ConfigurableAlg::m_className {""}

privateinherited

Definition at line 135 of file ConfigurableAlg.h.

{""};

m_fillHistosBasedOnHardware

bool TCS::DecisionAlg::m_fillHistosBasedOnHardware {0}

privateinherited

! fill accept/reject monitoring histos based on hdw decision

Definition at line 100 of file DecisionAlg.h.

{0};

m_hardwareDecisionBits

uint32_t TCS::DecisionAlg::m_hardwareDecisionBits {0}

privateinherited

! decision bits from hardware (assume the algo won't have >31 output bits)

Definition at line 96 of file DecisionAlg.h.

{0};

m_hardwareOverflowBits

uint32_t TCS::DecisionAlg::m_hardwareOverflowBits {0}

privateinherited

! overflow bits from hardware (assume the algo won't have >31 output bits)

Definition at line 98 of file DecisionAlg.h.

{0};

m_histAccept

std::vector<std::string> TCS::DecisionAlg::m_histAccept

protectedinherited

Definition at line 73 of file DecisionAlg.h.

m_histAcceptEta1Eta2

std::vector<std::string> TCS::DecisionAlg::m_histAcceptEta1Eta2

protectedinherited

Definition at line 79 of file DecisionAlg.h.

m_histAcceptEta2Eta3

std::vector<std::string> TCS::DecisionAlg::m_histAcceptEta2Eta3

protectedinherited

Definition at line 81 of file DecisionAlg.h.

m_histAcceptEta3Eta1

std::vector<std::string> TCS::DecisionAlg::m_histAcceptEta3Eta1

protectedinherited

Definition at line 83 of file DecisionAlg.h.

m_histAcceptM

std::vector<std::string> TCS::DecisionAlg::m_histAcceptM

protectedinherited

Definition at line 75 of file DecisionAlg.h.

m_histAcceptX

std::vector<std::string> TCS::DecisionAlg::m_histAcceptX

protectedinherited

Definition at line 77 of file DecisionAlg.h.

m_histReject

std::vector<std::string> TCS::DecisionAlg::m_histReject

protectedinherited

Definition at line 74 of file DecisionAlg.h.

m_histRejectEta1Eta2

std::vector<std::string> TCS::DecisionAlg::m_histRejectEta1Eta2

protectedinherited

Definition at line 80 of file DecisionAlg.h.

m_histRejectEta2Eta3

std::vector<std::string> TCS::DecisionAlg::m_histRejectEta2Eta3

protectedinherited

Definition at line 82 of file DecisionAlg.h.

m_histRejectEta3Eta1

std::vector<std::string> TCS::DecisionAlg::m_histRejectEta3Eta1

protectedinherited

Definition at line 84 of file DecisionAlg.h.

m_histRejectM

std::vector<std::string> TCS::DecisionAlg::m_histRejectM

protectedinherited

Definition at line 76 of file DecisionAlg.h.

m_histRejectX

std::vector<std::string> TCS::DecisionAlg::m_histRejectX

protectedinherited

Definition at line 78 of file DecisionAlg.h.

m_impl

std::unique_ptr<ConfigurableAlgImpl> TCS::ConfigurableAlg::m_impl

privateinherited

Definition at line 129 of file ConfigurableAlg.h.

m_isLegacyTopo

bool TCS::ConfigurableAlg::m_isLegacyTopo

privateinherited

Definition at line 144 of file ConfigurableAlg.h.

m_msg_tls

boost::thread_specific_ptr<MsgStreamTC> TrigConf::TrigConfMessaging::m_msg_tls

mutableprivateinherited

MsgStreamTC instance (a std::cout like with print-out levels)

Definition at line 71 of file TrigConfMessaging.h.

m_mu1_etamax

float TCS::AnomalyDetectionBDT::m_mu1_etamax {0}

private

Definition at line 68 of file AnomalyDetectionBDT.h.

{0}, m_mu1_ptmax{0}, m_mu1_etamin{0}, m_mu1_etamax{0}, m_mu1_phimin{0}, m_mu1_phimax{0}; // range of the first muon

m_mu1_etamin

float TCS::AnomalyDetectionBDT::m_mu1_etamin {0}

private

Definition at line 68 of file AnomalyDetectionBDT.h.

{0}, m_mu1_ptmax{0}, m_mu1_etamin{0}, m_mu1_etamax{0}, m_mu1_phimin{0}, m_mu1_phimax{0}; // range of the first muon

m_mu1_phimax

float TCS::AnomalyDetectionBDT::m_mu1_phimax {0}

private

Definition at line 68 of file AnomalyDetectionBDT.h.

{0}, m_mu1_ptmax{0}, m_mu1_etamin{0}, m_mu1_etamax{0}, m_mu1_phimin{0}, m_mu1_phimax{0}; // range of the first muon

m_mu1_phimin

float TCS::AnomalyDetectionBDT::m_mu1_phimin {0}

private

Definition at line 68 of file AnomalyDetectionBDT.h.

{0}, m_mu1_ptmax{0}, m_mu1_etamin{0}, m_mu1_etamax{0}, m_mu1_phimin{0}, m_mu1_phimax{0}; // range of the first muon

m_mu1_ptmax

float TCS::AnomalyDetectionBDT::m_mu1_ptmax {0}

private

Definition at line 68 of file AnomalyDetectionBDT.h.

{0}, m_mu1_ptmax{0}, m_mu1_etamin{0}, m_mu1_etamax{0}, m_mu1_phimin{0}, m_mu1_phimax{0}; // range of the first muon

m_mu1_ptmin

float TCS::AnomalyDetectionBDT::m_mu1_ptmin {0}

private

Definition at line 68 of file AnomalyDetectionBDT.h.

{0}, m_mu1_ptmax{0}, m_mu1_etamin{0}, m_mu1_etamax{0}, m_mu1_phimin{0}, m_mu1_phimax{0}; // range of the first muon

m_mu2_etamax

float TCS::AnomalyDetectionBDT::m_mu2_etamax {0}

private

Definition at line 69 of file AnomalyDetectionBDT.h.

{0}, m_mu2_ptmax{0}, m_mu2_etamin{0}, m_mu2_etamax{0}, m_mu2_phimin{0}, m_mu2_phimax{0}; // range of the second muon

m_mu2_etamin

float TCS::AnomalyDetectionBDT::m_mu2_etamin {0}

private

Definition at line 69 of file AnomalyDetectionBDT.h.

{0}, m_mu2_ptmax{0}, m_mu2_etamin{0}, m_mu2_etamax{0}, m_mu2_phimin{0}, m_mu2_phimax{0}; // range of the second muon

m_mu2_phimax

float TCS::AnomalyDetectionBDT::m_mu2_phimax {0}

private

Definition at line 69 of file AnomalyDetectionBDT.h.

{0}, m_mu2_ptmax{0}, m_mu2_etamin{0}, m_mu2_etamax{0}, m_mu2_phimin{0}, m_mu2_phimax{0}; // range of the second muon

m_mu2_phimin

float TCS::AnomalyDetectionBDT::m_mu2_phimin {0}

private

Definition at line 69 of file AnomalyDetectionBDT.h.

{0}, m_mu2_ptmax{0}, m_mu2_etamin{0}, m_mu2_etamax{0}, m_mu2_phimin{0}, m_mu2_phimax{0}; // range of the second muon

m_mu2_ptmax

float TCS::AnomalyDetectionBDT::m_mu2_ptmax {0}

private

Definition at line 69 of file AnomalyDetectionBDT.h.

{0}, m_mu2_ptmax{0}, m_mu2_etamin{0}, m_mu2_etamax{0}, m_mu2_phimin{0}, m_mu2_phimax{0}; // range of the second muon

m_mu2_ptmin

float TCS::AnomalyDetectionBDT::m_mu2_ptmin {0}

private

Definition at line 69 of file AnomalyDetectionBDT.h.

{0}, m_mu2_ptmax{0}, m_mu2_etamin{0}, m_mu2_etamax{0}, m_mu2_phimin{0}, m_mu2_phimax{0}; // range of the second muon

m_name

std::string TCS::ConfigurableAlg::m_name {""}

privateinherited

Definition at line 134 of file ConfigurableAlg.h.

{""};

m_numberOutputBits

unsigned int TCS::DecisionAlg::m_numberOutputBits {1}

privateinherited

Definition at line 94 of file DecisionAlg.h.

{1};

m_nVar

int TCS::AnomalyDetectionBDT::m_nVar {0}

private

Definition at line 66 of file AnomalyDetectionBDT.h.

{0};              // dimension of the BDT

m_parameters

ParameterSpace TCS::ConfigurableAlg::m_parameters {""}

privateinherited

Definition at line 140 of file ConfigurableAlg.h.

{""};

m_sim_mode

std::string TCS::AnomalyDetectionBDT::m_sim_mode

private

Definition at line 70 of file AnomalyDetectionBDT.h.

m_skipHistos

bool TCS::DecisionAlg::m_skipHistos {0}

privateinherited

! skip filling monitoring histos, used only when m_fillHistosBasedOnHardware==true

Definition at line 102 of file DecisionAlg.h.

{0};

m_totalScore

int64_t TCS::AnomalyDetectionBDT::m_totalScore {0}

private

Definition at line 67 of file AnomalyDetectionBDT.h.

{0};    // score of the input event

m_trees

std::vector<Tree> TCS::AnomalyDetectionBDT::m_trees

private

Definition at line 65 of file AnomalyDetectionBDT.h.

p_MaxTob

size_t TCS::AnomalyDetectionBDT::p_MaxTob {3}

private

Definition at line 74 of file AnomalyDetectionBDT.h.

{3}; //Number of TOBs (e.g., 3 muon events)

p_minEt1

parType_t TCS::AnomalyDetectionBDT::p_minEt1 {0}

private

Definition at line 72 of file AnomalyDetectionBDT.h.

{0};

p_minEt2

parType_t TCS::AnomalyDetectionBDT::p_minEt2 {0}

private

Definition at line 73 of file AnomalyDetectionBDT.h.

{0};

p_ScoreThreshold

parType_t TCS::AnomalyDetectionBDT::p_ScoreThreshold[2] = { 0, 0 }

private

Definition at line 71 of file AnomalyDetectionBDT.h.

{ 0, 0 };

---

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

• AnomalyDetectionBDT.h
• AnomalyDetectionBDT.cxx