METRoIsUnpackingTool Class Reference

#include <METRoIsUnpackingTool.h>

Inheritance diagram for METRoIsUnpackingTool:

Collaboration diagram for METRoIsUnpackingTool:

Public Member Functions
	METRoIsUnpackingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	start () override
StatusCode	unpack (const EventContext &ctx, const ROIB::RoIBResult &roib, const HLT::IDSet &activeChains) const override
virtual StatusCode	unpack (const EventContext &, const ROIB::RoIBResult &, const HLT::IDSet &) const override
virtual StatusCode	unpack (const EventContext &, const xAOD::TrigComposite &, const HLT::IDSet &) const override
virtual StatusCode	unpack (const EventContext &, const xAOD::TrigComposite &, const HLT::IDSet &) const override

Protected Types
using	ThrVec = std::vector< std::shared_ptr< TrigConf::L1Threshold > >
using	ThrVecRef = std::reference_wrapper< const ThrVec >

Protected Member Functions
StatusCode	getL1Thresholds (const TrigConf::L1Menu &l1Menu, const std::string &thrType, std::optional< ThrVecRef > &thrVec) const
	Retrieve a vector of thresholds with type thrType from L1Menu. More...
StatusCode	decodeMapping (std::function< bool(const std::string &)> &&filter)
	Fills mapping from L1 threshold -> to HLT chain. More...
void	addChainsToDecision (HLT::Identifier thresholdId, TrigCompositeUtils::Decision *d, const HLT::IDSet &activeChains) const

Static Protected Member Functions
static std::string	getProbeThresholdName (const std::string &thresholdName)
	Concatenate the probe identifier string with the threshold name string. More...

Protected Attributes
ToolHandle< GenericMonitoringTool >	m_monTool { this, "MonTool", "", "Monitoring tool" }
ToolHandle< IRoiUpdaterTool >	m_roiupdater { this, "RoiUpdater", "", "Roi Updater" }
std::map< HLT::Identifier, HLT::IDVec >	m_thresholdToChainMapping
std::map< HLT::Identifier, HLT::Identifier >	m_legToChainMapping

Private Attributes
Gaudi::Property< std::string >	m_fsRoIKey
LVL1::JEPRoIDecoder	m_jepDecoder
HLT::IDSet	m_allMETChains

Detailed Description

Definition at line 13 of file METRoIsUnpackingTool.h.

Member Typedef Documentation

ThrVec

using RoIsUnpackingToolBase::ThrVec = std::vector<std::shared_ptr<TrigConf::L1Threshold> >

protectedinherited

Definition at line 73 of file RoIsUnpackingToolBase.h.

ThrVecRef

using RoIsUnpackingToolBase::ThrVecRef = std::reference_wrapper<const ThrVec>

protectedinherited

Definition at line 74 of file RoIsUnpackingToolBase.h.

Constructor & Destructor Documentation

METRoIsUnpackingTool()

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

Definition at line 9 of file METRoIsUnpackingTool.cxx.

  : RoIsUnpackingToolBase(type, name, parent) {}

Member Function Documentation

addChainsToDecision()

void RoIsUnpackingToolBase::addChainsToDecision ( HLT::Identifier  thresholdId, TrigCompositeUtils::Decision *  d, const HLT::IDSet &  activeChains  ) const

protectedinherited

Definition at line 88 of file RoIsUnpackingToolBase.cxx.

                                                                                      {
  auto chains = m_thresholdToChainMapping.find( thresholdId );
  if ( chains == m_thresholdToChainMapping.end() ) {
    ATH_MSG_DEBUG("Threshold not known " << thresholdId);
    return;
  }
 
  TrigCompositeUtils::DecisionIDContainer ids;
  for ( auto chainId: chains->second ) {
    if ( activeChains.find(chainId) != activeChains.end() ) {
      ids.insert( chainId.numeric() );
      ATH_MSG_DEBUG( "Added " << chainId << " to the RoI/threshold decision " << thresholdId );
    } else {    // maybe it is a leg?
      auto legIterator = m_legToChainMapping.find( chainId );
      if ( legIterator != m_legToChainMapping.end() ) {
        // this is a leg we care about, need to check if respective chain was active, and activate
        if ( activeChains.find( legIterator->second ) != activeChains.end() ) {
          ids.insert( chainId.numeric() );
          ATH_MSG_DEBUG( "Added " << chainId << " to the RoI/threshold decision " << thresholdId );
        }
      }
    }
  }
  TrigCompositeUtils::insertDecisionIDs(ids, d);
  ATH_MSG_DEBUG( "Number of decisions in this RoI after adding chains using threshold " << thresholdId
                 << " " << TrigCompositeUtils::decisionIDs( d ).size() );
}

