#include <TrigThresholdDecisionTool.h>

Inheritance diagram for LVL1::TrigThresholdDecisionTool:

Collaboration diagram for LVL1::TrigThresholdDecisionTool:

Classes
struct	RPCFlagDecision

struct	TGCFlagDecision

Public Member Functions
	TrigThresholdDecisionTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	initialize () override

virtual StatusCode	start () override

virtual uint64_t	getPattern (const xAOD::MuonRoI &roi, const ThrVec &menuThresholds, const TrigConf::L1ThrExtraInfoBase &menuExtraInfo) const override

virtual uint64_t	getPattern (uint32_t dataWord, const ThrVec &menuThresholds, const TrigConf::L1ThrExtraInfoBase &menuExtraInfo) const

virtual std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > >	getThresholdDecisions (uint32_t dataWord, const EventContext &eventContext) const override

virtual std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > >	getThresholdDecisions (uint32_t dataWord, const ThrVec &menuThresholds, const TrigConf::L1ThrExtraInfoBase &menuExtraInfo) const override

virtual std::pair< std::string, double >	getMinThresholdNameAndValue (const std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > &decisions, const double &eta=0) const override

Protected Member Functions
bool	isExcludedRPCROI (const TrigConf::L1ThrExtraInfo_MU &menuExtraInfo, const std::string &rpcExclROIList, unsigned roi, unsigned sectorID, bool isSideC) const

bool	getTGCDecision (const std::string &tgcFlags, bool F, bool C, bool H) const

void	makeTGCDecision (const std::string &tgcFlags, bool F, bool C, bool H)

bool	getRPCDecision (const std::string &rpcFlags, bool M) const

void	makeRPCDecision (const std::string &rpcFlags, bool M)

void	parseFlags (const std::string &flags)

std::vector< std::string >	parseString (const std::string &str, const std::string &sep) const

std::string	getShapedFlags (const std::string &flags) const

