TCS::JetNoSortMatch Class Reference

#include <JetNoSortMatch.h>

Inheritance diagram for TCS::JetNoSortMatch:

Collaboration diagram for TCS::JetNoSortMatch:

Public Member Functions
	JetNoSortMatch (const std::string &name)
virtual	~JetNoSortMatch ()
virtual TCS::StatusCode	initialize ()
virtual TCS::StatusCode	sort (const InputTOBArray &input, TOBArray &output)
virtual TCS::StatusCode	sortBitCorrect (const InputTOBArray &input, TOBArray &output)
bool	overflow () const
	whether an overlflow occurred
SortingAlg &	setOverflow (const bool v)
	setter, to propagate bit from input event
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
virtual StatusCode	doReset ()
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
JetTOB::JetSize	m_jetsize
bool	m_overflow
	whether an overflow occurred during the current execution.

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

Private Attributes
parType_t	m_numberOfJets = { 0 }
parType_t	m_jsize = { 0 }
parType_t	p_MinET1 = { 0 }
parType_t	p_MinET2 = { 0 }
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 20 of file JetNoSortMatch.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

JetNoSortMatch()

TCS::JetNoSortMatch::JetNoSortMatch

(

const std::string &

name

)

Definition at line 19 of file JetNoSortMatch.cxx.

                                                        :
   SortingAlg(name)
{
   defineParameter( "InputWidth", 64 ); // for FW
   defineParameter( "OutputWidth", 64 );
   defineParameter( "JetSize", 2 );
   defineParameter("MinET1",0);
   defineParameter("MinET2",0);
   m_jetsize = JetTOB::JS1;
}

~JetNoSortMatch()

TCS::JetNoSortMatch::~JetNoSortMatch ( )

virtual

Definition at line 31 of file JetNoSortMatch.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::SortingAlg::doReset ( )

protectedvirtualinherited

Implements TCS::ConfigurableAlg.

Definition at line 12 of file SortingAlg.cxx.

                       {
   m_overflow = false;
   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);
}

fullname()

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

inlineinherited

Definition at line 50 of file ConfigurableAlg.h.

{ return m_className + "/" + m_name; }

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;
  }

initialize()

TCS::StatusCode TCS::JetNoSortMatch::initialize ( )

virtual

Reimplemented from TCS::ConfigurableAlg.

Definition at line 35 of file JetNoSortMatch.cxx.

                              {
   m_numberOfJets = parameter("OutputWidth").value();
   m_jsize = parameter("JetSize").value();
   p_MinET1  = parameter("MinET1").value();
   p_MinET2  = parameter("MinET2").value();
       
   TRG_MSG_INFO("MinET1          : " << p_MinET1);
   TRG_MSG_INFO("MinET2          : " << p_MinET2);
   return TCS::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; }

overflow()

bool TCS::SortingAlg::overflow ( ) const

inlineinherited

whether an overlflow occurred

In practice propagate the overflow bits from the input collections

Definition at line 35 of file SortingAlg.h.

{ return m_overflow; }

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; }

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(); }

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; }

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;}

setOverflow()

SortingAlg & TCS::SortingAlg::setOverflow ( const bool v )

inlineinherited

setter, to propagate bit from input event

Definition at line 37 of file SortingAlg.h.

{ m_overflow = v; return *this; }

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());
      }
   }
}

sort()

TCS::StatusCode TCS::JetNoSortMatch::sort ( const InputTOBArray & input, TOBArray & output )

virtual

Implements TCS::SortingAlg.

Definition at line 50 of file JetNoSortMatch.cxx.

                                                                      {
   const JetTOBArray & jets = dynamic_cast<const JetTOBArray&>(input);
   // because fw seems to have a differnt notation, for now 2 means JS1 8x8
   m_jetsize = m_jsize==2?JetTOB::JS1:JetTOB::JS2; 
 
   // fill output array with GenericTOBs builds from jets
   for(JetTOBArray::const_iterator cl = jets.begin(); cl!= jets.end(); ++cl ) {
 
     if( parType_t((*cl)-> Et2())  <= p_MinET1 ) continue; // E_T cut on 4x4, ET1 relates with FW ordering, Et2 is Etsmall
     if( parType_t((*cl)-> Et1())  <= p_MinET2 ) continue; // E_T cut on 8x8  , ET2 relates with FW ordering, Et1 is Etlarge
 
     output.push_back( GenericTOB(**cl, m_jetsize) );
   }
 
 
   // keep only max number of jets
   int par = m_numberOfJets ;
   unsigned int maxNumberOfJets = std::clamp(par, 0, std::abs(par));
   if(maxNumberOfJets>0) {
      while( output.size()> maxNumberOfJets ) {
         output.pop_back();
      }
   }   
   return TCS::StatusCode::SUCCESS;
}

sortBitCorrect()

TCS::StatusCode TCS::SortingAlg::sortBitCorrect ( const InputTOBArray & input, TOBArray & output )

virtualinherited

Reimplemented in TCS::jXESort, and TCS::MetSort.

Definition at line 17 of file SortingAlg.cxx.

{
  return sort(input, output);
}

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_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_jetsize

JetTOB::JetSize TCS::JetNoSortMatch::m_jetsize

protected

Definition at line 41 of file JetNoSortMatch.h.

m_jsize

parType_t TCS::JetNoSortMatch::m_jsize = { 0 }

private

Definition at line 34 of file JetNoSortMatch.h.

{ 0 };   

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_name

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

privateinherited

Definition at line 134 of file ConfigurableAlg.h.

{""};

m_numberOfJets

parType_t TCS::JetNoSortMatch::m_numberOfJets = { 0 }

private

Definition at line 33 of file JetNoSortMatch.h.

{ 0 };

m_overflow

bool TCS::SortingAlg::m_overflow

protectedinherited

whether an overflow occurred during the current execution.

Definition at line 42 of file SortingAlg.h.

m_parameters

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

privateinherited

Definition at line 140 of file ConfigurableAlg.h.

{""};

p_MinET1

parType_t TCS::JetNoSortMatch::p_MinET1 = { 0 }

private

Definition at line 35 of file JetNoSortMatch.h.

{ 0 };

p_MinET2

parType_t TCS::JetNoSortMatch::p_MinET2 = { 0 }

private

Definition at line 36 of file JetNoSortMatch.h.

{ 0 };

---

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

• JetNoSortMatch.h
• JetNoSortMatch.cxx