ATLAS Offline Software
Loading...
Searching...
No Matches
EMRoIsUnpackingTool Class Reference

#include <EMRoIsUnpackingTool.h>

Inheritance diagram for EMRoIsUnpackingTool:
Collaboration diagram for EMRoIsUnpackingTool:

Public Member Functions

 EMRoIsUnpackingTool (const std::string &type, const std::string &name, const IInterface *parent)
StatusCode unpack (const EventContext &ctx, const ROIB::RoIBResult &roib, const HLT::IDSet &activeChains) const override
virtual StatusCode initialize () override
virtual StatusCode start () 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.
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< GenericMonitoringToolm_monTool { this, "MonTool", "", "Monitoring tool" }
ToolHandle< IRoiUpdaterToolm_roiupdater { this, "RoiUpdater", "", "Roi Updater" }
std::map< HLT::Identifier, HLT::IDVecm_thresholdToChainMapping
std::map< HLT::Identifier, HLT::Identifierm_legToChainMapping
Data dependencies
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainerm_decisionsKey
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainerm_decisionsKeyProbe
SG::WriteHandleKey< TrigRoiDescriptorCollectionm_trigRoIsKey
SG::ReadHandleKey< TrigConf::L1Menum_l1MenuKey
SG::ReadHandleKey< TrigConf::HLTMenum_HLTMenuKey

Private Attributes

SG::WriteHandleKey< DataVector< LVL1::RecEmTauRoI > > m_recRoIsKey
Gaudi::Property< float > m_roIWidth
LVL1::CPRoIDecoder m_cpDecoder

Detailed Description

Definition at line 13 of file EMRoIsUnpackingTool.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

◆ EMRoIsUnpackingTool()

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

Definition at line 11 of file EMRoIsUnpackingTool.cxx.

14 : RoIsUnpackingToolBase(type, name, parent) {}
RoIsUnpackingToolBase(const std::string &type, const std::string &name, const IInterface *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.

90 {
91 auto chains = m_thresholdToChainMapping.find( thresholdId );
92 if ( chains == m_thresholdToChainMapping.end() ) {
93 ATH_MSG_DEBUG("Threshold not known " << thresholdId);
94 return;
95 }
96
98 for ( auto chainId: chains->second ) {
99 if ( activeChains.find(chainId) != activeChains.end() ) {
100 ids.insert( chainId.numeric() );
101 ATH_MSG_DEBUG( "Added " << chainId << " to the RoI/threshold decision " << thresholdId );
102 } else { // maybe it is a leg?
103 auto legIterator = m_legToChainMapping.find( chainId );
104 if ( legIterator != m_legToChainMapping.end() ) {
105 // this is a leg we care about, need to check if respective chain was active, and activate
106 if ( activeChains.find( legIterator->second ) != activeChains.end() ) {
107 ids.insert( chainId.numeric() );
108 ATH_MSG_DEBUG( "Added " << chainId << " to the RoI/threshold decision " << thresholdId );
109 }
110 }
111 }
112 }
114 ATH_MSG_DEBUG( "Number of decisions in this RoI after adding chains using threshold " << thresholdId
115 << " " << TrigCompositeUtils::decisionIDs( d ).size() );
116}
#define ATH_MSG_DEBUG(x)
std::map< HLT::Identifier, HLT::Identifier > m_legToChainMapping
std::map< HLT::Identifier, HLT::IDVec > m_thresholdToChainMapping
void insertDecisionIDs(const Decision *src, Decision *dest)
Appends the decision IDs of src to the dest decision object.
std::set< DecisionID > DecisionIDContainer
void decisionIDs(const Decision *d, DecisionIDContainer &destination)
Extracts DecisionIDs stored in the Decision object.

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

52 {
53 SG::ReadHandle<TrigConf::HLTMenu> hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
54 ATH_CHECK( hltMenuHandle.isValid() );
55 // Cleanup in case there was a stop/start transition
57
58 for ( const TrigConf::Chain& chain: *hltMenuHandle ) {
59 const HLT::Identifier chainIdentifier(chain.name());
60 const std::vector<std::string> thresholds{ chain.l1thresholds() };
61 const std::vector<size_t> legMultiplicities{ chain.legMultiplicities() };
62 if (thresholds.size() != legMultiplicities.size()) {
63 ATH_MSG_ERROR("Encountered a chain " << chain.name() << " with " << legMultiplicities.size()
64 << " legs but only " << thresholds.size() << " thresholds. These should be the same.");
65 return StatusCode::FAILURE;
66 }
67 size_t counter = 0;
68 for ( const std::string& th: thresholds ) {
69 if ( filter(th) ) {
70 const HLT::Identifier thresholdIdentifier(th);
71 m_thresholdToChainMapping[ thresholdIdentifier ].push_back( chainIdentifier );
72 ATH_MSG_DEBUG( "Associating " << chainIdentifier << " with threshold " << th );
73 if ( thresholds.size() > 1 ) {
74 HLT::Identifier legIdentifier = TrigCompositeUtils::createLegName(chainIdentifier, counter);
75 m_thresholdToChainMapping[ thresholdIdentifier ].push_back( legIdentifier );
76 m_legToChainMapping.insert( std::make_pair( legIdentifier, chainIdentifier ) );
77 ATH_MSG_DEBUG( "Associating additional chain leg " << legIdentifier
78 << " with threshold " << thresholdIdentifier );
79 }
80 }
81 ++counter;
82 }
83 }
84 return StatusCode::SUCCESS;
85}
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_ERROR(x)
SG::ReadHandleKey< TrigConf::HLTMenu > m_HLTMenuKey
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
HLT::Identifier createLegName(const HLT::Identifier &chainIdentifier, size_t counter)
Generate the HLT::Identifier which corresponds to a specific leg of a given chain.

◆ 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]l1MenuThe L1Menu object
[in]thrTypeThe threshold type, e.g. EM, MU, eTAU
[out]thrVecThe 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.

