PrescalingTool Class Reference

#include <PrescalingTool.h>

Inheritance diagram for PrescalingTool:

Collaboration diagram for PrescalingTool:

Public Member Functions
	PrescalingTool ()=delete
	PrescalingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	prescaleChains (const EventContext &ctx, const HLT::IDVec &initiallyActive, HLT::IDVec &remainActive, bool forExpressStream=false) const override
	The method to prescale chains. More...

Private Types
using	ChainSet = std::set< HLT::Identifier >

Private Attributes
SG::ReadCondHandleKey< TrigConf::HLTPrescalesSet >	m_hltPrescaleSetInputKey
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
Gaudi::Property< bool >	m_keepUnknownChains
ToolHandle< GenericMonitoringTool >	m_monTool
ATHRNG::RNGWrapper	m_RNGEngines
	Random engine for calculating prescales. More...
ChainSet	m_nonCPSChains
std::map< std::string, HLT::IDVec >	m_CPSGroups
TrigConf::HLTPrescalesSet::HLTPrescale	m_prescaleForUnknownChain
HLT::Identifier	m_costChainID {""}

Detailed Description

Definition at line 33 of file PrescalingTool.h.

Member Typedef Documentation

ChainSet

using PrescalingTool::ChainSet = std::set<HLT::Identifier>

private

Definition at line 79 of file PrescalingTool.h.

Constructor & Destructor Documentation

PrescalingTool() [1/2]

PrescalingTool::PrescalingTool ( )

delete

PrescalingTool() [2/2]

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

Definition at line 19 of file PrescalingTool.cxx.

                                                           :
   base_class(type, name, parent),
   m_RNGEngines( PSTRanluxFactory, SG::getNSlots() ) {}

Member Function Documentation

initialize()

StatusCode PrescalingTool::initialize ( )

overridevirtual

Definition at line 26 of file PrescalingTool.cxx.

                                      {
   ATH_CHECK(m_hltPrescaleSetInputKey.initialize( ! m_hltPrescaleSetInputKey.key().empty() ));
   ATH_CHECK( m_HLTMenuKey.initialize() );
   ATH_CHECK( m_eventInfoKey.initialize() );
 
   if ( !m_monTool.empty() ) {
      ATH_CHECK(m_monTool.retrieve());
   }
 
   if (m_keepUnknownChains.value()) {
      ATH_MSG_WARNING(m_keepUnknownChains.name() << " is set to True. "
                      << "This is OK for testing but do not use this in production");
   }
   m_prescaleForUnknownChain = { m_keepUnknownChains.value(), (m_keepUnknownChains.value() ? 1.0 : -1.0) };
   m_costChainID = HLT::Identifier("HLT_noalg_CostMonDS_L1All");
   return StatusCode::SUCCESS;
}

prescaleChains()

StatusCode PrescalingTool::prescaleChains ( const EventContext &  ctx, const HLT::IDVec &  initiallyActive, HLT::IDVec &  remainActive, bool  forExpressStream = false  ) const

overridevirtual

The method to prescale chains.

If the prescale set input key is not defined or the chain does not exist in the prescale set, then the chains (or all chains) are kept according to the property KeepUnknownChains

Parameters

[in]	ctx	event context is needed for accessing the random engine
[in]	initiallyActive	vector of HLTIdentifiers of initially active chains (because they were seeded by L1)
[out]	remainActive	vector that is being filled with HLTIdentifiers of chains surviving the prescaling

Note: the event time needs to be taken from the EventInfo instead EventContext.eventID, which is commonly done! This is due to the special case when the trigger is run in a partition with preloaded data and the parameter HltEventLoopMgr.forceStartOfRunTime is set >0. In that case the EventContext.EventID is forced to the be the SOR time for each event. Using the EventContext.eventID would lead to a constant seed and a skewed prescaling.