Protected Attributes
ToolHandle< LVL1::ITrigT1MuonRecRoiTool >	m_rpcTool {this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"}

ToolHandle< LVL1::ITrigT1MuonRecRoiTool >	m_tgcTool {this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"}

std::map< std::string, std::vector< std::vector< std::string > > >	m_parsed_flags

std::map< std::string, std::set< TGCFlagDecision > >	m_tgcFlag_decisions

std::map< std::string, std::set< RPCFlagDecision > >	m_rpcFlag_decisions

Detailed Description

Definition at line 39 of file TrigThresholdDecisionTool.h.

Constructor & Destructor Documentation

◆ TrigThresholdDecisionTool()

LVL1::TrigThresholdDecisionTool::TrigThresholdDecisionTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 15 of file TrigThresholdDecisionTool.cxx.

18 : base_class(type, name, parent) {}

Member Function Documentation

◆ getMinThresholdNameAndValue()

std::pair< std::string, double > LVL1::TrigThresholdDecisionTool::getMinThresholdNameAndValue	(	const std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > &	decisions,
		const double &	eta = `0`
	)		const

overridevirtual

Definition at line 209 of file TrigThresholdDecisionTool.cxx.

   {
     //find the highest pt threshold passed - depite the name of this function
     std::string thrName="";
     double thrVal=0;
     for (unsigned idec=0;idec<decisions.size();++idec) {
       if (!decisions[idec].second) continue;
       std::shared_ptr<TrigConf::L1Threshold> thr = decisions[idec].first;
       if (thr->thrValue(eta) > thrVal)
     {
       thrVal = thr->thrValue(eta);
       thrName = thr->name();
     }
     }
     return std::make_pair(thrName, thrVal);
   }

◆ getPattern() [1/2]

uint64_t LVL1::TrigThresholdDecisionTool::getPattern	(	const xAOD::MuonRoI &	roi,
		const ThrVec &	menuThresholds,
		const TrigConf::L1ThrExtraInfoBase &	menuExtraInfo
	)		const

overridevirtual

Definition at line 78 of file TrigThresholdDecisionTool.cxx.

                                                                                                         {
     return getPattern(roi.roiWord(), menuThresholds, menuExtraInfo);
   }

◆ getPattern() [2/2]

uint64_t LVL1::TrigThresholdDecisionTool::getPattern	(	uint32_t	dataWord,
		const ThrVec &	menuThresholds,
		const TrigConf::L1ThrExtraInfoBase &	menuExtraInfo
	)		const

virtual

Definition at line 84 of file TrigThresholdDecisionTool.cxx.

                                                                                                         {
     uint64_t thresholdsPattern = 0;
  
     //first figure out if we need to use the RPC or TGC tool for decoding the ROI
     LVL1::ITrigT1MuonRecRoiTool::MuonTriggerSystem system = m_rpcTool->getSystem(dataWord);
     const LVL1::ITrigT1MuonRecRoiTool* roiTool;
     if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel) roiTool = &(*m_rpcTool);
     else roiTool = &(*m_tgcTool);
  
     //buffer the some information
     unsigned isub = roiTool->getBitMaskValue(&dataWord, roiTool->SubSysIDMask());
     LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem side = static_cast<LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem>(isub);
     unsigned ptword = roiTool->getBitMaskValue(&dataWord, roiTool->ThresholdMask());
     unsigned roi, sectorID;
     if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel) {
       roi      = roiTool->getBitMaskValue(&dataWord, roiTool->BarrelRoIMask());
       sectorID = roiTool->getBitMaskValue(&dataWord, roiTool->BarrelSectorIDMask());
     } else if (system == LVL1::ITrigT1MuonRecRoiTool::Endcap) {
       roi      = roiTool->getBitMaskValue(&dataWord, roiTool->EndcapRoIMask());
       sectorID = roiTool->getBitMaskValue(&dataWord, roiTool->EndcapSectorIDMask());
     } else { // Forward
       roi      = roiTool->getBitMaskValue(&dataWord, roiTool->ForwardRoIMask());
       sectorID = roiTool->getBitMaskValue(&dataWord, roiTool->ForwardSectorIDMask());
     }
     const TrigConf::L1ThrExtraInfo_MU& muThrExtraInfo = dynamic_cast<const TrigConf::L1ThrExtraInfo_MU&>(menuExtraInfo);
  
     //buffer (notional) TGC/RPC flags
     bool F=false, C=false, H=false, M=false;
     if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel)
     {
       M  = dataWord & roiTool->OverflowPerRoIMask();
     }
     else
     {
       F = dataWord & roiTool->BW2Or3Mask();
       C = dataWord & roiTool->InnerCoinMask();
       H = dataWord & roiTool->GoodMFMask();
     }
  
     //loop over the thresholds
     for (const std::shared_ptr<TrigConf::L1Threshold>& thrBase : menuThresholds) {
       auto thr = static_cast<TrigConf::L1Threshold_MU*>(thrBase.get());
  
       bool passed{false};
       if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel) {
         //skip the threshold with regions not corresponding to ALL or barrel
         if (thr->region().find("ALL") == std::string::npos &&
             thr->region().find("BA") == std::string::npos) continue;
  
         //veto this candidate from this multiplicity if it's part of the excluded ROI list
         const bool isSideC = (side == LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideC());
         if (isExcludedRPCROI(muThrExtraInfo, thr->rpcExclROIList(), roi, sectorID, isSideC)) continue;
  
         if (ptword >= thr->idxBarrel()) {
           // mark this threshold as passed
           passed = true;
         }
  
         passed &= getRPCDecision(getShapedFlags(thr->rpcFlags()), M);
       }
       else { // Endcap or Forward
         if (system == LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem()) { // Endcap
           //skip the threshold with regions not corresponding to ALL or endcap
           if (thr->region().find("ALL") == std::string::npos &&
               thr->region().find("EC") == std::string::npos) continue;
  
           if (ptword >= thr->idxEndcap()) {
             // mark this threshold as passed
             passed = true;
           }
         }
         else { // Forward
           //skip the threshold with regions not corresponding to ALL or forward
           if (thr->region().find("ALL") == std::string::npos &&
               thr->region().find("FW") == std::string::npos) continue;
  
           if (ptword >= thr->idxForward()) {
             // mark this threshold as passed
             passed = true;
           }
         }
  
         passed &= getTGCDecision(getShapedFlags(thr->tgcFlags()), F, C, H);
       } // end Endcap or Forward
  
       if (passed) {
         // set the corresponding bit in the pattern
         thresholdsPattern |= (1 << thr->mapping());
       }
  
     } // loop over thresholds
  
     return thresholdsPattern;
   }