35 {
36 try {
37 thrVec = ThrVecRef(l1Menu.thresholds(thrType));
38 }
39 catch (const std::exception& ex) {
40 ATH_MSG_ERROR("Failed to retrieve " << thrType << " thresholds from L1 menu. Exception:" << ex.what());
41 return StatusCode::FAILURE;
42 }
43 return StatusCode::SUCCESS;
44}
std::reference_wrapper< const ThrVec > ThrVecRef
std::vector< std::shared_ptr< TrigConf::L1Threshold > > thresholds() const
Access to list of all L1Thresholds.
Definition L1Menu.cxx:267

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

47 {
48 return "PROBE" + thresholdName;
49}

◆ initialize()

StatusCode EMRoIsUnpackingTool::initialize ( )
overridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 17 of file EMRoIsUnpackingTool.cxx.

17 {
19 ATH_CHECK( m_recRoIsKey.initialize() );
20 return StatusCode::SUCCESS;
21}
SG::WriteHandleKey< DataVector< LVL1::RecEmTauRoI > > m_recRoIsKey
virtual StatusCode initialize() override

◆ start()

StatusCode EMRoIsUnpackingTool::start ( )
overridevirtual

Definition at line 24 of file EMRoIsUnpackingTool.cxx.

24 {
25 ATH_CHECK(decodeMapping([](const std::string& name){
26 return name.find("EM") == 0 or name.find(getProbeThresholdName("EM")) == 0;
27 }));
28 return StatusCode::SUCCESS;
29}
StatusCode decodeMapping(std::function< bool(const std::string &)> &&filter)
Fills mapping from L1 threshold -> to HLT chain.
static std::string getProbeThresholdName(const std::string &thresholdName)
Concatenate the probe identifier string with the threshold name string.

◆ unpack() [1/2]

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

Reimplemented from RoIsUnpackingToolBase.

Definition at line 44 of file RoIsUnpackingToolBase.h.

46 { return StatusCode::SUCCESS; }

◆ unpack() [2/2]

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

Reimplemented from RoIsUnpackingToolBase.

Definition at line 32 of file EMRoIsUnpackingTool.cxx.