Definition at line 93 of file PrescalingTool.cxx.

                                                                        {
   if ( initiallyActive.empty() ) {
      return StatusCode::SUCCESS;
   }
 
   // clear the output just in case
   remainActive.clear();
 
   if ( m_hltPrescaleSetInputKey.key().empty() ) {
      // if no prescaling key is configured, treat all prescales according to the property KeepUnknownChains
      if( m_keepUnknownChains ) {
         remainActive.reserve( initiallyActive.size() );
         for( const auto & ch : initiallyActive ) {
            remainActive.push_back(ch);
         }
      }
      return StatusCode::SUCCESS;
   }
 
   SG::ReadCondHandle<TrigConf::HLTPrescalesSet> hltPrescaleSet{m_hltPrescaleSetInputKey, ctx};
   ATH_CHECK(hltPrescaleSet.isValid());
 
   // access to psk
   ATH_MSG_DEBUG("Using HLT PSK " << hltPrescaleSet->psk());
   auto mon_lb = Monitored::Scalar<int>("LB", [&](){ return ctx.eventID().lumi_block(); });
   auto mon_psk = Monitored::Scalar<std::string>("HLTPSK", [&](){ return std::to_string(hltPrescaleSet->psk()); });
   auto mon = Monitored::Group(m_monTool, mon_lb, mon_psk);
 
   // prepare the result
   remainActive.reserve( initiallyActive.size() );
 
   // create the seed from the event time
   auto eventInfoHandle = SG::makeHandle( m_eventInfoKey, ctx );
   CHECK( eventInfoHandle.isValid() );
   size_t seed = eventInfoHandle->timeStamp() ^ eventInfoHandle->timeStampNSOffset();
 
   CLHEP::HepRandomEngine* engine = m_RNGEngines.getEngine( ctx );
   engine->setSeed( seed, 0 );
 
   auto getPrescale = [&](const HLT::Identifier& ch) -> const TrigConf::HLTPrescalesSet::HLTPrescale& {
      try {
         if (forExpressStream) {
            return hltPrescaleSet->prescale_express( ch.numeric() );
         } else {
            return hltPrescaleSet->prescale( ch.numeric() );
         }
      } catch(const std::out_of_range & ex) {
         // if chain with that name is not found in the prescale set
         if (m_keepUnknownChains.value()) {
            ATH_MSG_DEBUG("No prescale value for chain " << ch << ", keeping it because "
                          << m_keepUnknownChains.name() << "=" << m_keepUnknownChains.value());
         } else {
            ATH_MSG_ERROR("No prescale value for chain " << ch);
         }
      }
      return m_prescaleForUnknownChain;
   };
 
   auto decisionPerChain = [&](const HLT::Identifier& ch, double prescaleValue ) -> bool {
      auto flat = engine->flat();
      if(ch == m_costChainID) { // this is to explicitly monitor the cost chain
         auto mon_rndm = Monitored::Scalar<double>("Random", flat);
         Monitored::Group(m_monTool, mon_rndm);
      }
      return flat < 1./ prescaleValue;
   };
 
   struct ChainAndPrescale {
      HLT::Identifier id;
      TrigConf::HLTPrescalesSet::HLTPrescale ps;
      double relativePrescale{};
   };
 
   for ( auto [groupName, chainIDs]: m_CPSGroups) {
      // check if this group is seeded
      // only need to find one CPS chain if initiallyActive is L1seeded HLT id's
      if ( forExpressStream || std::find(initiallyActive.begin(), initiallyActive.end(), chainIDs.front()) != initiallyActive.end() ) {
         std::vector<ChainAndPrescale> psValueSorted;
         for ( const HLT::Identifier& ch: chainIDs ) {
            // in express stream initiallyActive are HLT accept id's, but chainIDs contain all chains in the group
            // regardless of HLT accept; skip the HLT reject id's to ensure remainActive is a subset of initiallyActive
            if ( forExpressStream && std::find(initiallyActive.begin(), initiallyActive.end(), ch) == initiallyActive.end() ) {
               continue;
            }
            auto ps = getPrescale(ch);
            if ( ps.enabled ) // exclude prescaled out chains
               psValueSorted.emplace_back( ChainAndPrescale({ch, ps}) );
         }
         if ( psValueSorted.empty() ) { // sometimes all chains may be presscaled out/disabled
            continue;
         }
         std::sort(psValueSorted.begin(), psValueSorted.end(), [](const ChainAndPrescale& a, const ChainAndPrescale& b){
            return a.ps.prescale < b.ps.prescale;
         });
         // setup relative prescales
         // the first chain (with the lowest PS is relative w.r.t the all events)
         psValueSorted.front().relativePrescale = psValueSorted.front().ps.prescale;
         if ( psValueSorted.size() > 1 ) {
            for ( auto i = psValueSorted.begin()+1; i < psValueSorted.end(); ++i ) {
               i->relativePrescale = i->ps.prescale / (i-1)->ps.prescale ;
            }
         }
         if (msgLvl(MSG::DEBUG)) {
            ATH_MSG_DEBUG("Chains in CPS group '"<< groupName <<"' sorted by PS : ");
            for ( const ChainAndPrescale& ch: psValueSorted ) {
               ATH_MSG_DEBUG("  " << ch.id << " " << (ch.ps.enabled ?
                             "prescale relative to the above " + std::to_string(ch.relativePrescale) :
                             "disabled"));
            }
         }
         // do actual prescaling
         for ( const ChainAndPrescale& ch: psValueSorted ) {
            const bool decision = decisionPerChain(ch.id, ch.relativePrescale);
            if ( not decision ) {break;}
            remainActive.push_back( ch.id );
         }
      }
   }
 
   // go through all active chains that are not in CPS groups
   for ( const HLT::Identifier& ch: m_nonCPSChains ) {
      if ( std::find( initiallyActive.begin(), initiallyActive.end(), ch ) != initiallyActive.end() ) {
         auto prescale = getPrescale(ch);
         if ( prescale.enabled ) {
            const bool decision = decisionPerChain(ch, prescale.prescale);
            if ( decision ) {
               remainActive.push_back( ch );
            }
            ATH_MSG_DEBUG("Prescaling decision for chain " << ch << " " << decision);
         } else {
            ATH_MSG_DEBUG("Chain " << ch << " is disabled, won't keep" );
         }
      }
   }
 
   return StatusCode::SUCCESS;
}