◆ getRPCDecision()

bool LVL1::TrigThresholdDecisionTool::getRPCDecision	(	const std::string &	rpcFlags,
		bool	M
	)		const

protected

Definition at line 306 of file TrigThresholdDecisionTool.cxx.

   {
     //check if the word has been checked before for this string of flags (it should always, as we've buffered them in 'start')
     RPCFlagDecision decision(M);
     auto previous_decisions = m_rpcFlag_decisions.find(rpcFlags);
     if (previous_decisions == m_rpcFlag_decisions.end()) return false;
  
     auto previous_decision_itr = previous_decisions->second.find(decision);
     if (previous_decision_itr != previous_decisions->second.end()) return previous_decision_itr->pass;
     return false;
   }

◆ getShapedFlags()

std::string LVL1::TrigThresholdDecisionTool::getShapedFlags ( const std::string & flags ) const

protected

Definition at line 393 of file TrigThresholdDecisionTool.cxx.

   {
     std::string shapedFlags = flags;
     shapedFlags.erase(std::remove_if(shapedFlags.begin(),shapedFlags.end(),::isspace),shapedFlags.end()); // remove spaces
     std::vector<std::string> vec_ors = parseString(shapedFlags,"|");
     std::set<std::string> set_ors;
     for(const auto& ors : vec_ors){
       std::vector<std::string> vec_ands = parseString(ors,"&");
       std::set<std::string> set_ands;
       for(const auto& ands : vec_ands){
     set_ands.insert(ands);
       }
       std::string aa = "";
       for(const auto& ands : set_ands){
     aa += ands;
     aa += "&";
       }
       std::string bb = aa.substr(0,aa.size()-1); // remove the last "&"
       set_ors.insert(bb);
     }
     std::string aa = "";
     for(const auto& ors : set_ors){
       aa += ors;
       aa += "|";
     }
     std::string bb = aa.substr(0,aa.size()-1); // remove the last "|"
     return bb;
   }

◆ getTGCDecision()

bool LVL1::TrigThresholdDecisionTool::getTGCDecision	(	const std::string &	tgcFlags,
		bool	F,
		bool	C,
		bool	H
	)		const

protected

Definition at line 259 of file TrigThresholdDecisionTool.cxx.

   {
     //check if the word has been checked before for this string of flags (it should always, as we've buffered them in 'start')
     TGCFlagDecision decision(F,C,H);
     auto previous_decisions = m_tgcFlag_decisions.find(tgcFlags);
     if (previous_decisions == m_tgcFlag_decisions.end()) return false;
  
     auto previous_decision_itr = previous_decisions->second.find(decision);
     if (previous_decision_itr != previous_decisions->second.end()) return previous_decision_itr->pass;
     return false;
   }

◆ getThresholdDecisions() [1/2]

std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > LVL1::TrigThresholdDecisionTool::getThresholdDecisions	(	uint32_t	dataWord,
		const EventContext &	eventContext
	)		const

overridevirtual

Definition at line 182 of file TrigThresholdDecisionTool.cxx.

                                                                                            {
     // Retrieve the L1 menu configuration
     SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey, eventContext);
     std::optional<ThrVecRef> menuThresholds = getMenuThresholds(*l1Menu);
     std::optional<ExtraInfoRef> menuExtraInfo = getMenuThresholdExtraInfo(*l1Menu);
     // Call the other overload
     return getThresholdDecisions(dataWord, menuThresholds.value().get(), menuExtraInfo.value().get());
   }