decodeMapping()

StatusCode RoIsUnpackingToolBase::decodeMapping ( std::function< bool(const std::string &)> &&  filter )

protectedinherited

Fills mapping from L1 threshold -> to HLT chain.

• filter Function that, using the threshold name, defines if this decoder instance should take care of this threshold

Definition at line 52 of file RoIsUnpackingToolBase.cxx.

                                                                                              {
  SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
  ATH_CHECK( hltMenuHandle.isValid() );
  // Cleanup in case there was a stop/start transition
  m_thresholdToChainMapping.clear();
  
  for ( const TrigConf::Chain& chain: *hltMenuHandle ) {
    const HLT::Identifier chainIdentifier(chain.name());
    const std::vector<std::string> thresholds{ chain.l1thresholds() };
    const std::vector<size_t> legMultiplicities{ chain.legMultiplicities() };
    if (thresholds.size() != legMultiplicities.size()) {
      ATH_MSG_ERROR("Encountered a chain " << chain.name() << " with " << legMultiplicities.size()
                    << " legs but only " << thresholds.size() << " thresholds. These should be the same.");
      return StatusCode::FAILURE;
    }
    size_t counter = 0;
    for ( const std::string& th: thresholds ) {
      if ( filter(th) ) {
        const HLT::Identifier thresholdIdentifier(th);
        m_thresholdToChainMapping[ thresholdIdentifier ].push_back( chainIdentifier );
        ATH_MSG_DEBUG( "Associating " << chainIdentifier << " with threshold " << th );
        if ( thresholds.size() > 1 ) {
          HLT::Identifier legIdentifier = TrigCompositeUtils::createLegName(chainIdentifier, counter);
          m_thresholdToChainMapping[ thresholdIdentifier ].push_back( legIdentifier );
          m_legToChainMapping.insert( std::make_pair( legIdentifier,  chainIdentifier ) );
          ATH_MSG_DEBUG( "Associating additional chain leg " << legIdentifier
                        << " with threshold " << thresholdIdentifier );
        }
      }
      ++counter;
    }
  }
  return StatusCode::SUCCESS;
}

getL1Thresholds()

StatusCode RoIsUnpackingToolBase::getL1Thresholds ( const TrigConf::L1Menu &  l1Menu, const std::string &  thrType, std::optional< ThrVecRef > &  thrVec  ) const

protectedinherited

Retrieve a vector of thresholds with type thrType from L1Menu.

Parameters

[in]	l1Menu	The L1Menu object
[in]	thrType	The threshold type, e.g. EM, MU, eTAU
[out]	thrVec	The output will be passed into this parameter

Returns

FAILURE on exception reading the menu (e.g. thrType not in menu), SUCCESS otherwise

