Trig::DecisionUnpackerAthena Class Reference

#include <DecisionUnpackerAthena.h>

Inheritance diagram for Trig::DecisionUnpackerAthena:

Collaboration diagram for Trig::DecisionUnpackerAthena:

Public Types
typedef unsigned	CTPID
typedef unsigned	CHAIN_COUNTER

Public Member Functions
	DecisionUnpackerAthena (const SG::ReadHandleKey< TrigDec::TrigDecision > *olddeckey)
virtual	~DecisionUnpackerAthena ()
	DecisionUnpackerAthena (const DecisionUnpackerAthena &)=delete
DecisionUnpackerAthena &	operator= (const DecisionUnpackerAthena &)=delete
virtual StatusCode	unpackDecision (const EventContext &, std::unordered_map< std::string, const LVL1CTP::Lvl1Item * > &, std::map< CTPID, LVL1CTP::Lvl1Item > &, std::unordered_map< std::string, const HLT::Chain * > &, std::map< CHAIN_COUNTER, HLT::Chain > &, std::unordered_map< std::string, const HLT::Chain * > &, std::map< CHAIN_COUNTER, HLT::Chain > &, char &, bool) const override
virtual StatusCode	unpackNavigation (const EventContext &, HLT::TrigNavStructure *) const override
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Private Member Functions
StatusCode	unpackItems (const LVL1CTP::Lvl1Result &result, std::map< CTPID, LVL1CTP::Lvl1Item > &, std::unordered_map< std::string, const LVL1CTP::Lvl1Item * > &) const
StatusCode	unpackChains (const std::vector< uint32_t > &serialized_chains, std::map< unsigned, HLT::Chain > &cache, std::unordered_map< std::string, const HLT::Chain * > &output) const

Private Attributes
const SG::ReadHandleKey< TrigDec::TrigDecision > *	m_deckey {nullptr}
	Key of the trigger decision object in the event.

Static Private Attributes
static asg::AsgTool *s_logger	ATLAS_THREAD_SAFE {nullptr}

Detailed Description

Definition at line 32 of file DecisionUnpackerAthena.h.

Member Typedef Documentation

CHAIN_COUNTER

typedef unsigned Trig::IDecisionUnpacker::CHAIN_COUNTER

inherited

Definition at line 33 of file IDecisionUnpacker.h.

CTPID

typedef unsigned Trig::IDecisionUnpacker::CTPID

inherited

Definition at line 32 of file IDecisionUnpacker.h.

Constructor & Destructor Documentation

DecisionUnpackerAthena() [1/2]

Trig::DecisionUnpackerAthena::DecisionUnpackerAthena

(

const SG::ReadHandleKey< TrigDec::TrigDecision > *

olddeckey

)

Definition at line 16 of file DecisionUnpackerAthena.cxx.

                                                                                                      : 
    m_deckey(olddeckey) {
  }

~DecisionUnpackerAthena()

Trig::DecisionUnpackerAthena::~DecisionUnpackerAthena ( )

virtual

Definition at line 20 of file DecisionUnpackerAthena.cxx.

                                                 {
  }

DecisionUnpackerAthena() [2/2]

Trig::DecisionUnpackerAthena::DecisionUnpackerAthena ( const DecisionUnpackerAthena & )

delete

Member Function Documentation

msg() [1/2]

MsgStream & Trig::Logger::msg ( ) const

inlineinherited

Definition at line 29 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

                           {
      if (s_logger) return s_logger->msg();
      else throw std::runtime_error("TrigDecisionTool Logger not initialized.");
    }

msg() [2/2]

MsgStream & Trig::Logger::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 33 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

{ return msg() << lvl; }

msgLvl()

bool Trig::Logger::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 34 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

{ return s_logger && s_logger->msgLvl(lvl); }

operator=()

DecisionUnpackerAthena & Trig::DecisionUnpackerAthena::operator= ( const DecisionUnpackerAthena & )

delete

unpackChains()

