TCS::InvariantMassInclusive1 Class Reference

#include <InvariantMassInclusive1.h>

Inheritance diagram for TCS::InvariantMassInclusive1:

Collaboration diagram for TCS::InvariantMassInclusive1:

Public Member Functions
	InvariantMassInclusive1 (const std::string &name)
virtual	~InvariantMassInclusive1 ()
virtual StatusCode	initialize ()
virtual StatusCode	processBitCorrect (const std::vector< TCS::TOBArray const * > &input, const std::vector< TCS::TOBArray * > &output, Decision &decison)
virtual StatusCode	process (const std::vector< TCS::TOBArray const * > &input, const std::vector< TCS::TOBArray * > &output, Decision &decison)
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
parType_t	p_NumberLeading1 = { 0 }
parType_t	p_NumberLeading2 = { 0 }
parType_t	p_InvMassMin [6] = {0, 0, 0,0,0,0}
parType_t	p_InvMassMax [6] = {0, 0, 0,0,0,0}
parType_t	p_MinET1 [6] = { 0 ,0,0,0,0,0}
parType_t	p_MinET2 [6] = { 0 ,0,0,0,0,0}
parType_t	p_OneBarrel = { 0 }
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 16 of file InvariantMassInclusive1.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

InvariantMassInclusive1()

TCS::InvariantMassInclusive1::InvariantMassInclusive1

(

const std::string &

name

)

Definition at line 30 of file InvariantMassInclusive1.cxx.

                                                                          : DecisionAlg(name)
{
   defineParameter("InputWidth", 3);
   defineParameter("MaxTob", 0); 
   defineParameter("NumResultBits", 6);
   defineParameter("RequireOneBarrel", 0);
   defineParameter("MinMSqr",  0, 0);
   defineParameter("MaxMSqr", 999, 0);
   defineParameter("MinMSqr",  0, 1);
   defineParameter("MaxMSqr",  999, 1);
   defineParameter("MinMSqr", 0, 2);
   defineParameter("MaxMSqr", 999, 2);
   defineParameter("MinMSqr", 0, 3);
   defineParameter("MaxMSqr", 999, 3);
   defineParameter("MinMSqr", 0, 4);
   defineParameter("MaxMSqr", 999, 4);
   defineParameter("MinMSqr", 0, 5);
   defineParameter("MaxMSqr", 999, 5);
   defineParameter("MinET1",0,0);
   defineParameter("MinET2",0,0);
   defineParameter("MinET1",0,1);
   defineParameter("MinET2",0,1);
   defineParameter("MinET1",0,2);
   defineParameter("MinET2",0,2);
   defineParameter("MinET1",0,3);
   defineParameter("MinET2",0,3);
   defineParameter("MinET1",0,4);
   defineParameter("MinET2",0,4);
   defineParameter("MinET1",0,5);
   defineParameter("MinET2",0,5);  
 
 
   setNumberOutputBits(6);
}

~InvariantMassInclusive1()

TCS::InvariantMassInclusive1::~InvariantMassInclusive1 ( )

virtual

Definition at line 65 of file InvariantMassInclusive1.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::InvariantMassInclusive1::initialize ( )

virtual

Reimplemented from TCS::ConfigurableAlg.

