#include <RoIsUnpackingEmulationTool.h>

Inheritance diagram for RoIsUnpackingEmulationTool:

Collaboration diagram for RoIsUnpackingEmulationTool:

Classes
struct	FakeRoI

Public Member Functions
	RoIsUnpackingEmulationTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual 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 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
Properties
Gaudi::Property< float >	m_roIWidth

Gaudi::Property< std::string >	m_inputFilename

Gaudi::Property< std::string >	m_thresholdPrefix

Emulation
std::vector< std::vector< RoIsUnpackingEmulationTool::FakeRoI > >	m_inputData

unsigned	m_currentRowNumber {0}

StatusCode	readEmulatedData ()

std::vector< std::vector< FakeRoI > >	parseInputFile ()

static std::vector< FakeRoI >	parseInputFileLine (const std::string &line, unsigned lineNumber)

static FakeRoI	parseInputRoI (const std::string &roi, unsigned lineNumber, unsigned roiNumber)

Detailed Description

Definition at line 11 of file RoIsUnpackingEmulationTool.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

◆ RoIsUnpackingEmulationTool()

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

Definition at line 9 of file RoIsUnpackingEmulationTool.cxx.

12 : 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 RoIsUnpackingEmulationTool::initialize ( )

overridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 15 of file RoIsUnpackingEmulationTool.cxx.

                                                   {
   ATH_CHECK( RoIsUnpackingToolBase::initialize() );
  
   if (readEmulatedData().isFailure() ) {
     ATH_MSG_ERROR( "Failed to read emulated data" );
     return StatusCode::FAILURE;
   }
  
   return StatusCode::SUCCESS;
 }

◆ parseInputFile()

std::vector< std::vector< RoIsUnpackingEmulationTool::FakeRoI > > RoIsUnpackingEmulationTool::parseInputFile ( )

private

Definition at line 71 of file RoIsUnpackingEmulationTool.cxx.

                                                                                                    {
   const char* whiteSpaceChars = " \t\n\r\f\v";
   auto rtrim = [whiteSpaceChars](std::string& s) { s.erase(s.find_last_not_of(whiteSpaceChars) + 1); };
   auto ltrim = [whiteSpaceChars](std::string& s) { s.erase(0, s.find_first_not_of(whiteSpaceChars)); };
   auto trim = [&rtrim, &ltrim](std::string& s) { ltrim(s); rtrim(s); };
  
   std::vector<std::vector<RoIsUnpackingEmulationTool::FakeRoI>> result;
   unsigned lineNumber = 0;
   std::string line;
  
   std::ifstream inputFile(m_inputFilename);
   if (!inputFile.good())  {
     throw std::invalid_argument("File " + m_inputFilename + "does not exists or is corrupted");
   }
  
   while (getline(inputFile, line)) {
     trim(line);
     if (line.empty()) {continue;}
     result.push_back(parseInputFileLine(line, ++lineNumber));
   }
  
   if (result.empty()) {
     throw std::invalid_argument("File " + m_inputFilename + " does not contain any RoI");
   }
   ATH_MSG_DEBUG("Read in " << result.size() << " pseudo events from " << m_inputFilename );
   return result;
 }

◆ parseInputFileLine()

std::vector< RoIsUnpackingEmulationTool::FakeRoI > RoIsUnpackingEmulationTool::parseInputFileLine	(	const std::string &	line,
		unsigned	lineNumber
	)

staticprivate

Definition at line 101 of file RoIsUnpackingEmulationTool.cxx.

                                                                                          {
   std::vector<RoIsUnpackingEmulationTool::FakeRoI> result;
   unsigned roiNumber = 0;
   std::stringstream inputLine(line);
   std::string roi;
  
   while (getline(inputLine, roi, ';'))  {
     // FIXME: If there aren't as many input fields in roi as parseInputRoI expects,
     // it'll return uninitialized data (which can lead to a practically infinite
     // loop when we try to normalize the phi). Add an elementary check here to
     // fix such a loop observed from creatingEVTest in ViewAlgsTest.
     if (roi.find (',') != std::string::npos) {
       result.push_back(parseInputRoI(roi, lineNumber, ++roiNumber));
     }
   }
   return result;
 }

◆ parseInputRoI()

RoIsUnpackingEmulationTool::FakeRoI RoIsUnpackingEmulationTool::parseInputRoI	(	const std::string &	roi,
		unsigned	lineNumber,
		unsigned	roiNumber
	)

