TCS::eEmSort Class Reference

#include <eEmSort.h>

Inheritance diagram for TCS::eEmSort:

Collaboration diagram for TCS::eEmSort:

Public Member Functions
	eEmSort (const std::string &name)
virtual	~eEmSort ()
virtual TCS::StatusCode	initialize () override
virtual TCS::StatusCode	sort (const InputTOBArray &input, TOBArray &output) override final
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 (std::string_view parameterName) const
const Parameter &	parameter (std::string_view 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, std::string_view name, std::string_view title, const int binx, const int xmin, const int xmax)
void	bookHist (std::vector< std::string > &regName, std::string_view name, std::string_view 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 (std::string_view name, TCS::parType_t value)
void	defineParameter (std::string_view 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
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_numberOfeEms = { 0 }
parType_t	m_minREta = { 0 }
parType_t	m_minRHad = { 0 }
parType_t	m_minWsTot = { 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 18 of file eEmSort.h.

Member Enumeration Documentation

AlgType

enum TCS::ConfigurableAlg::AlgType

protectedinherited

Enumerator
NONE
SORT
DECISION
COUNT

Definition at line 33 of file ConfigurableAlg.h.

{ NONE, SORT, DECISION, COUNT };

Constructor & Destructor Documentation

eEmSort()

TCS::eEmSort::eEmSort

(

const std::string &

name

)

Definition at line 22 of file eEmSort.cxx.

                                          : SortingAlg(name) {
   defineParameter( "InputWidth", 120 ); // for FW
   defineParameter( "InputWidth1stStage", 30 ); // for FW
   defineParameter( "OutputWidth", 6 );
   defineParameter( "REtaMin", 0 );
   defineParameter( "RHadMin", 0 );
   defineParameter( "WsTotMin", 0 );
   defineParameter( "MinEta", 0 );
   defineParameter( "MaxEta", 196 );
}

~eEmSort()

TCS::eEmSort::~eEmSort ( )

virtual

Definition at line 35 of file eEmSort.cxx.

{}

Member Function Documentation

algoId()

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

inlineinherited

Definition at line 54 of file ConfigurableAlg.h.

{ return m_algoId; }

bookHist() [1/2]

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

inherited

Definition at line 272 of file ConfigurableAlg.cxx.

                                                                                                                                                       {
  std::string xmin_str = ToString(xmin);
  std::string xmax_str = ToString(xmax);
  std::string newTitle{title};
  std::string newName{name};
 
  
  newName = newName+"_"+xmin_str+newTitle+xmax_str;
  newTitle = xmin_str+newTitle+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 += "#times10"; }
    if (title == "PT" || title == "ET" || title == "HT" || title == "INVM" || title == "MT")     { xTitle +=" [GeV]"; } 
  } 
  else {
    if (title == "ETA" || title == "DETA" || title == "DR")                                  { xTitle +="#times40"; }
    if (title == "PHI" || title == "DPHI")                                                   { xTitle +="#times20"; }
    if (title == "PT" || title == "ET" || title == "HT" || title == "INVM" || title == "MT") { xTitle +=" [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_view::npos ){
    xmin_new=-eta_max;
    xmax_new=eta_max;
  }
  if ( title.find("PHI") != std::string_view::npos || title.find("DPHI") != std::string_view::npos ){
    xmin_new=0;
    xmax_new=phi_max;
  }
  if ( title.find("DETA") != std::string_view::npos || title.find("DR") != std::string_view::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, std::string_view name, std::string_view title, const int binx, const int xmin, const int xmax, const int biny, const int ymin, const int ymax )

inherited

Definition at line 350 of file ConfigurableAlg.cxx.

                                                                                                                                                                                                       {
  auto usPos = title.find(" vs ");
  std::string xName;
  std::string yName;
  if (usPos != std::string_view::npos)[[likely]]{
    xName.assign(title.substr(0,usPos));
    yName.assign(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 = newName+"_"+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 341 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 464 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 175 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 130 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 167 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 122 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 193 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 154 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 183 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 138 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 188 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 146 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 50 of file ConfigurableAlg.h.

{ return m_className; }

defineParameter() [1/3]

void ConfigurableAlg::defineParameter ( const Parameter & parameter )

privateinherited

Definition at line 215 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 ( std::string_view name, TCS::parType_t value )

protectedinherited

Definition at line 203 of file ConfigurableAlg.cxx.

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

defineParameter() [3/3]

void ConfigurableAlg::defineParameter ( std::string_view name, TCS::parType_t value, unsigned int selection )

protectedinherited

Definition at line 209 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 474 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 478 of file ConfigurableAlg.cxx.

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

fullname()

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

inlineinherited

Definition at line 51 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::eEmSort::initialize ( )

overridevirtual

Reimplemented from TCS::ConfigurableAlg.

Definition at line 39 of file eEmSort.cxx.

                       {
   m_numberOfeEms = parameter("OutputWidth").value();
   m_minREta = parameter("REtaMin").value();
   m_minRHad = parameter("RHadMin").value();
   m_minWsTot = parameter("WsTotMin").value();
   return TCS::StatusCode::SUCCESS;
}

isCountingAlg()

bool TCS::ConfigurableAlg::isCountingAlg ( ) const

inlineinherited

Definition at line 65 of file ConfigurableAlg.h.

{ return m_algType == COUNT; }

isDecisionAlg()

bool TCS::ConfigurableAlg::isDecisionAlg ( ) const

inlineinherited

Definition at line 63 of file ConfigurableAlg.h.

{ return m_algType == DECISION; }

isLegacyTopo()

bool TCS::ConfigurableAlg::isLegacyTopo ( ) const

inlineinherited

Definition at line 67 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 491 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 507 of file ConfigurableAlg.cxx.

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

isSortingAlg()

bool TCS::ConfigurableAlg::isSortingAlg ( ) const

inlineinherited

Definition at line 61 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 49 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 ( std::string_view parameterName ) const

inherited

Definition at line 245 of file ConfigurableAlg.cxx.

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

parameter() [2/2]

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

inherited

Definition at line 251 of file ConfigurableAlg.cxx.

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

parameters()

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

inlineinherited

Definition at line 88 of file ConfigurableAlg.h.

{ return m_parameters; }

quadraticSumBW()

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

inherited

Definition at line 162 of file ConfigurableAlg.cxx.

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

registerHist() [1/2]

void ConfigurableAlg::registerHist ( TH1 * h )

protectedinherited

Definition at line 264 of file ConfigurableAlg.cxx.

                                          {
   m_impl->registerHist(h);
}

registerHist() [2/2]

void ConfigurableAlg::registerHist ( TH2 * h )

protectedinherited

Definition at line 268 of file ConfigurableAlg.cxx.

                                          {
   m_impl->registerHist(h);
}

reset()

StatusCode TCS::ConfigurableAlg::reset ( )

inlineinherited

Definition at line 59 of file ConfigurableAlg.h.

{ return doReset(); }

setAlgoId()

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

inlineinherited

Definition at line 94 of file ConfigurableAlg.h.

{ m_algoId = algoId; }

setClassName()

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

inlineinherited

Definition at line 44 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 260 of file ConfigurableAlg.cxx.

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

setLegacyMode()

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

inlineinherited

Definition at line 46 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 224 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::eEmSort::sort ( const InputTOBArray & input, TOBArray & output )

finaloverridevirtual

Implements TCS::SortingAlg.

Definition at line 49 of file eEmSort.cxx.

                                                               {
 
   const eEmTOBArray & eems = dynamic_cast<const eEmTOBArray&>(input);
 
   // fill output array with GenericTOB buildt from eEms
   for(eEmTOBArray::const_iterator eem = eems.begin(); eem!= eems.end(); ++eem ) {
 
      // isolation cut
      if ( !isocut(m_minREta, (*eem)-> Reta()) ) {continue;}
      if ( !isocut(m_minRHad, (*eem)-> Rhad()) ) {continue;}
      if ( !isocut(m_minWsTot, (*eem)-> Wstot()) ) {continue;}
      
      const GenericTOB gtob(**eem);
      output.push_back( gtob );
   }
 
   // sort
   output.sort(SortByEtLargesteEm);
   
 
   // keep only max number of eEms
   int par = m_numberOfeEms;
   unsigned int maxNumberOfeEms = std::clamp(par, 0, std::abs(par));
   if(maxNumberOfeEms>0) {
      while( output.size()> maxNumberOfeEms ) {
         if (output.size() == (maxNumberOfeEms+1)) {
            bool isAmbiguous = output[maxNumberOfeEms-1].EtDouble() == output[maxNumberOfeEms].EtDouble();
            if (isAmbiguous) { output.setAmbiguityFlag(true); }
         }
         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 482 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 139 of file ConfigurableAlg.h.

{0};

m_algType

AlgType TCS::ConfigurableAlg::m_algType

privateinherited

Definition at line 143 of file ConfigurableAlg.h.

m_className

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

privateinherited

Definition at line 136 of file ConfigurableAlg.h.

{""};

m_impl

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

privateinherited

Definition at line 130 of file ConfigurableAlg.h.

m_isLegacyTopo

bool TCS::ConfigurableAlg::m_isLegacyTopo

privateinherited

Definition at line 145 of file ConfigurableAlg.h.

m_minREta

parType_t TCS::eEmSort::m_minREta = { 0 }

private

Definition at line 32 of file eEmSort.h.

{ 0 };

m_minRHad

parType_t TCS::eEmSort::m_minRHad = { 0 }

private

Definition at line 33 of file eEmSort.h.

{ 0 };

m_minWsTot

parType_t TCS::eEmSort::m_minWsTot = { 0 }

private

Definition at line 34 of file eEmSort.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 135 of file ConfigurableAlg.h.

{""};

m_numberOfeEms

parType_t TCS::eEmSort::m_numberOfeEms = { 0 }

private

Definition at line 31 of file eEmSort.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 141 of file ConfigurableAlg.h.

{""};

---

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

• eEmSort.h
• eEmSort.cxx