◆ getThresholdDecisions() [2/2]

std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > LVL1::TrigThresholdDecisionTool::getThresholdDecisions	(	uint32_t	dataWord,
		const ThrVec &	menuThresholds,
		const TrigConf::L1ThrExtraInfoBase &	menuExtraInfo
	)		const

overridevirtual

Definition at line 193 of file TrigThresholdDecisionTool.cxx.

                                                                                                           {
  
     const uint64_t pattern = getPattern(dataWord, menuThresholds, menuExtraInfo);
  
     //the object that will be returned: pairs of thresholds and pass/fail decisions
     std::vector<std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool> > threshold_decisions;
     threshold_decisions.resize(menuThresholds.size());
     for (const std::shared_ptr<TrigConf::L1Threshold>& thr : menuThresholds) {
       const bool decision = pattern & (1 << thr->mapping());
       threshold_decisions[thr->mapping()] = std::make_pair(thr, decision);
     }
     return threshold_decisions;
   }

◆ initialize()

StatusCode LVL1::TrigThresholdDecisionTool::initialize ( )

overridevirtual

Definition at line 20 of file TrigThresholdDecisionTool.cxx.

   {
     ATH_MSG_DEBUG( "========================================" );
     ATH_MSG_DEBUG( "Initialize for TrigThresholdDecisionTool"  );
     ATH_MSG_DEBUG( "========================================" );
  
     ATH_CHECK(RoIThresholdsTool::initialize());
     ATH_CHECK( m_rpcTool.retrieve() );
     ATH_CHECK( m_tgcTool.retrieve() );
     return StatusCode::SUCCESS;
   }

◆ isExcludedRPCROI()

bool LVL1::TrigThresholdDecisionTool::isExcludedRPCROI	(	const TrigConf::L1ThrExtraInfo_MU &	menuExtraInfo,
		const std::string &	rpcExclROIList,
		unsigned	roi,
		unsigned	sectorID,
		bool	isSideC
	)		const

protected

Definition at line 226 of file TrigThresholdDecisionTool.cxx.

                                                                              {
     if (rpcExclROIList != "")
     {
       const std::map<std::string, std::vector<unsigned int> >& exclList = menuExtraInfo.exclusionList(rpcExclROIList);
       if (exclList.size() != 0)
       {
     //build the sector name of this ROI to compare against the exclusion list
     std::stringstream sectorName;
     sectorName<<"B";
     int sectorNumber=sectorID;
     if (isSideC) sectorNumber += 32;
     if (sectorNumber < 10) sectorName << "0";
     sectorName << sectorNumber;
     
     //do the comparison
     auto exclROIs = exclList.find(sectorName.str());
     if (exclROIs != exclList.end())
     {
       for (auto roi_itr=exclROIs->second.begin();roi_itr!=exclROIs->second.end();roi_itr++)
       {
         if (*roi_itr == roi) return true;
       }
     }
       }
     } // rpcExclList != ""
  
     return false;
   }

◆ makeRPCDecision()

void LVL1::TrigThresholdDecisionTool::makeRPCDecision	(	const std::string &	rpcFlags,
		bool	M
	)

protected

