RoIsUnpackingEmulationTool Class Reference

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

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

                                                              { return StatusCode::SUCCESS; }

unpack() [2/2]

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, ctx) );
    }
 
    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 55 of file RoIsUnpackingEmulationTool.h.

{0};

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.

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

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

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

m_inputData

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

private

Definition at line 54 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 33 of file RoIsUnpackingEmulationTool.h.

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

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.

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

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

m_roiupdater

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

protectedinherited

Definition at line 68 of file RoIsUnpackingToolBase.h.

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

m_roIWidth

Gaudi::Property<float> RoIsUnpackingEmulationTool::m_roIWidth

private

Initial value:

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

Definition at line 30 of file RoIsUnpackingEmulationTool.h.

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

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 36 of file RoIsUnpackingEmulationTool.h.

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

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.

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

---

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

• RoIsUnpackingEmulationTool.h
• RoIsUnpackingEmulationTool.cxx