Class template for all phase-1 L1 RoI unpacking tools. More...

#include <RoIsUnpackingToolPhase1.h>

Inheritance diagram for RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >:

Collaboration diagram for RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >:

Public Member Functions
	RoIsUnpackingToolPhase1 (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	unpack (const EventContext &ctx, const xAOD::TrigComposite &l1TriggerResult, const HLT::IDSet &activeChains) const override
virtual StatusCode	unpack (const EventContext &, const ROIB::RoIBResult &, 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.
StatusCode	decodeMapping (std::function< bool(const std::string &)> &&filter)
	Fills mapping from L1 threshold -> to HLT chain.
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.

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
Data dependencies
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer >	m_decisionsKey
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer >	m_decisionsKeyProbe
SG::WriteHandleKey< TrigRoiDescriptorCollection >	m_trigRoIsKey
SG::ReadHandleKey< TrigConf::L1Menu >	m_l1MenuKey
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey

Private Attributes
Gaudi::Property< std::string >	m_l1RoILinkName
SG::ReadDecorHandleKey< T_RoIContainer >	m_thresholdPatternsKey
Gaudi::Property< float >	m_roiHalfWidthEta
Gaudi::Property< float >	m_roiHalfWidthPhi

Detailed Description

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>
class RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >

Class template for all phase-1 L1 RoI unpacking tools.

Definition at line 23 of file RoIsUnpackingToolPhase1.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

◆ RoIsUnpackingToolPhase1()

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::RoIsUnpackingToolPhase1	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

inline

Definition at line 41 of file RoIsUnpackingToolPhase1.h.

42 : RoIsUnpackingToolBase(type, name, parent) {}

RoIsUnpackingToolBase::RoIsUnpackingToolBase

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

Definition RoIsUnpackingToolBase.cxx:10

RoIsUnpackingToolPhase1

Class template for all phase-1 L1 RoI unpacking tools.

Definition RoIsUnpackingToolPhase1.h:23

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()

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

virtual StatusCode RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::initialize ( )

inlineoverridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 45 of file RoIsUnpackingToolPhase1.h.

                                           {
    ATH_CHECK(RoIsUnpackingToolBase::initialize());
    ATH_CHECK(m_l1MenuKey.initialize());
    ATH_CHECK(m_trigRoIsKey.initialize());
    ATH_CHECK(m_thresholdPatternsKey.initialize());
    return StatusCode::SUCCESS;
  }

◆ start()

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

virtual StatusCode RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::start ( )

inlineoverridevirtual

Definition at line 54 of file RoIsUnpackingToolPhase1.h.

                                      {
    ATH_CHECK(decodeMapping([](const std::string& name){
      return name.find(N_ThresholdType)==0 or name.find(getProbeThresholdName(N_ThresholdType))==0;
    }));
    return StatusCode::SUCCESS;
  }

◆ unpack() [1/2]

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

virtual StatusCode RoIsUnpackingToolBase::unpack	(	const EventContext &	,
		const ROIB::RoIBResult &	,
		const HLT::IDSet &	) const

inlineoverridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 40 of file RoIsUnpackingToolBase.h.

42 { return StatusCode::SUCCESS; }

◆ unpack() [2/2]

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

virtual StatusCode RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::unpack	(	const EventContext &	ctx,
		const xAOD::TrigComposite &	l1TriggerResult,
		const HLT::IDSet &	activeChains ) const

inlineoverridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 63 of file RoIsUnpackingToolPhase1.h.

                                                                         {
    using namespace HLTSeedingNs;
    using namespace TrigCompositeUtils;
    const bool doProbe = !m_decisionsKeyProbe.empty();
 
    // Create and record RoI descriptor and decision containers
    SG::WriteHandle<TrigRoiDescriptorCollection> roiDescriptors = createAndStoreNoAux(m_trigRoIsKey, ctx);
    SG::WriteHandle<DecisionContainer> decisionsMain = createAndStore(m_decisionsKey, ctx);
    SG::WriteHandle<DecisionContainer> decisionsProbe;
    if (doProbe) decisionsProbe = createAndStore(m_decisionsKeyProbe, ctx);
 
    // Retrieve the xAOD RoI container from L1TriggerResult
    if (!l1TriggerResult.hasObjectLink(m_l1RoILinkName, ClassID_traits<T_RoIContainer>::ID())) {
      ATH_MSG_DEBUG("No " << N_ThresholdType << " RoIs in this event");
      auto monRoIsCount = Monitored::Scalar("count", 0);
      Monitored::Group(m_monTool, monRoIsCount);
      return StatusCode::SUCCESS;
    }
    ElementLink<T_RoIContainer> roisLink = l1TriggerResult.objectLink<T_RoIContainer>(m_l1RoILinkName);
    ATH_CHECK(roisLink.isValid());
    const T_RoIContainer& rois = roisLink.getStorableObjectRef();
 
    // Create threshold patterns decoration accessor
    auto thrPatternAcc = SG::makeHandle<uint64_t>(m_thresholdPatternsKey, ctx);
    ATH_CHECK(thrPatternAcc.isPresent());
 
    // Retrieve the L1 menu configuration
    SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey, ctx);
    ATH_CHECK(l1Menu.isValid());
    std::optional<ThrVecRef> thresholds;
    ATH_CHECK(getL1Thresholds(*l1Menu, N_ThresholdType, thresholds));
 
    size_t linkIndex{0};
    for (const T_RoI* roi : rois) {
      // Create new RoI descriptor
      roiDescriptors->push_back(std::make_unique<TrigRoiDescriptor>(
        static_cast<unsigned int>((roi->*F_RoIWordGetter)()), 0u, 0u,
        roi->eta(), roi->eta()-m_roiHalfWidthEta, roi->eta()+m_roiHalfWidthEta,
        roi->phi(), roi->phi()-m_roiHalfWidthPhi, roi->phi()+m_roiHalfWidthPhi
      ));
 
      // Create new decision and link the RoI objects
      Decision* decisionMain = TrigCompositeUtils::newDecisionIn(decisionsMain.ptr(), hltSeedingNodeName());
      decisionMain->setObjectLink(initialRoIString(),
                                  ElementLink<TrigRoiDescriptorCollection>(m_trigRoIsKey.key(), linkIndex, ctx));
      decisionMain->setObjectLink(initialRecRoIString(),
                                  ElementLink<T_RoIContainer>(m_l1RoILinkName, linkIndex, ctx));
 
      Decision* decisionProbe{nullptr};
      if (doProbe) {
        decisionProbe = TrigCompositeUtils::newDecisionIn(decisionsProbe.ptr(), hltSeedingNodeName());
        decisionProbe->setObjectLink(initialRoIString(),
                                    ElementLink<TrigRoiDescriptorCollection>(m_trigRoIsKey.key(), linkIndex, ctx));
        decisionProbe->setObjectLink(initialRecRoIString(),
                                    ElementLink<T_RoIContainer>(m_l1RoILinkName, linkIndex, ctx));
      }
 
      std::vector<TrigCompositeUtils::DecisionID> passedThresholdIDs;
 
      // Add positive decisions for chains to be activated by this RoI object
      uint64_t thresholdPattern = thrPatternAcc(*roi);
      ATH_MSG_DEBUG("RoI #" << linkIndex << " threshold pattern: " << thresholdPattern);
      for (const std::shared_ptr<TrigConf::L1Threshold>& thr : thresholds.value().get()) {
        if ((thresholdPattern & (1_u64 << thr->mapping())) == 0_u64) {continue;}
        passedThresholdIDs.push_back(HLT::Identifier(thr->name()));
        ATH_MSG_DEBUG("RoI #" << linkIndex << " passed threshold number " << thr->mapping()
                      << " name" << (doProbe ? "s " : " ") << thr->name()
                      << (doProbe ? " and "+getProbeThresholdName(thr->name()) : ""));
        addChainsToDecision(HLT::Identifier(thr->name()), decisionMain, activeChains);
        if (doProbe) addChainsToDecision(HLT::Identifier(getProbeThresholdName(thr->name())), decisionProbe, activeChains);
      }
 
      decisionMain->setDetail("thresholds", passedThresholdIDs);
      if (doProbe) decisionProbe->setDetail("thresholds", passedThresholdIDs);
 
      ++linkIndex;
    }
 
    // Monitor the TrigRoiDescriptorCollection
    {
      auto monRoIsCount = Monitored::Scalar("count", roiDescriptors->size());
      auto monRoIsEta = Monitored::Collection("eta", *roiDescriptors, &TrigRoiDescriptor::eta);
      auto monRoIsPhi = Monitored::Collection("phi", *roiDescriptors, &TrigRoiDescriptor::phi);
      Monitored::Group(m_monTool, monRoIsCount, monRoIsEta, monRoIsPhi);
    }
 
    return StatusCode::SUCCESS;
  }

Member Data Documentation

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

51 {

52 this, "Decisions", "RoIDecisions", "Decisions for each RoI"};

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

54 {

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

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

63 {

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

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

60 {

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

◆ m_l1RoILinkName

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

Gaudi::Property<std::string> RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::m_l1RoILinkName

private

Initial value:

{
    this, "L1RoILinkName", N_RoIContainer,
    "Name of the link to read from L1TriggerResult for L1 xAOD RoI container"}

Definition at line 25 of file RoIsUnpackingToolPhase1.h.

                                           {
    this, "L1RoILinkName", N_RoIContainer,
    "Name of the link to read from L1TriggerResult for L1 xAOD RoI container"};

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

67{ this, "MonTool", "", "Monitoring tool" };

◆ m_roiHalfWidthEta

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

Gaudi::Property<float> RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::m_roiHalfWidthEta

private

Initial value:

{

this, "RoIHalfWidthEta", 0.1, "Size of RoI in eta"}

Definition at line 33 of file RoIsUnpackingToolPhase1.h.

33 {

34 this, "RoIHalfWidthEta", 0.1, "Size of RoI in eta"};

◆ m_roiHalfWidthPhi

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

Gaudi::Property<float> RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::m_roiHalfWidthPhi

private

Initial value:

{

this, "RoIHalfWidthPhi", 0.1, "Size of RoI in phi"}

Definition at line 36 of file RoIsUnpackingToolPhase1.h.

36 {

37 this, "RoIHalfWidthPhi", 0.1, "Size of RoI in phi"};

◆ m_roiupdater

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

protectedinherited

Definition at line 68 of file RoIsUnpackingToolBase.h.

68{ this, "RoiUpdater", "", "Roi Updater" };

◆ m_thresholdPatternsKey

template<typename T_RoI, typename T_RoIContainer, auto F_RoIWordGetter, const char * N_RoIContainer, const char * N_ThresholdType>

SG::ReadDecorHandleKey<T_RoIContainer> RoIsUnpackingToolPhase1< T_RoI, T_RoIContainer, F_RoIWordGetter, N_RoIContainer, N_ThresholdType >::m_thresholdPatternsKey

private

Initial value:

{
    this, "L1RoIThresholdPatternsKey", std::string(N_RoIContainer)+".thresholdPatterns",
    "Name of the L1 xAOD RoI container decoration for the threshold patterns"}

Definition at line 29 of file RoIsUnpackingToolPhase1.h.

                                                              {
    this, "L1RoIThresholdPatternsKey", std::string(N_RoIContainer)+".thresholdPatterns",
    "Name of the L1 xAOD RoI container decoration for the threshold patterns"};

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

57 {

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

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

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ThrVec

◆ ThrVecRef

Constructor & Destructor Documentation

◆ RoIsUnpackingToolPhase1()

Member Function Documentation

◆ addChainsToDecision()

◆ decodeMapping()

◆ getL1Thresholds()

◆ getProbeThresholdName()

◆ initialize()

◆ start()

◆ unpack() [1/2]

◆ unpack() [2/2]

Member Data Documentation

◆ m_decisionsKey

◆ m_decisionsKeyProbe

◆ m_HLTMenuKey

◆ m_l1MenuKey

◆ m_l1RoILinkName

◆ m_legToChainMapping

◆ m_monTool

◆ m_roiHalfWidthEta

◆ m_roiHalfWidthPhi

◆ m_roiupdater

◆ m_thresholdPatternsKey

◆ m_thresholdToChainMapping

◆ m_trigRoIsKey