Definition at line 318 of file TrigThresholdDecisionTool.cxx.

   {
     //check if the word has been checked before for this string of flags
     RPCFlagDecision decision(M);
     auto previous_decisions = &m_rpcFlag_decisions[rpcFlags];
     auto previous_decision_itr = previous_decisions->find(decision);
     if (previous_decision_itr != previous_decisions->end()) return;
     else if (rpcFlags == "") {
       decision.pass=true;
       previous_decisions->insert(decision);
     }
     else { // make the decision
       
       //check the quality based on the flags.
       //loop over outer layer of "ors" and 'or' the results
       bool passedFlags = false;
       const std::vector<std::vector<std::string> >* vec_flags = &m_parsed_flags[rpcFlags];
       for (auto or_itr = vec_flags->begin();or_itr!=vec_flags->end();or_itr++)
       {
     //loop over the inner layer of "ands" and 'and' the results
     bool passedAnd = true;
     for (auto and_itr = or_itr->begin();and_itr!=or_itr->end();and_itr++)
     {
       if (*and_itr == "M") passedAnd = passedAnd && M;
     }
     passedFlags = passedFlags || passedAnd;
       }
       //buffer the decision
       decision.pass = passedFlags;
       previous_decisions->insert(decision);
     }     
   }

◆ makeTGCDecision()

void LVL1::TrigThresholdDecisionTool::makeTGCDecision	(	const std::string &	tgcFlags,
		bool	F,
		bool	C,
		bool	H
	)

protected

Definition at line 271 of file TrigThresholdDecisionTool.cxx.

   {
     //check if the word has been checked before for this string of flags
     TGCFlagDecision decision(F,C,H);
     auto previous_decisions = &m_tgcFlag_decisions[tgcFlags];
     auto previous_decision_itr = previous_decisions->find(decision);
     if (previous_decision_itr != previous_decisions->end()) return;
     else if (tgcFlags == "") {
       decision.pass=true;
       previous_decisions->insert(decision);
     }
     else { // make the decision
       
       //check the quality based on the flags.
       //loop over outer layer of "ors" and 'or' the results
       bool passedFlags = false;
       const std::vector<std::vector<std::string> >* vec_flags = &m_parsed_flags[tgcFlags];
       for (auto or_itr = vec_flags->begin();or_itr!=vec_flags->end();or_itr++)
       {
     //loop over the inner layer of "ands" and 'and' the results
     bool passedAnd = true;
     for (auto and_itr = or_itr->begin();and_itr!=or_itr->end();and_itr++)
     {
       if (*and_itr == "F") passedAnd = passedAnd && F;
       else if (*and_itr == "C") passedAnd = passedAnd && C;
       else if (*and_itr == "H") passedAnd = passedAnd && H;
     }
     passedFlags = passedFlags || passedAnd;
       }
       //buffer the decision
       decision.pass = passedFlags;
       previous_decisions->insert(decision);
     }     
   }

◆ parseFlags()

void LVL1::TrigThresholdDecisionTool::parseFlags ( const std::string & flags )

protected

Definition at line 351 of file TrigThresholdDecisionTool.cxx.

   {
     //parse the logic of the quality flag into a 2D vector, where outer layer contains the logic |'s and inner layer contains the logical &'s.
     //save the 2D vector in a map so we don't have to parse it each time we want to check the flags.
     if (m_parsed_flags.find(flags) == m_parsed_flags.end())
     {
       std::vector<std::string> vec_ors = parseString(flags, "|");
       std::vector<std::vector<std::string> > vec_flags;
       for (unsigned ior=0;ior<vec_ors.size();ior++)
       {
     vec_flags.push_back(parseString(vec_ors[ior],"&"));
       }
       m_parsed_flags[flags] = vec_flags;
     }
   }

◆ parseString()

std::vector< std::string > LVL1::TrigThresholdDecisionTool::parseString	(	const std::string &	str,
		const std::string &	sep
	)		const

protected

Definition at line 367 of file TrigThresholdDecisionTool.cxx.

   {
     std::vector<std::string> parsed;
     int pos = 0;
     bool first = true;
     if (str.size() == 0) return parsed;
     if (str.find(sep) == std::string::npos)
     {
       parsed.push_back(str);
       return parsed;
     }
     while (true)
     {
       int newPos = str.find(sep, pos);
       if (str.find(sep, pos) == std::string::npos)
       {
     if (!first) parsed.push_back(str.substr(pos, newPos-pos));
     break;
       }
       std::string sub = str.substr(pos, newPos-pos);
       parsed.push_back(sub);
       pos = newPos+1;
       first = false;
     }
     return parsed;
   }