start()

StatusCode PrescalingTool::start ( )

overridevirtual

Definition at line 45 of file PrescalingTool.cxx.

                                 {
 
   // Cleanup in case there was a stop/start transition
   m_CPSGroups.clear();
   m_nonCPSChains.clear();
 
   SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
   ATH_CHECK( hltMenuHandle.isValid() );
 
   std::map<std::string, std::set<std::string>> l1SeedsCheckForCPS;
   for ( const TrigConf::Chain& chain: *hltMenuHandle ) {
      HLT::Identifier chainID{ chain.name() };
      int isCPS = 0;
      for ( const auto& group: chain.groups() ) {
         if ( group.find("CPS") != std::string::npos) {
            m_CPSGroups[group].push_back( chainID );
            l1SeedsCheckForCPS[group].insert(chain.l1item());
            isCPS++;
         }
      }
      if ( isCPS ==0 ) {
         m_nonCPSChains.insert( chainID );
      }
      if ( isCPS > 1 ) {
         ATH_MSG_ERROR("Chain " << chainID << " belongs to more than one CPS groups");
         return StatusCode::FAILURE;
      }
   }
 
   for ( auto [group, chains]: m_CPSGroups ) {
      if ( chains.size() == 1 ) {
         ATH_MSG_ERROR("Only one chain " << chains.front() << " in CPS group " << group << " that makes no sense");
         return StatusCode::FAILURE;
      }
   }
 
   for ( auto [group, l1SeedsSet]: l1SeedsCheckForCPS) {
      if ( l1SeedsSet.size() != 1 ) {
         ATH_MSG_ERROR("Chains in CPS group " << group << " have several different L1 seeds "
                       << std::vector<std::string>(l1SeedsSet.begin(), l1SeedsSet.end()));
         return StatusCode::FAILURE;
      }
   }
 
   return StatusCode::SUCCESS;
}

Member Data Documentation

m_costChainID

HLT::Identifier PrescalingTool::m_costChainID {""}

private

Definition at line 84 of file PrescalingTool.h.

m_CPSGroups

std::map<std::string, HLT::IDVec> PrescalingTool::m_CPSGroups

private

Definition at line 81 of file PrescalingTool.h.

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> PrescalingTool::m_eventInfoKey

private

Initial value:

{
    this, "EventInfo", "EventInfo", "Event Info Object Key"}

Definition at line 67 of file PrescalingTool.h.

m_HLTMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> PrescalingTool::m_HLTMenuKey

private

Initial value:

{
    this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu"}

Definition at line 64 of file PrescalingTool.h.

m_hltPrescaleSetInputKey

SG::ReadCondHandleKey<TrigConf::HLTPrescalesSet> PrescalingTool::m_hltPrescaleSetInputKey

private

Initial value:

{
    this, "HLTPrescales", "HLTPrescales", "HLT prescales set"}

Definition at line 61 of file PrescalingTool.h.

m_keepUnknownChains

Gaudi::Property<bool> PrescalingTool::m_keepUnknownChains

private

Initial value:

{
    this, "KeepUnknownChains", false, "If True then chains for which prescaling information is not set are kept"}

Definition at line 70 of file PrescalingTool.h.

m_monTool

ToolHandle<GenericMonitoringTool> PrescalingTool::m_monTool

private

Initial value:

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

Definition at line 73 of file PrescalingTool.h.

m_nonCPSChains

ChainSet PrescalingTool::m_nonCPSChains

private

Definition at line 80 of file PrescalingTool.h.

m_prescaleForUnknownChain

TrigConf::HLTPrescalesSet::HLTPrescale PrescalingTool::m_prescaleForUnknownChain

private

Definition at line 83 of file PrescalingTool.h.

m_RNGEngines

ATHRNG::RNGWrapper PrescalingTool::m_RNGEngines

private

Random engine for calculating prescales.

Definition at line 77 of file PrescalingTool.h.

---

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

• PrescalingTool.h
• PrescalingTool.cxx