LVL1::TrigThresholdDecisionTool Class Reference

#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 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
bool	getRPCDecision (const std::string &rpcFlags, bool M) const
void	makeRPCDecision (const std::string &rpcFlags, bool M) const
void	parseFlags (const std::string &flags) const
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	ATLAS_THREAD_SAFE {}
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.

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.

    : base_class(type, name, parent) {}

Member Function Documentation

configureToolFromMenu()

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

protected

Definition at line 52 of file TrigThresholdDecisionTool.cxx.

                                                                                              {
 
    std::lock_guard guard{m_mutex};
    if (m_isInitialized) {
        return StatusCode::SUCCESS;
    }
 
    m_parsed_flags.clear();
    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);
 
        //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);
        }
    }
    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 254 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;
      std::shared_ptr<TrigConf::L1Threshold_MU> thr = std::static_pointer_cast<TrigConf::L1Threshold_MU>(decisions[idec].first);
      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 96 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 103 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 365 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 452 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(std::move(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 318 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 208 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 232 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 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() );
 
    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 285 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 ) const

protected

Definition at line 377 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 ) const

protected

Definition at line 330 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 ) const

protected

Definition at line 410 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] = std::move(vec_flags);
    }
  }

parseString()

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

protected

Definition at line 426 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(std::move(sub));
      pos = newPos+1;
      first = false;
    }
    return parsed;
  }

start()

StatusCode LVL1::TrigThresholdDecisionTool::start ( )

overridevirtual

Definition at line 36 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/5]

std::map<std::string, std::vector<std::vector<std::string> > > m_parsed_flags LVL1::TrigThresholdDecisionTool::ATLAS_THREAD_SAFE {}

mutableprotected

Definition at line 119 of file TrigThresholdDecisionTool.h.

{};

ATLAS_THREAD_SAFE [2/5]

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

mutableprotected

Definition at line 122 of file TrigThresholdDecisionTool.h.

{};

ATLAS_THREAD_SAFE [3/5]

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

mutableprotected

Definition at line 123 of file TrigThresholdDecisionTool.h.

{};

ATLAS_THREAD_SAFE [4/5]

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

mutableprotected

Definition at line 128 of file TrigThresholdDecisionTool.h.

{false};

ATLAS_THREAD_SAFE [5/5]

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

mutableprotected

Definition at line 129 of file TrigThresholdDecisionTool.h.

{};

m_configSvc

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

protected

Definition at line 126 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 127 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