◆ start()

StatusCode LVL1::TrigThresholdDecisionTool::start ( )

overridevirtual

Definition at line 32 of file TrigThresholdDecisionTool.cxx.

   {
     ATH_MSG_DEBUG( "==========================================" );
     ATH_MSG_DEBUG( "Start for Phase1 TrigThresholdDecisionTool"  );
     ATH_MSG_DEBUG( "==========================================" );
  
     m_parsed_flags.clear();
     m_tgcFlag_decisions.clear();
  
     //front-load the TGC flag parsing and all possible 3-bit decisions for the menu
     SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey);
     ATH_CHECK(l1Menu.isValid());
     std::optional<ThrVecRef> menuThresholds = getMenuThresholds(*l1Menu);
     ATH_CHECK(menuThresholds.has_value());
  
     for (const std::shared_ptr<TrigConf::L1Threshold>& thrBase : menuThresholds.value().get()) {
       auto thr = static_cast<TrigConf::L1Threshold_MU*>(thrBase.get());
  
       //parse the tgc flags and buffer them
       std::string tgcFlags = getShapedFlags( thr->tgcFlags() );
       parseFlags(tgcFlags);
  
       //loop over all 3-bit flag combinations
       for (unsigned flags=0;flags<8;flags++)
       {
     bool F=flags&0b100;
     bool C=flags&0b010;
     bool H=flags&0b001;
     makeTGCDecision(tgcFlags, F, C, H);
       }
  
       //parse the rpc flags and buffer them
       std::string rpcFlags = getShapedFlags( thr->rpcFlags() );
       parseFlags(rpcFlags);
  
       //loop over all 2-bit flag combinations
       for (unsigned flags=0;flags<2;flags++)
       {
     bool M=flags&0b1;
     makeRPCDecision(rpcFlags, M);
       }
     }
  
     return StatusCode::SUCCESS;
   }

Member Data Documentation

◆ m_parsed_flags

std::map<std::string, std::vector<std::vector<std::string> > > LVL1::TrigThresholdDecisionTool::m_parsed_flags

protected

Definition at line 115 of file TrigThresholdDecisionTool.h.

◆ m_rpcFlag_decisions

std::map<std::string, std::set<RPCFlagDecision> > LVL1::TrigThresholdDecisionTool::m_rpcFlag_decisions

protected

Definition at line 119 of file TrigThresholdDecisionTool.h.

◆ m_rpcTool

ToolHandle<LVL1::ITrigT1MuonRecRoiTool> LVL1::TrigThresholdDecisionTool::m_rpcTool {this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"}

protected

Definition at line 111 of file TrigThresholdDecisionTool.h.

◆ m_tgcFlag_decisions

std::map<std::string, std::set<TGCFlagDecision> > LVL1::TrigThresholdDecisionTool::m_tgcFlag_decisions

protected

Definition at line 118 of file TrigThresholdDecisionTool.h.

◆ m_tgcTool

ToolHandle<LVL1::ITrigT1MuonRecRoiTool> LVL1::TrigThresholdDecisionTool::m_tgcTool {this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"}

protected

Definition at line 112 of file TrigThresholdDecisionTool.h.

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TrigThresholdDecisionTool()

Member Function Documentation

◆ getMinThresholdNameAndValue()

◆ getPattern() [1/2]

◆ getPattern() [2/2]

◆ getRPCDecision()

◆ getShapedFlags()

◆ getTGCDecision()

◆ getThresholdDecisions() [1/2]

◆ getThresholdDecisions() [2/2]

◆ initialize()

◆ isExcludedRPCROI()

◆ makeRPCDecision()

◆ makeTGCDecision()

◆ parseFlags()

◆ parseString()

◆ start()

Member Data Documentation

◆ m_parsed_flags

◆ m_rpcFlag_decisions

◆ m_rpcTool

◆ m_tgcFlag_decisions

◆ m_tgcTool