StatusCode Trig::DecisionUnpackerAthena::unpackChains ( const std::vector< uint32_t > & serialized_chains, std::map< unsigned, HLT::Chain > & cache, std::unordered_map< std::string, const HLT::Chain * > & output ) const

private

Definition at line 43 of file DecisionUnpackerAthena.cxx.

                                                                                       {
   
    if( serialized_chains.empty() ) {
      ATH_MSG_WARNING("ChainResult is empty");
      return StatusCode::FAILURE;
    }
 
    output.reserve( output.size() + cache.size() );
 
    std::vector<uint32_t>::const_iterator rawIt = serialized_chains.begin();
    ++rawIt; // skip first number as it is count
    for ( ; rawIt != serialized_chains.end(); ++rawIt ) {
 
      unsigned cntr = HLT::Chain::inquireChainCounter(*rawIt);
 
      // localte now the chain
      auto cacheIt = cache.find(cntr);
      if ( cacheIt == cache.end() ) {
        ATH_MSG_WARNING("Missing chain of counter in the configuration: " << cntr);
        return StatusCode::FAILURE;
      } else {
        cacheIt->second.reset();
        cacheIt->second.deserialize(*rawIt);
        output[cacheIt->second.getChainName()] = &cacheIt->second;
        ATH_MSG_VERBOSE("Updated chain in this event : " << cacheIt->second);
      }
    }
    return StatusCode::SUCCESS;
  }

unpackDecision()

StatusCode Trig::DecisionUnpackerAthena::unpackDecision ( const EventContext & ctx, std::unordered_map< std::string, const LVL1CTP::Lvl1Item * > & itemsByName, std::map< CTPID, LVL1CTP::Lvl1Item > & itemsCache, std::unordered_map< std::string, const HLT::Chain * > & l2chainsByName, std::map< CHAIN_COUNTER, HLT::Chain > & l2chainsCache, std::unordered_map< std::string, const HLT::Chain * > & efchainsByName, std::map< CHAIN_COUNTER, HLT::Chain > & efchainsCache, char & bgCode, bool unpackHLT ) const

overridevirtual

Implements Trig::IDecisionUnpacker.

Definition at line 75 of file DecisionUnpackerAthena.cxx.

                                    {
 
    SG::ReadHandle<TrigDec::TrigDecision> trigDec(*m_deckey, ctx);
    const TrigDec::TrigDecision* dec = trigDec.cptr();
 
    bgCode = dec->BGCode();
 
    // L1 items
    itemsByName.clear();
    ATH_MSG_DEBUG("Unpacking of L1 items");
    if( unpackItems(dec->getL1Result(),itemsCache,itemsByName).isFailure() ) {
      ATH_MSG_WARNING("Unpacking of L1 items failed");
    }
  
 
    // protect from unpacking in case HLT was not run (i.e. configuration chains are 0)
    if (!unpackHLT) return StatusCode::SUCCESS;
 
 
    // L2 chains
    l2chainsByName.clear();
    ATH_MSG_DEBUG("Unpacking of L2 chains");
    if ( dec->getL2Result().getHLTLevel() != HLT::UNKNOWN ) {
      const std::vector<uint32_t>& l2_serialized_chains = dec->getL2Result().getChainResult();
      ATH_MSG_DEBUG(l2_serialized_chains.size() << " L2 chains");
    
      if ( unpackChains(l2_serialized_chains, l2chainsCache, l2chainsByName).isFailure() ) {
        ATH_MSG_WARNING("Unpacking of L2 chains failed");
      }
    }
  
    // EF chains
    ATH_MSG_DEBUG("Unpacking of EF/HLT chains");
    efchainsByName.clear();
    const std::vector<uint32_t>& ef_serialized_chains = dec->getEFResult().getChainResult();
    ATH_MSG_DEBUG(ef_serialized_chains.size() << " EF/HLT chains");
  
    if ( ! ef_serialized_chains.empty()) {
      if ( unpackChains(ef_serialized_chains, efchainsCache, efchainsByName).isFailure() ) {
        ATH_MSG_WARNING("Unpacking of EF/HLT chains failed");
      }
    } else {
      ATH_MSG_DEBUG("Empty EF/HLT chains");
    }
 
    return StatusCode::SUCCESS;
  }