34 {
35 using namespace TrigCompositeUtils;
36
37 // create and record the collections needed
38 SG::WriteHandle<TrigRoiDescriptorCollection> trigRoIs = createAndStoreNoAux(m_trigRoIsKey, ctx );
39 SG::WriteHandle<DataVector<LVL1::RecEmTauRoI>> recRoIs = createAndStoreNoAux( m_recRoIsKey, ctx );
40 SG::WriteHandle<DecisionContainer> decisionOutput = createAndStore(m_decisionsKey, ctx );
41 SG::WriteHandle<DecisionContainer> decisionOutputProbe = createAndStore(m_decisionsKeyProbe, ctx );
42
43 // Retrieve the L1 menu configuration
44 SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey, ctx);
45 ATH_CHECK(l1Menu.isValid());
46 std::optional<ThrVecRef> emThresholds;
47 ATH_CHECK(getL1Thresholds(*l1Menu, "EM", emThresholds));
48
49 // Flag if there was an overflow in the TOB transmission to CMX (there were more TOBs than can be transferred)
50 bool overflow{false};
51 constexpr static unsigned int s_maxEmTOBs{5}; // Hardcoded in L1Calo firmware, see ATR-23697 and ATR-12285
52 std::unordered_map<unsigned int, std::unordered_map<unsigned int, unsigned int>> tobCounts; // {crate, {module, count}}
53
54 // RoIBResult contains vector of EM fragments
55 for ( const auto & emTauFragment : roib.eMTauResult() ) {
56 for ( const auto & roi : emTauFragment.roIVec() ) {
57 uint32_t roIWord = roi.roIWord();
58 if ( not ( LVL1::TrigT1CaloDefs::EMRoIWordType == roi.roIType() ) ) {
59 ATH_MSG_DEBUG( "Skipping RoI as it is not EM threshold " << roIWord );
60 continue;
61 }
62
63 if (!overflow) {
64 unsigned int crate = m_cpDecoder.crate(roIWord);
65 unsigned int module = m_cpDecoder.module(roIWord);
66 overflow = (++tobCounts[crate][module] > s_maxEmTOBs);
67 }
68
69 recRoIs->push_back( std::make_unique<LVL1::RecEmTauRoI>(roIWord, l1Menu.cptr()) );
70 const LVL1::RecEmTauRoI* recRoI = recRoIs->back();
71
72 trigRoIs->push_back( std::make_unique<TrigRoiDescriptor>(
73 roIWord, 0u ,0u,
74 recRoI->eta(), recRoI->eta()-m_roIWidth, recRoI->eta()+m_roIWidth,
75 recRoI->phi(), recRoI->phi()-m_roIWidth, recRoI->phi()+m_roIWidth) );
76
77 ATH_MSG_DEBUG( "RoI word: 0x" << MSG::hex << std::setw( 8 ) << roIWord << MSG::dec );
78
79 // The hltSeedingNodeName denotes an initial node with no parents
80 Decision* decisionMain = TrigCompositeUtils::newDecisionIn( decisionOutput.ptr(), hltSeedingNodeName() );
81 Decision* decisionProbe = TrigCompositeUtils::newDecisionIn( decisionOutputProbe.ptr(), hltSeedingNodeName() );
82
83 std::vector<TrigCompositeUtils::DecisionID> passedThresholdIDs;
84
85 for (const auto& th : emThresholds.value().get()) {
86 ATH_MSG_VERBOSE( "Checking if the threshold " << th->name() << " passed" );
87 if ( recRoI->passedThreshold( th->mapping() ) ) {
88 passedThresholdIDs.push_back( HLT::Identifier( th->name() ) );
89 const std::string thresholdProbeName = getProbeThresholdName(th->name());
90 ATH_MSG_DEBUG( "Passed Threshold names " << th->name() << " and " << thresholdProbeName);
91 addChainsToDecision( HLT::Identifier( th->name() ), decisionMain, activeChains );
92 addChainsToDecision( HLT::Identifier( thresholdProbeName ), decisionProbe, activeChains );
93 }
94 }
95
96 decisionMain->setDetail( "thresholds", passedThresholdIDs );
97 decisionMain->setObjectLink( initialRoIString(),
98 ElementLink<TrigRoiDescriptorCollection>(m_trigRoIsKey.key(), trigRoIs->size()-1, ctx) );
99 decisionMain->setObjectLink( initialRecRoIString(),
100 ElementLink<DataVector<LVL1::RecEmTauRoI>>(m_recRoIsKey.key(), recRoIs->size()-1, ctx) );
101
102 decisionProbe->setDetail( "thresholds", passedThresholdIDs );
103 decisionProbe->setObjectLink( initialRoIString(),
104 ElementLink<TrigRoiDescriptorCollection>(m_trigRoIsKey.key(), trigRoIs->size()-1, ctx) );
105 decisionProbe->setObjectLink( initialRecRoIString(),
106 ElementLink<DataVector<LVL1::RecEmTauRoI>>(m_recRoIsKey.key(), recRoIs->size()-1, ctx) );
107 }
108 }
109
110 // Decorate the decisions with overflow information
111 if (overflow) {
112 ATH_MSG_WARNING("L1Calo overflow for EM TOBs to CMX detected");
113 }
114 for (Decision* decision : *decisionOutput) {
115 decision->setDetail("overflow", static_cast<char>(overflow));
116 }
117
118 for ( auto roi: *trigRoIs ) {
119 ATH_MSG_DEBUG( "RoI Eta: " << roi->eta() << " Phi: " << roi->phi() << " RoIWord: " << roi->roiWord() );
120 }
121
122 // monitoring
123 {
124 auto RoIsCount = Monitored::Scalar( "count", trigRoIs->size() );
125 auto RoIsPhi = Monitored::Collection( "phi", *trigRoIs, &TrigRoiDescriptor::phi );
126 auto RoIsEta = Monitored::Collection( "eta", *trigRoIs, &TrigRoiDescriptor::eta );
127 Monitored::Group( m_monTool, RoIsCount, RoIsEta, RoIsPhi );
128 }
129
130 ATH_MSG_DEBUG( "Unpacked " << trigRoIs->size() << " RoIs" );
131
132 return StatusCode::SUCCESS;
133}
#define ATH_MSG_VERBOSE(x)
#define ATH_MSG_WARNING(x)
SG::WriteHandle< DecisionContainer > createAndStore(const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
Creates and right away records the DecisionContainer with the key.
LVL1::CPRoIDecoder m_cpDecoder
Gaudi::Property< float > m_roIWidth
virtual double eta() const =0
virtual double phi() const =0
Methods to retrieve data members.
virtual double eta() const
returns eta coord of ROI
bool passedThreshold(unsigned int threshold_number) const
returns TRUE if threshold number threshold_number has been passed by this ROI.
virtual double phi() const
returns phi coord of ROI
const std::vector< EMTauResult > & eMTauResult() const
Gets the egamma part of the L1 RDO.
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > m_decisionsKey
ToolHandle< GenericMonitoringTool > m_monTool
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
void addChainsToDecision(HLT::Identifier thresholdId, TrigCompositeUtils::Decision *d, const HLT::IDSet &activeChains) const
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > m_decisionsKeyProbe
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_trigRoIsKey
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.
const_pointer_type cptr()
Dereference the pointer.
pointer_type ptr()
Dereference the pointer.
bool setObjectLink(const std::string &name, const ElementLink< CONTAINER > &link)
Set the link to an object.
bool setDetail(const std::string &name, const TYPE &value)
Set an TYPE detail on the object.
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
SG::WriteHandle< CONT > createAndStoreNoAux(const SG::WriteHandleKey< CONT > &key, const EventContext &ctx)
Creates and right away records the Container CONT with the key.
Decision * newDecisionIn(DecisionContainer *dc, const std::string &name)
Helper method to create a Decision object, place it in the container and return a pointer to it.
const std::string & initialRecRoIString()
const std::string & initialRoIString()
const std::string & hltSeedingNodeName()
setEventNumber uint32_t

Member Data Documentation

◆ m_cpDecoder

LVL1::CPRoIDecoder EMRoIsUnpackingTool::m_cpDecoder
private

Definition at line 36 of file EMRoIsUnpackingTool.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.

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_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_recRoIsKey

SG::WriteHandleKey< DataVector<LVL1::RecEmTauRoI> > EMRoIsUnpackingTool::m_recRoIsKey
private
Initial value:
{
this, "OutputRecRoIs", "HLT_RecEMRoIs",
"Name of the RoIs object produced by the unpacker"}

Definition at line 29 of file EMRoIsUnpackingTool.h.

29 {
30 this, "OutputRecRoIs", "HLT_RecEMRoIs",
31 "Name of the RoIs object produced by the unpacker"};

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

Gaudi::Property<float> EMRoIsUnpackingTool::m_roIWidth
private
Initial value:
{
this, "RoIWidth", 0.2, "Size of RoI in eta/ phi"}

Definition at line 33 of file EMRoIsUnpackingTool.h.

33 {
34 this, "RoIWidth", 0.2, "Size of RoI in eta/ phi"};

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