Trig::DecisionUnpackerEventInfo Class Reference

#include <DecisionUnpackerEventInfo.h>

Inheritance diagram for Trig::DecisionUnpackerEventInfo:

Collaboration diagram for Trig::DecisionUnpackerEventInfo:

Public Types
typedef unsigned	CTPID
typedef unsigned	CHAIN_COUNTER

Public Member Functions
	DecisionUnpackerEventInfo (const SG::ReadHandleKey< EventInfo > *oldEventInfoKey)
virtual	~DecisionUnpackerEventInfo ()
	DecisionUnpackerEventInfo (const DecisionUnpackerEventInfo &)=delete
DecisionUnpackerEventInfo &	operator= (const DecisionUnpackerEventInfo &)=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 std::vector< uint32_t > &level1TriggerInfo, std::map< CTPID, LVL1CTP::Lvl1Item > &itemsCache, std::unordered_map< std::string, const LVL1CTP::Lvl1Item * > &itemsByName) const
StatusCode	unpackChains (const std::vector< uint32_t > &chainTriggerInfo, std::map< unsigned, HLT::Chain > &cache, std::unordered_map< std::string, const HLT::Chain * > &output) const

Private Attributes
const SG::ReadHandleKey< EventInfo > *	m_eventInfoKey {nullptr}

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

Detailed Description

Definition at line 30 of file DecisionUnpackerEventInfo.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

DecisionUnpackerEventInfo() [1/2]

Trig::DecisionUnpackerEventInfo::DecisionUnpackerEventInfo

(

const SG::ReadHandleKey< EventInfo > *

oldEventInfoKey

)

Definition at line 32 of file DecisionUnpackerEventInfo.cxx.

                                                                                                        :
    m_eventInfoKey(oldEventInfoKey){
  }

~DecisionUnpackerEventInfo()

Trig::DecisionUnpackerEventInfo::~DecisionUnpackerEventInfo ( )

virtual

Definition at line 36 of file DecisionUnpackerEventInfo.cxx.

                                                       {
  }

DecisionUnpackerEventInfo() [2/2]

Trig::DecisionUnpackerEventInfo::DecisionUnpackerEventInfo ( const DecisionUnpackerEventInfo & )

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

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

delete

unpackChains()

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

private

Definition at line 76 of file DecisionUnpackerEventInfo.cxx.

                                                                                         {
    output.reserve( output.size() + cache.size() );
    for( auto& [cntr, chain] : cache){
      chain.reset();
 
      //we have to make a guess here 
      //the bit form the event header is set according to 
      //HLT::Chain::chainPassed() i.e. either non-prescaled, non-ressurected && passed
      //or it was passed through.
      //if the bit is set, we will chose the first version for all chains
      //even though some may be passed through
      //if the bit is not set we will set all flags to false
 
      bool decision =  get32BitDecision( cntr, chainTriggerInfo );
      if(decision){
    chain.setDecisions( true, //raw
                 false,//passedthrough
                 false,//prescaled
                 false //resurrected
                 );
      }
      else {
    chain.setDecisions( false,//raw
                 false,//passedthrough
                 false,//prescaled
                 false //resurrected
                 );
      }
      output[chain.getChainName()] = &chain;
    }
    return StatusCode::SUCCESS;
  }

unpackDecision()

StatusCode Trig::DecisionUnpackerEventInfo::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 & , bool unpackHLT ) const

overridevirtual

Implements Trig::IDecisionUnpacker.

Definition at line 111 of file DecisionUnpackerEventInfo.cxx.

                                    {
    
    ATH_MSG_DEBUG("unpacking decision from EventInfo");
 
    SG::ReadHandle<EventInfo> eventInfo(*m_eventInfoKey, ctx);
    const TriggerInfo* dec = eventInfo->trigger_info();
 
    // bgCode = dec->BGCode();
  
    // L1 items
    itemsByName.clear();
    ATH_MSG_DEBUG("Unpacking of L1 items");
    if( unpackItems(dec->level1TriggerInfo(),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();
    const auto& level2TriggerInfo = dec->level2TriggerInfo();
 
    if ( unpackChains(level2TriggerInfo, l2chainsCache, l2chainsByName).isFailure() ) {
      ATH_MSG_WARNING("Unpacking of L2 chains failed");
    }
 
    // EF chains
    efchainsByName.clear();
    const auto& eventFilterInfo = dec->eventFilterInfo();
  
    if ( unpackChains(eventFilterInfo, efchainsCache, efchainsByName).isFailure() ) {
      ATH_MSG_WARNING("Unpacking of EF/HLT chains failed");
    }
    
    return StatusCode::SUCCESS;
  }

unpackItems()

StatusCode Trig::DecisionUnpackerEventInfo::unpackItems ( const std::vector< uint32_t > & level1TriggerInfo, std::map< CTPID, LVL1CTP::Lvl1Item > & itemsCache, std::unordered_map< std::string, const LVL1CTP::Lvl1Item * > & itemsByName ) const

private

Definition at line 40 of file DecisionUnpackerEventInfo.cxx.

                                                                                                                            {
    
    uint32_t L1SIZE = level1TriggerInfo.size()/3;
    std::vector<uint32_t>::const_iterator begin, end;
    
    begin = level1TriggerInfo.begin();
    end = begin;
    std::advance(end,L1SIZE);
    std::vector<uint32_t> tbp(begin,end);
    
    begin = end;
    std::advance(end,L1SIZE);
    std::vector<uint32_t> tap(begin,end);
    
    begin = end;
    std::advance(end,L1SIZE);
    std::vector<uint32_t> tav(begin,end);
 
    itemsByName.reserve( itemsByName.size() + itemsCache.size() );
    for ( auto [ctpid, item] : itemsCache ) {
      ATH_MSG_VERBOSE("Unpacking bits for item: " << ctpid << " " << item.name());
      const bool passBP = get32BitDecision(ctpid,tbp);
      const bool passAP = get32BitDecision(ctpid,tap);
      const bool passAV = get32BitDecision(ctpid,tav);
      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::DecisionUnpackerEventInfo::unpackNavigation ( const EventContext & , HLT::TrigNavStructure *  ) const

overridevirtual

Implements Trig::IDecisionUnpacker.

Definition at line 161 of file DecisionUnpackerEventInfo.cxx.

                                                                                     {
    ATH_MSG_WARNING("This is the EventInfo Unpacker, there is no Navigation available -- but someone seems to try to access features triggering a navi unpacking");
    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_eventInfoKey

const SG::ReadHandleKey<EventInfo>* Trig::DecisionUnpackerEventInfo::m_eventInfoKey {nullptr}

private

Definition at line 51 of file DecisionUnpackerEventInfo.h.

{nullptr};

---

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

• DecisionUnpackerEventInfo.h
• DecisionUnpackerEventInfo.cxx