staticprivate

Definition at line 121 of file RoIsUnpackingEmulationTool.cxx.

                                                                                                        {
   RoIsUnpackingEmulationTool::FakeRoI result;
   std::stringstream inputRoi(roi);
   std::string roiElement;
   unsigned roiElementNumber = 0;
  
   std::vector<std::function<void(const std::string&)>> fillResultFunctors;
   fillResultFunctors.emplace_back([&](const std::string& eta) { result.eta = stod(eta); });
   fillResultFunctors.emplace_back([&](const std::string& phi) { result.phi = stod(phi); });
   fillResultFunctors.emplace_back([&](const std::string& word) { result.roIWord = stoul(word); });
   fillResultFunctors.emplace_back([&](const std::string& passedThresholdID) {
     result.passedThresholdIDs.push_back(passedThresholdID); });
  
   while (getline(inputRoi, roiElement, ','))        {
     if (roiElementNumber > 2) { roiElementNumber = 3; }
     try{
       //cppcheck bug: https://trac.cppcheck.net/ticket/11530
       //cppcheck-suppress containerOutOfBounds
       fillResultFunctors[roiElementNumber++](roiElement);
     }
     catch (const std::exception& ex) {
       throw std::invalid_argument("Exception encountered while parsing line " + std::to_string(lineNumber) +
                                   ", roi " + std::to_string(roiNumber) + ". Exception: " + ex.what());
     }
   }
  
   return result;
 }

◆ readEmulatedData()

StatusCode RoIsUnpackingEmulationTool::readEmulatedData ( )

private

