LVL1::TrigThresholdDecisionTool Class Reference

#include <TrigThresholdDecisionTool.h>

Inheritance diagram for LVL1::TrigThresholdDecisionTool:

Collaboration diagram for LVL1::TrigThresholdDecisionTool:

Classes
struct	TGCFlagDecision
struct	RPCFlagDecision

Public Types
using	parsedFlagsMap = std::unordered_map<std::string, std::vector<std::vector<std::string_view> > >

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 EventContext &ctx, 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
StatusCode	configureToolFromMenu (const TrigConf::L1Menu &l1Menu) const
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, const parsedFlagsMap &parsed_flags) const
bool	getRPCDecision (const std::string &rpcFlags, bool M) const
void	makeRPCDecision (const std::string &rpcFlags, bool M, const parsedFlagsMap &parsed_flags) const
void	parseFlags (const std::string &flags, parsedFlagsMap &parsed_flags) 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::set< TGCFlagDecision > > m_tgcFlag_decisions	ATLAS_THREAD_SAFE {}
std::map< std::string, std::set< RPCFlagDecision > > m_rpcFlag_decisions	ATLAS_THREAD_SAFE {}
ServiceHandle< TrigConf::ITrigConfigSvc >	m_configSvc {this, "TrigConfigSvc", "TrigConf::xAODConfigSvc"}
Gaudi::Property< bool >	m_MenuFromxAOD {this, "MenuFromxAOD", false, "Flag to enable loading the L1 menu from xAOD as metadata instead of the detector store"}
std::atomic< bool > m_isInitialized	ATLAS_THREAD_SAFE {false}
std::mutex m_mutex	ATLAS_THREAD_SAFE {}

Detailed Description

Definition at line 40 of file TrigThresholdDecisionTool.h.

Member Typedef Documentation

parsedFlagsMap

using LVL1::TrigThresholdDecisionTool::parsedFlagsMap = std::unordered_map<std::string, std::vector<std::vector<std::string_view> > >

Definition at line 73 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 18 of file TrigThresholdDecisionTool.cxx.

    : base_class(type, name, parent) {}

Member Function Documentation

configureToolFromMenu()

StatusCode LVL1::TrigThresholdDecisionTool::configureToolFromMenu ( const TrigConf::L1Menu & l1Menu ) const

protected

Definition at line 55 of file TrigThresholdDecisionTool.cxx.

                                                                                              {
 
    std::lock_guard guard{m_mutex};
    if (m_isInitialized) {
        return StatusCode::SUCCESS;
    }
 
    //buffered parsed TGC/RPC flags
    parsedFlagsMap parsed_flags;
    m_tgcFlag_decisions.clear();
    m_rpcFlag_decisions.clear();
 
    //front-load the TGC flag parsing and all possible 3-bit decisions for the menu
    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, parsed_flags);
 
        //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, parsed_flags);
        }
 
        //parse the rpc flags and buffer them
        std::string rpcFlags = getShapedFlags( thr->rpcFlags() );
        parseFlags(rpcFlags, parsed_flags);
 
        //loop over all 2-bit flag combinations
        for (unsigned flags=0;flags<2;flags++){
            bool M=flags&0b1;
            makeRPCDecision(rpcFlags, M, parsed_flags);
        }
    }
    m_isInitialized = true;
    return StatusCode::SUCCESS;
}

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 258 of file TrigThresholdDecisionTool.cxx.

  { 
    if (m_MenuFromxAOD and !m_isInitialized){
        const TrigConf::L1Menu& l1Menu = m_configSvc->l1Menu( Gaudi::Hive::currentContext());
        if (configureToolFromMenu(l1Menu) != StatusCode::SUCCESS){
            throw std::runtime_error("Error configuring the TrigThresholdDecisionTool from metadata!");
        }
    }
 
    //find the highest pt threshold passed - depite the name of this function
    std::string thrName="";
    double thrVal=0;
    double thrValTmp=0;
    for (unsigned idec=0;idec<decisions.size();++idec) {
      if (!decisions[idec].second) continue;
      const TrigConf::L1Threshold_MU* thr = static_cast<TrigConf::L1Threshold_MU*>(decisions[idec].first.get());
      if(std::abs(eta)<1.05){
    thrValTmp = thr->ptBarrel();
      }
      else{
    thrValTmp = thr->ptEndcap();
      }
      if (thrValTmp > thrVal)
    {
      thrVal = thrValTmp;
      thrName = thr->name();
    }
    }
    return std::make_pair(thrName, thrVal);
  }