Definition at line 69 of file InvariantMassInclusive1.cxx.

                                       {
   if(parameter("MaxTob").value() > 0) {
      p_NumberLeading1 = parameter("MaxTob").value();
      p_NumberLeading2 = parameter("MaxTob").value();
   } else {
      p_NumberLeading1 = parameter("InputWidth").value();
      p_NumberLeading2 = parameter("InputWidth").value();
   }
 
   p_OneBarrel = parameter("RequireOneBarrel").value();
 
   for(unsigned int i=0; i<numberOutputBits(); ++i) {
      p_InvMassMin[i] = parameter("MinMSqr", i).value();
      p_InvMassMax[i] = parameter("MaxMSqr", i).value();
   
      p_MinET1[i] = parameter("MinET1",i).value();
      p_MinET2[i] = parameter("MinET2",i).value();
   }
   TRG_MSG_INFO("NumberLeading1 : " << p_NumberLeading1);
   TRG_MSG_INFO("NumberLeading2 : " << p_NumberLeading2);
   TRG_MSG_INFO("RequireOneBarrel : " << p_OneBarrel);
   for(unsigned int i=0; i<numberOutputBits(); ++i) {
      TRG_MSG_INFO("InvMassMin   : " << p_InvMassMin[i]);
      TRG_MSG_INFO("InvMassMax   : " << p_InvMassMax[i]);
 
   
      TRG_MSG_INFO("MinET1          : " << p_MinET1[i]);
      TRG_MSG_INFO("MinET2          : " << p_MinET2[i]);
   }
   TRG_MSG_INFO("number output : " << numberOutputBits());
 
   // book histograms
   for(unsigned int i=0; i<numberOutputBits(); ++i) {
       std::string hname_accept = "hInvariantMassInclusive1_accept_bit"+std::to_string((int)i);
       std::string hname_reject = "hInvariantMassInclusive1_reject_bit"+std::to_string((int)i);
       // mass
       bookHist(m_histAccept, hname_accept, "INVM", 100, sqrt(p_InvMassMin[i]), sqrt(p_InvMassMax[i]));
       bookHist(m_histReject, hname_reject, "INVM", 100, sqrt(p_InvMassMin[i]), sqrt(p_InvMassMax[i]));
   }
   
   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::InvariantMassInclusive1::process ( const std::vector< TCS::TOBArray const * > & input, const std::vector< TCS::TOBArray * > & output, Decision & decison )

virtual

Implements TCS::DecisionAlg.

Definition at line 177 of file InvariantMassInclusive1.cxx.

{
 
   if(input.size() == 1) {     
      for( TOBArray::const_iterator tob1 = input[0]->begin(); 
           tob1 != input[0]->end() && distance( input[0]->begin(), tob1) < p_NumberLeading1;
           ++tob1) 
         {
            
 
            TCS::TOBArray::const_iterator tob2 = tob1; ++tob2;      
            for( ;
                 tob2 != input[0]->end() && distance( input[0]->begin(), tob2) < p_NumberLeading2;
                 ++tob2) {
 
 
               // OneBarrel
               if (p_OneBarrel && parType_t(abs((*tob1)->eta())) > 10 && parType_t(abs((*tob2)->eta())) > 10 ) continue;
               
               // Inv Mass calculation
             
           unsigned int invmass2 = calcInvMass( *tob1, *tob2 );
 
 
               for(unsigned int i=0; i<numberOutputBits(); ++i) {
                   bool accept = false;
                  if( parType_t((*tob1)->Et()) <= std::min(p_MinET1[i],p_MinET2[i])) continue; // ET cut
                  if( parType_t((*tob2)->Et()) <= std::min(p_MinET1[i],p_MinET2[i])) continue; // ET cut
                  if( (parType_t((*tob1)->Et()) <= std::max(p_MinET1[i],p_MinET2[i])) && (parType_t((*tob2)->Et()) <= std::max(p_MinET1[i],p_MinET2[i]))) continue;
                  accept = invmass2 >= p_InvMassMin[i] && invmass2 <= p_InvMassMax[i]; // 
                  const bool fillAccept = fillHistos() and (fillHistosBasedOnHardware() ? getDecisionHardwareBit(i) : accept);
                  const bool fillReject = fillHistos() and not fillAccept;
                  const bool alreadyFilled = decision.bit(i);
                  if( accept ) {
                      decision.setBit(i, true);
                      output[i]->push_back( TCS::CompositeTOB(*tob1, *tob2) );
                  }
                  if(fillAccept and not alreadyFilled) {
                      fillHist1D(m_histAccept[i],sqrt((float)invmass2));
                  } else if(fillReject) {
                      fillHist1D(m_histReject[i],sqrt((float)invmass2));
                  }
                  TRG_MSG_DEBUG("Decision " << i << ": " << (accept?"pass":"fail") << " invmass2 = " << invmass2);
               }
            }
         }
   } else {
 
      TCS_EXCEPTION("InvariantMassInclusive1 alg must have either 1  inputs, but got " << input.size());
 
   }
 
   return TCS::StatusCode::SUCCESS;
}

processBitCorrect()

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

virtual

Implements TCS::DecisionAlg.

Definition at line 115 of file InvariantMassInclusive1.cxx.

{
 
   if(input.size() == 1) {     
     
      for( TOBArray::const_iterator tob1 = input[0]->begin(); 
           tob1 != input[0]->end() && distance( input[0]->begin(), tob1) < p_NumberLeading1;
           ++tob1) 
         {
            
 
            TCS::TOBArray::const_iterator tob2 = tob1; ++tob2;      
            for( ;
                 tob2 != input[0]->end() && distance( input[0]->begin(), tob2) < p_NumberLeading2;
                 ++tob2) {
 
 
               // OneBarrel
               if (p_OneBarrel && parType_t(abs((*tob1)->eta())) > 10 && parType_t(abs((*tob2)->eta())) > 10 ) continue;
               
               // Inv Mass calculation
               unsigned int invmass2 = calcInvMassBW( *tob1, *tob2 );
               for(unsigned int i=0; i<numberOutputBits(); ++i) {
                   bool accept = false;
                   if( parType_t((*tob1)->Et()) <= std::min(p_MinET1[i],p_MinET2[i])) continue; // ET cut
                   if( parType_t((*tob2)->Et()) <= std::min(p_MinET1[i],p_MinET2[i])) continue; // ET cut
                   if( (parType_t((*tob1)->Et()) <= std::max(p_MinET1[i],p_MinET2[i])) && (parType_t((*tob2)->Et()) <= std::max(p_MinET1[i],p_MinET2[i]))) continue;
                   accept = invmass2 >= p_InvMassMin[i] && invmass2 <= p_InvMassMax[i]; //
                   const bool fillAccept = fillHistos() and (fillHistosBasedOnHardware() ? getDecisionHardwareBit(i) : accept);
                   const bool fillReject = fillHistos() and not fillAccept;
                   const bool alreadyFilled = decision.bit(i);
                   if( accept ) {
                       decision.setBit(i, true);
                       output[i]->push_back( TCS::CompositeTOB(*tob1, *tob2) );
                   }
                   if(fillAccept and not alreadyFilled) {
                       fillHist1D(m_histAccept[i],sqrt((float)invmass2));
                   } else if(fillReject) {
                       fillHist1D(m_histReject[i],sqrt((float)invmass2));
                   }
                   TRG_MSG_DEBUG("Decision " << i << ": " << (accept?"pass":"fail") << " invmass2 = " << invmass2);
               }
            }
         }
         for (unsigned int i=0; i < numberOutputBits(); ++i) {
            bool hasAmbiguousInputs =  TSU::isAmbiguousTruncation(input[0], p_NumberLeading1, p_MinET1[i])
                                    || TSU::isAmbiguousTruncation(input[0], p_NumberLeading2, p_MinET2[i]);
            output[i]->setAmbiguityFlag(hasAmbiguousInputs);
         }
   } else {
 
      TCS_EXCEPTION("InvariantMassInclusive1 alg must have either 1  inputs, but got " << input.size());
 
   }
 
   return TCS::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_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_parameters

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

privateinherited

Definition at line 140 of file ConfigurableAlg.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};

p_InvMassMax

parType_t TCS::InvariantMassInclusive1::p_InvMassMax[6] = {0, 0, 0,0,0,0}

private

Definition at line 37 of file InvariantMassInclusive1.h.

{0, 0, 0,0,0,0};

p_InvMassMin

parType_t TCS::InvariantMassInclusive1::p_InvMassMin[6] = {0, 0, 0,0,0,0}

private

Definition at line 36 of file InvariantMassInclusive1.h.

{0, 0, 0,0,0,0};

p_MinET1

parType_t TCS::InvariantMassInclusive1::p_MinET1[6] = { 0 ,0,0,0,0,0}

private

Definition at line 38 of file InvariantMassInclusive1.h.

{ 0 ,0,0,0,0,0};

p_MinET2

parType_t TCS::InvariantMassInclusive1::p_MinET2[6] = { 0 ,0,0,0,0,0}

private

Definition at line 39 of file InvariantMassInclusive1.h.

{ 0 ,0,0,0,0,0};

p_NumberLeading1

parType_t TCS::InvariantMassInclusive1::p_NumberLeading1 = { 0 }

private

Definition at line 34 of file InvariantMassInclusive1.h.

{ 0 };

p_NumberLeading2

parType_t TCS::InvariantMassInclusive1::p_NumberLeading2 = { 0 }

private

Definition at line 35 of file InvariantMassInclusive1.h.

{ 0 };

p_OneBarrel

parType_t TCS::InvariantMassInclusive1::p_OneBarrel = { 0 }

private

Definition at line 40 of file InvariantMassInclusive1.h.

{ 0 };

---

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

• InvariantMassInclusive1.h
• InvariantMassInclusive1.cxx