Definition at line 35 of file RoIsUnpackingEmulationTool.cxx.

                                                        {
   if ( m_inputFilename.empty() ) {
     ATH_MSG_WARNING("Provided InputFilename parameter is empty");
     return StatusCode::RECOVERABLE;
   }
   try {
     m_currentRowNumber = 0;
     m_inputData = parseInputFile();
   }
   catch (const std::exception& ex) {
     ATH_MSG_WARNING(ex.what());
     return StatusCode::RECOVERABLE;
   }
  
   ATH_MSG_DEBUG("Input file parsed successfully. Data:");
  
   for (auto& fragment : m_inputData) {
     ATH_MSG_DEBUG("Event");
     for (auto& fakeRoI : fragment) {
       const char* const delim = ", ";
       std::ostringstream debugPassedTresholdIDs;
       std::copy(fakeRoI.passedThresholdIDs.begin(),
                 fakeRoI.passedThresholdIDs.end(),
                 std::ostream_iterator<std::string>(debugPassedTresholdIDs, delim));
  
       ATH_MSG_DEBUG("Eta: " + std::to_string(fakeRoI.eta) +
                     ", Phi: " + std::to_string(fakeRoI.phi) +
                     ", Word: " + std::to_string(fakeRoI.roIWord) +
                     ", PassedThresholdIDs: " + debugPassedTresholdIDs.str());
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ start()

StatusCode RoIsUnpackingEmulationTool::start ( )

overridevirtual

Definition at line 27 of file RoIsUnpackingEmulationTool.cxx.

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

◆ unpack() [1/4]

virtual StatusCode RoIsUnpackingToolBase::unpack

inlineoverride

Definition at line 40 of file RoIsUnpackingToolBase.h.

42 { return StatusCode::SUCCESS; }

◆ unpack() [2/4]

virtual StatusCode RoIsUnpackingToolBase::unpack

inlineoverride

Definition at line 44 of file RoIsUnpackingToolBase.h.

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

46 { return StatusCode::SUCCESS; }

◆ unpack() [4/4]

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

overridevirtual

Reimplemented from RoIsUnpackingToolBase.

Definition at line 151 of file RoIsUnpackingEmulationTool.cxx.

                                                                                    {
   using namespace TrigCompositeUtils;
  
   // create and record the collections needed
   SG::WriteHandle<TrigRoiDescriptorCollection> trigRoIs = createAndStoreNoAux(m_trigRoIsKey, ctx );
   SG::WriteHandle<DecisionContainer> decisionOutput = createAndStore(m_decisionsKey, ctx );
  
   // retrieve fake data for this event
   if (m_inputData.empty()){
     ATH_MSG_ERROR("No input dataset found. Cannot decode RoI emulation");
     return StatusCode::FAILURE;
   }
   const size_t line = ctx.evt() % m_inputData.size();
   ATH_MSG_DEBUG("Getting RoIs for event "<< line);
   auto FakeRoIs = m_inputData[line];
  
   for (auto& roi : FakeRoIs) {
     uint32_t roIWord = roi.roIWord;
     trigRoIs->push_back( std::make_unique<TrigRoiDescriptor>(
       roIWord, 0u ,0u,
       roi.eta, roi.eta-m_roIWidth, roi.eta+m_roIWidth,
       roi.phi, roi.phi-m_roIWidth, roi.phi+m_roIWidth) );
  
     ATH_MSG_DEBUG( "RoI word: 0x" << MSG::hex << std::setw(8) << roIWord << MSG::dec );
  
     // This hltSeedingNodeName() denotes an initial node with no parents
     auto *decision  = TrigCompositeUtils::newDecisionIn( decisionOutput.ptr(), hltSeedingNodeName() );
     std::vector<TrigCompositeUtils::DecisionID> passedThresholdIDs;
  
     for ( const auto& th: roi.passedThresholdIDs ) {
       ATH_MSG_DEBUG( "Passed Threshold " << th << " enabling respective chains " );
       passedThresholdIDs.push_back( HLT::Identifier(th) );
       addChainsToDecision( HLT::Identifier( th ), decision, activeChains );
       decision->setObjectLink( initialRoIString(),
                                ElementLink<TrigRoiDescriptorCollection>(m_trigRoIsKey.key(), trigRoIs->size()-1) );
     }
  
     decision->setDetail( "thresholds", passedThresholdIDs );
   }
  
   for ( auto roi: *trigRoIs ) {
     ATH_MSG_DEBUG("RoI Eta: " << roi->eta() << " Phi: " << roi->phi() << " RoIWord: " << roi->roiWord());
   }
  
   return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_currentRowNumber

unsigned RoIsUnpackingEmulationTool::m_currentRowNumber {0}

private

Definition at line 53 of file RoIsUnpackingEmulationTool.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_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_inputData

std::vector<std::vector<RoIsUnpackingEmulationTool::FakeRoI> > RoIsUnpackingEmulationTool::m_inputData

private

Definition at line 52 of file RoIsUnpackingEmulationTool.h.

◆ m_inputFilename

Gaudi::Property<std::string> RoIsUnpackingEmulationTool::m_inputFilename

private

Initial value:

{

this, "InputFilename", "RoIEmulation.dat", "FakeROI input filename"}

Definition at line 31 of file RoIsUnpackingEmulationTool.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_roIWidth

Gaudi::Property<float> RoIsUnpackingEmulationTool::m_roIWidth

private

Initial value:

{

"RoIWidth", 0.1, "Size of RoI in eta/ phi"}

Definition at line 28 of file RoIsUnpackingEmulationTool.h.

◆ m_thresholdPrefix

Gaudi::Property<std::string> RoIsUnpackingEmulationTool::m_thresholdPrefix

private

Initial value:

{
    this, "ThresholdPrefix", "EM",
    "Activate chains that are seed from threshold that have this prefix in the name"}

Definition at line 34 of file RoIsUnpackingEmulationTool.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:

Classes

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Attributes

Emulation

Detailed Description

Member Typedef Documentation

◆ ThrVec

◆ ThrVecRef

Constructor & Destructor Documentation

◆ RoIsUnpackingEmulationTool()

Member Function Documentation

◆ addChainsToDecision()

◆ decodeMapping()

◆ getL1Thresholds()

◆ getProbeThresholdName()

◆ initialize()

◆ parseInputFile()

◆ parseInputFileLine()

◆ parseInputRoI()

◆ readEmulatedData()

◆ start()

◆ unpack() [1/4]

◆ unpack() [2/4]

◆ unpack() [3/4]

◆ unpack() [4/4]

Member Data Documentation

◆ m_currentRowNumber

◆ m_decisionsKey

◆ m_decisionsKeyProbe

◆ m_HLTMenuKey

◆ m_inputData

◆ m_inputFilename

◆ m_l1MenuKey

◆ m_legToChainMapping

◆ m_monTool

◆ m_roiupdater

◆ m_roIWidth

◆ m_thresholdPrefix

◆ m_thresholdToChainMapping

◆ m_trigRoIsKey