Definition at line 33 of file RoIsUnpackingToolBase.cxx.

                                                                                        {
  try {
    thrVec = ThrVecRef(l1Menu.thresholds(thrType));
  }
  catch (const std::exception& ex) {
    ATH_MSG_ERROR("Failed to retrieve " << thrType << " thresholds from L1 menu. Exception:" << ex.what());
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

getProbeThresholdName()

std::string RoIsUnpackingToolBase::getProbeThresholdName ( const std::string &  thresholdName )

staticprotectedinherited

Concatenate the probe identifier string with the threshold name string.

Creates an alternate threshold name, used by lower pT probe legs of tag+probe chains.

Definition at line 47 of file RoIsUnpackingToolBase.cxx.

                                                                                     {
  return "PROBE" + thresholdName;
}

initialize()

StatusCode METRoIsUnpackingTool::initialize ( )

overridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 15 of file METRoIsUnpackingTool.cxx.

                                            {
  ATH_CHECK(RoIsUnpackingToolBase::initialize());
  return StatusCode::SUCCESS;
}

start()

StatusCode METRoIsUnpackingTool::start ( )

overridevirtual

Definition at line 21 of file METRoIsUnpackingTool.cxx.

                                       {
  ATH_CHECK(decodeMapping([](const std::string& name){
    return name.find("TE") == 0 or name.find("XE") == 0 or name.find("XS") == 0;
  }));
 
  for ( auto th2chains: m_thresholdToChainMapping ) {
    m_allMETChains.insert( th2chains.second.begin(), th2chains.second.end() );
  }
 
  return StatusCode::SUCCESS;
}

unpack() [1/4]

virtual StatusCode RoIsUnpackingToolBase::unpack

inlineoverride

Definition at line 40 of file RoIsUnpackingToolBase.h.

                                                              { return StatusCode::SUCCESS; }

unpack() [2/4]

virtual StatusCode RoIsUnpackingToolBase::unpack

inlineoverride

Definition at line 44 of file RoIsUnpackingToolBase.h.

                                                              { return StatusCode::SUCCESS; }

unpack() [3/4]

virtual StatusCode RoIsUnpackingToolBase::unpack ( const EventContext &  , const xAOD::TrigComposite &  , const HLT::IDSet &    ) const

inlineoverridevirtualinherited

Definition at line 44 of file RoIsUnpackingToolBase.h.

                                                              { return StatusCode::SUCCESS; }

unpack() [4/4]

StatusCode METRoIsUnpackingTool::unpack ( const EventContext &  ctx, const ROIB::RoIBResult &  roib, const HLT::IDSet &  activeChains  ) const

overridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 34 of file METRoIsUnpackingTool.cxx.

                                                                            {
  using namespace TrigCompositeUtils;
  SG::WriteHandle<DecisionContainer> decisionOutput = createAndStore(m_decisionsKey, ctx );
 
  // Retrieve the L1 menu configuration
  SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey, ctx);
  ATH_CHECK(l1Menu.isValid());
  ThrVec thresholds;
  std::optional<ThrVecRef> xeThresholds;
  std::optional<ThrVecRef> teThresholds;
  std::optional<ThrVecRef> xsThresholds;
  ATH_CHECK(getL1Thresholds(*l1Menu, "XE", xeThresholds));
  ATH_CHECK(getL1Thresholds(*l1Menu, "TE", teThresholds));
  ATH_CHECK(getL1Thresholds(*l1Menu, "XS", xsThresholds));
  thresholds.insert(thresholds.end(), xeThresholds.value().get().cbegin(), xeThresholds.value().get().cend());
  thresholds.insert(thresholds.end(), teThresholds.value().get().cbegin(), teThresholds.value().get().cend());
  thresholds.insert(thresholds.end(), xsThresholds.value().get().cbegin(), xsThresholds.value().get().cend());
 
  HLT::IDSet activeMETchains;
  // see if any chain we care of is active
  std::set_intersection(activeChains.begin(), activeChains.end(),
                        m_allMETChains.begin(), m_allMETChains.end(),
                        std::inserter(activeMETchains, activeMETchains.end()));
 
  ATH_MSG_DEBUG("Unpacking MET RoI for " << activeMETchains.size() << " chains");
 
  // This hltSeedingNodeName() denotes an initial node with no parents
  auto *decision  = TrigCompositeUtils::newDecisionIn( decisionOutput.ptr(), hltSeedingNodeName() );
  for (const auto& th: thresholds) {
    addChainsToDecision(  HLT::Identifier( th->name() ), decision, activeChains );
  }
 
  ATH_MSG_DEBUG("Linking to FS RoI descriptor");
  decision->setObjectLink( initialRoIString(), ElementLink<TrigRoiDescriptorCollection>( m_fsRoIKey, 0 ) );
 
  // check the MET RoI, TODO unpack and create L1 MET object (only if turns out to be needed)
  bool foundMETRoI = false;
  const std::vector<ROIB::JetEnergyResult>& jetEnergyResult = roib.jetEnergyResult();
  for ( const ROIB::JetEnergyResult& jeResult: jetEnergyResult ) {
    for ( const ROIB::JetEnergyRoI& roi: jeResult.roIVec() ) {
      const LVL1::TrigT1CaloDefs::RoIType roiType = m_jepDecoder.roiType( roi.roIWord() );
      if ( roiType == LVL1::TrigT1CaloDefs::EnergyRoIWordType0 ) {
        foundMETRoI = true;
        break;
      }
    }
  }
 
  // inconsistency, active MET chains, yet missing MET RoI
  if ( (not activeMETchains.empty()) and not foundMETRoI) {
    ATH_MSG_WARNING( "" << activeMETchains.size() << " active MET chains while missing  MET RoI" );
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_allMETChains

HLT::IDSet METRoIsUnpackingTool::m_allMETChains

private

Definition at line 32 of file METRoIsUnpackingTool.h.

m_decisionsKey

SG::WriteHandleKey<TrigCompositeUtils::DecisionContainer> RoIsUnpackingToolBase::m_decisionsKey

protectedinherited

Initial value:

{
    this, "Decisions", "RoIDecisions", "Decisions for each RoI"}

Definition at line 51 of file RoIsUnpackingToolBase.h.

m_decisionsKeyProbe

SG::WriteHandleKey<TrigCompositeUtils::DecisionContainer> RoIsUnpackingToolBase::m_decisionsKeyProbe

protectedinherited

Initial value:

{
    this, "DecisionsProbe", "", "Optional secondary set of Decisions for each RoI for probe a.k.a. delayed a.k.a. rerun chains"}

Definition at line 54 of file RoIsUnpackingToolBase.h.

m_fsRoIKey

Gaudi::Property<std::string> METRoIsUnpackingTool::m_fsRoIKey

private

Initial value:

{
    this, "FSRoIKey", "HLT_FSRoI", "The key of FS RoI made earlier by the HLTSeeding"}

Definition at line 28 of file METRoIsUnpackingTool.h.

m_HLTMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> RoIsUnpackingToolBase::m_HLTMenuKey

protectedinherited

Initial value:

{
    this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "Name of the HLTMenu object to read configuration from"}

Definition at line 63 of file RoIsUnpackingToolBase.h.

m_jepDecoder

LVL1::JEPRoIDecoder METRoIsUnpackingTool::m_jepDecoder

private

Definition at line 31 of file METRoIsUnpackingTool.h.

m_l1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> RoIsUnpackingToolBase::m_l1MenuKey

protectedinherited

Initial value:

{
    this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "Name of the L1Menu object to read configuration from"}

Definition at line 60 of file RoIsUnpackingToolBase.h.

m_legToChainMapping

std::map<HLT::Identifier, HLT::Identifier> RoIsUnpackingToolBase::m_legToChainMapping

protectedinherited

Definition at line 71 of file RoIsUnpackingToolBase.h.

m_monTool

ToolHandle<GenericMonitoringTool> RoIsUnpackingToolBase::m_monTool { this, "MonTool", "", "Monitoring tool" }

protectedinherited

Definition at line 67 of file RoIsUnpackingToolBase.h.

m_roiupdater

ToolHandle<IRoiUpdaterTool> RoIsUnpackingToolBase::m_roiupdater { this, "RoiUpdater", "", "Roi Updater" }

protectedinherited

Definition at line 68 of file RoIsUnpackingToolBase.h.

m_thresholdToChainMapping

std::map<HLT::Identifier, HLT::IDVec> RoIsUnpackingToolBase::m_thresholdToChainMapping

protectedinherited

Definition at line 70 of file RoIsUnpackingToolBase.h.

m_trigRoIsKey

SG::WriteHandleKey<TrigRoiDescriptorCollection> RoIsUnpackingToolBase::m_trigRoIsKey

protectedinherited

Initial value:

{
    this, "OutputTrigRoIs", "", "Name of the RoIs collection produced by the unpacker"}

Definition at line 57 of file RoIsUnpackingToolBase.h.

---

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

• METRoIsUnpackingTool.h
• METRoIsUnpackingTool.cxx