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 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.

    : 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;
    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 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 313 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 400 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 266 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 233 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 325 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 278 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 358 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 374 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:

• TrigThresholdDecisionTool.h
• TrigThresholdDecisionTool.cxx