unpackItems()

StatusCode Trig::DecisionUnpackerAthena::unpackItems ( const LVL1CTP::Lvl1Result & result, std::map< CTPID, LVL1CTP::Lvl1Item > & itemsCache, std::unordered_map< std::string, const LVL1CTP::Lvl1Item * > & itemsByName ) const

private

Definition at line 24 of file DecisionUnpackerAthena.cxx.

                                                                                                                         {
    itemsByName.reserve( itemsByName.size() + itemsCache.size() );
    for ( auto& [ctpid, item] : itemsCache ) {
      ATH_MSG_VERBOSE("Unpacking bits for item: " << ctpid << " " << item.name());
      const bool passBP = result.isPassedBeforePrescale(ctpid);
      const bool passAP = result.isPassedAfterPrescale(ctpid);
      const bool passAV = result.isPassedAfterVeto(ctpid);
      LVL1CTP::Lvl1Item itemNew (item.name(), item.hashId(),
                                 passBP, passAP, passAV,
                                 item.prescaleFactor());
      item = std::move (itemNew);
      itemsByName[item.name()] = &item;
    }
    return StatusCode::SUCCESS;
  }

unpackNavigation()

StatusCode Trig::DecisionUnpackerAthena::unpackNavigation ( const EventContext & ctx, HLT::TrigNavStructure * nav ) const

overridevirtual

Implements Trig::IDecisionUnpacker.

Definition at line 132 of file DecisionUnpackerAthena.cxx.

                                                                                      {
    ATH_MSG_DEBUG("Unpacking Navigation");
    SG::ReadHandle<TrigDec::TrigDecision> trigDec(*m_deckey, ctx);
    const TrigDec::TrigDecision* dec = trigDec.cptr();
    if (nav) {
      HLT::NavigationCore* fullNav = dynamic_cast<HLT::NavigationCore*>(nav);
      
      if(!fullNav){
        ATH_MSG_WARNING("downcast failed");
        return StatusCode::FAILURE;
      }
      
      fullNav->reset();
 
 
      // try to get navigation from EF/HLT 
      ATH_MSG_DEBUG("Trying to unpack EF/HLT Navigation of size: " << dec->getEFResult().getNavigationResult().size());
      
      bool unpacking_status = !dec->getEFResult().getNavigationResult().empty() && fullNav->deserialize(dec->getEFResult().getNavigationResult());
      
      if ( ! unpacking_status ) {
        if (msgLvl(MSG::DEBUG)) {
          msg() << MSG::DEBUG << "EF/HLT Navigation unpacking failed";
        }
        if (!dec->getL2Result().getNavigationResult().empty()) {
          msg() << ", falling back to L2 Navigation of size: "
                    << dec->getL2Result().getNavigationResult().size() << endmsg;      
            unpacking_status = nav->deserialize(dec->getL2Result().getNavigationResult());
          } else {
          msg() << endmsg;
        }   
      }
      if ( ! unpacking_status ) {
        ATH_MSG_DEBUG("Full (L2 & EF) Navigation unpacking failed");
      } else {
        ATH_MSG_DEBUG("Unpacked Navigation ");  
      } 
    }
 
    return StatusCode::SUCCESS;
  }

Member Data Documentation

ATLAS_THREAD_SAFE

asg::AsgTool* s_logger Trig::Logger::ATLAS_THREAD_SAFE {nullptr}

inlinestaticprivateinherited

Definition at line 38 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

{nullptr};

m_deckey

const SG::ReadHandleKey<TrigDec::TrigDecision>* Trig::DecisionUnpackerAthena::m_deckey {nullptr}

private

Key of the trigger decision object in the event.

Definition at line 54 of file DecisionUnpackerAthena.h.

{nullptr};

---

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

• DecisionUnpackerAthena.h
• DecisionUnpackerAthena.cxx