getPattern() [1/2]

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

overridevirtual

Definition at line 100 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 107 of file TrigThresholdDecisionTool.cxx.

                                                                                                        {
    if (m_MenuFromxAOD and !m_isInitialized){
        const TrigConf::L1Menu& l1Menu = m_configSvc->l1Menu( Gaudi::Hive::currentContext());
        if (configureToolFromMenu(l1Menu) != StatusCode::SUCCESS){
            throw std::runtime_error("Error configuring the TrigThresholdDecisionTool from metadata!");
        }
    }
 
    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 |= (1ull << thr->mapping());
      }
 
    } // loop over thresholds
 
    return thresholdsPattern;
  }

getRPCDecision()

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

protected

Definition at line 369 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 437 of file TrigThresholdDecisionTool.cxx.

  {
    std::string shapedFlags = flags;
    shapedFlags.erase(std::remove_if(shapedFlags.begin(), shapedFlags.end(), 
         [](unsigned char c) { return std::isspace(c); }), shapedFlags.end());
    std::vector<std::string_view> vec_ors = tokenize<std::string_view>(shapedFlags,'|');
    std::set<std::string> set_ors;
    for(const auto& ors : vec_ors){
      std::vector<std::string_view> vec_ands = tokenize<std::string_view>(ors,'&');
      std::set<std::string_view> set_ands;
      for(const auto& ands : vec_ands){
    set_ands.insert(ands);
      }
      std::string aa = "";
      for(const auto& ands : set_ands){
    aa += ands;
    aa += '&';
      }
      if(!aa.empty()) aa.pop_back(); // remove the last "&"
      set_ors.insert(std::move(aa));
    }
    std::string aa = "";
    for(const auto& ors : set_ors){
      aa += ors;
      aa += '|';
    }
    if(!aa.empty()) aa.pop_back();// remove the last "|"
    return aa;
  }

getTGCDecision()

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

protected

Definition at line 322 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 212 of file TrigThresholdDecisionTool.cxx.

                                                                                           {
    // Retrieve the L1 menu configuration
    const TrigConf::L1Menu* l1Menu;
    if (m_MenuFromxAOD){
        l1Menu = &m_configSvc->l1Menu( eventContext );
        if (!m_isInitialized){
            if (configureToolFromMenu(*l1Menu) != StatusCode::SUCCESS){
                throw std::runtime_error("Error configuring the TrigThresholdDecisionTool from metadata!");
            }
        } 
    }
    else{
        SG::ReadHandle<TrigConf::L1Menu> l1MenuHandle = SG::makeHandle(m_l1MenuKey, eventContext);
        l1Menu = l1MenuHandle.cptr();
    }
 
    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 236 of file TrigThresholdDecisionTool.cxx.

                                                                                                          {
    if (m_MenuFromxAOD and !m_isInitialized){
        const TrigConf::L1Menu& l1Menu = m_configSvc->l1Menu( Gaudi::Hive::currentContext());
        if (configureToolFromMenu(l1Menu) != StatusCode::SUCCESS){
            throw std::runtime_error("Error configuring the TrigThresholdDecisionTool from metadata!");
        }
    }
 
    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 23 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() );
 
    if(m_MenuFromxAOD) {
        ATH_CHECK( m_configSvc.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 289 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::string sectorName("B");
 
    int sectorNumber=sectorID;
    if (isSideC) sectorNumber += 32;
        if (sectorNumber < 10) sectorName += '0';
        sectorName += std::to_string(sectorNumber);
    
    //do the comparison
    auto exclROIs = exclList.find(sectorName);
    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, const parsedFlagsMap & parsed_flags ) const

protected

Definition at line 381 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 auto* vec_flags = &parsed_flags.at(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, const parsedFlagsMap & parsed_flags ) const

protected

Definition at line 334 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 auto* vec_flags = &parsed_flags.at(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, parsedFlagsMap & parsed_flags ) const

protected

Definition at line 414 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.
 
    // 1. Single-lookup insertion check using try_emplace.
    // If the key exists, it returns immediately without doing any work.
    auto [it, inserted] = parsed_flags.try_emplace(flags);
    
    if (!inserted) {
        return; 
    }
    std::string_view stable_key = it->first;
    std::vector<std::string_view> vec_ors = tokenize<std::string_view>(stable_key, '|');
    std::vector<std::vector<std::string_view> > vec_flags;
    for (unsigned ior=0;ior<vec_ors.size();ior++)
      {
    vec_flags.push_back(tokenize<std::string_view>(vec_ors[ior],'&'));
      }
      it->second = std::move(vec_flags);
  }

start()

StatusCode LVL1::TrigThresholdDecisionTool::start ( )

overridevirtual

Definition at line 39 of file TrigThresholdDecisionTool.cxx.

  {
    ATH_MSG_DEBUG( "==========================================" );
    ATH_MSG_DEBUG( "Start for Phase1 TrigThresholdDecisionTool"  );
    ATH_MSG_DEBUG( "==========================================" );
 
    // we configure the tool here only if we are not running from xAOD
    if (!m_MenuFromxAOD){
        
        SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey);
        ATH_CHECK(l1Menu.isValid());
        ATH_CHECK(configureToolFromMenu(*l1Menu));
    }
    return StatusCode::SUCCESS;
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/4]

std::mutex m_mutex LVL1::TrigThresholdDecisionTool::ATLAS_THREAD_SAFE {}

mutableprotected

Definition at line 127 of file TrigThresholdDecisionTool.h.

{};

ATLAS_THREAD_SAFE [2/4]

std::atomic<bool> m_isInitialized LVL1::TrigThresholdDecisionTool::ATLAS_THREAD_SAFE {false}

mutableprotected

Definition at line 126 of file TrigThresholdDecisionTool.h.

{false};

ATLAS_THREAD_SAFE [3/4]

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

mutableprotected

Definition at line 121 of file TrigThresholdDecisionTool.h.

{};

ATLAS_THREAD_SAFE [4/4]

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

mutableprotected

Definition at line 120 of file TrigThresholdDecisionTool.h.

{};

m_configSvc

ServiceHandle<TrigConf::ITrigConfigSvc> LVL1::TrigThresholdDecisionTool::m_configSvc {this, "TrigConfigSvc", "TrigConf::xAODConfigSvc"}

protected

Definition at line 124 of file TrigThresholdDecisionTool.h.

{this, "TrigConfigSvc", "TrigConf::xAODConfigSvc"};

m_MenuFromxAOD

Gaudi::Property<bool> LVL1::TrigThresholdDecisionTool::m_MenuFromxAOD {this, "MenuFromxAOD", false, "Flag to enable loading the L1 menu from xAOD as metadata instead of the detector store"}

protected

Definition at line 125 of file TrigThresholdDecisionTool.h.

{this, "MenuFromxAOD", false, "Flag to enable loading the L1 menu from xAOD as metadata instead of the detector store"};

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 115 of file TrigThresholdDecisionTool.h.

{this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"};

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 116 of file TrigThresholdDecisionTool.h.

{this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"};

---

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

• TrigThresholdDecisionTool.h
• TrigThresholdDecisionTool.cxx