HLT::Lvl1ResultAccessTool Class Reference

This tool is used to handle all LVL1 results in a coherent way, taking the LVL1 configuration into account to fill the raw bits with more meaningful data. More...

#include <Lvl1ResultAccessTool.h>

Inheritance diagram for HLT::Lvl1ResultAccessTool:

Collaboration diagram for HLT::Lvl1ResultAccessTool:

Public Member Functions
	Lvl1ResultAccessTool (const std::string &name, const std::string &type, const IInterface *parent)
	std Gaudi constructor
virtual StatusCode	initialize () override
virtual std::vector< std::unique_ptr< LVL1CTP::Lvl1Item > >	makeLvl1ItemConfig (const EventContext &context) const override
virtual bool	isCalibrationEvent (const ROIB::RoIBResult &result) const override
	checks if we have calibration items fired in this event
virtual std::vector< const LVL1CTP::Lvl1Item * >	createL1Items (const std::vector< std::unique_ptr< LVL1CTP::Lvl1Item > > &lvl1ItemConfig, const ROIB::RoIBResult &result, LVL1CTP::Lvl1Result const **lvl1ResultOut=nullptr) const override
	Extract LVL1 items from given RoIBResult.
virtual std::bitset< 3 >	lvl1EMTauJetOverflow (const ROIB::RoIBResult &result) override
	Check if there was an overflow in the TOB transmission to CMX.

Private Attributes
LVL1::JEPRoIDecoder	m_jepDecoder
LVL1::CPRoIDecoder	m_cpDecoder
SG::ReadCondHandleKey< TrigConf::L1PrescalesSet >	m_l1PrescaleSetInputKey { this, "L1Prescales", "L1Prescales", "L1 prescales set"}
	access to L1Prescales
SG::WriteHandleKey< LVL1CTP::Lvl1Result >	m_l1ResultKey { this, "L1Result", "L1Result", "L1 result"}

Detailed Description

This tool is used to handle all LVL1 results in a coherent way, taking the LVL1 configuration into account to fill the raw bits with more meaningful data.

This was used by the Lvl1Converter in the Run-1&2 HLT Steering. Now the only client is the trigger decision tool (class TrigDecisionTool) which makes all trigger information available to the end-users.

Author

Till Eifert Till..nosp@m.Eife.nosp@m.rt@ce.nosp@m.rn.c.nosp@m.h

Nicolas Berger Nicol.nosp@m.as.B.nosp@m.erger.nosp@m.@cer.nosp@m.n.ch

Definition at line 39 of file Lvl1ResultAccessTool.h.

Constructor & Destructor Documentation

Lvl1ResultAccessTool()

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

std Gaudi constructor

Definition at line 15 of file Lvl1ResultAccessTool.cxx.

                                                                          :
   base_class(name, type, parent)
{
}

Member Function Documentation

createL1Items()

std::vector< const LVL1CTP::Lvl1Item * > HLT::Lvl1ResultAccessTool::createL1Items ( const std::vector< std::unique_ptr< LVL1CTP::Lvl1Item > > & lvl1ItemConfig, const ROIB::RoIBResult & result, LVL1CTP::Lvl1Result const ** lvl1ResultOut = nullptr ) const

overridevirtual

Extract LVL1 items from given RoIBResult.

Parameters

result	reference to RoIBResult object, holding all LVL1 RoIs and items
lvl1ResultOut	If non-null, create (in addition) a LVL1 container holding all Lvl1 results, and return through this argument.

Returns

vector holding pointers to all LVL1 items

Definition at line 100 of file Lvl1ResultAccessTool.cxx.

{
   std::vector< const LVL1CTP::Lvl1Item* > items;
   std::vector<ROIB::CTPRoI> bitsBP = result.cTPResult().TBP();
   std::vector<ROIB::CTPRoI> bitsAP = result.cTPResult().TAP();
   std::vector<ROIB::CTPRoI> bitsAV = result.cTPResult().TAV();
 
   bool calib_flag = isCalibrationEvent(result);
   ATH_MSG_DEBUG("Calibration event? " << calib_flag);
   
   // loop over all configured items if no calibration, else only 3 last // Needs fixing
   int ctpVersion = result.cTPResult().header().formatVersion() & 0xf ;
   CTPdataformatVersion v(ctpVersion);
   
   unsigned first_item = calib_flag ? v.getMaxTrigItems()-3 : 0; // last three items are calib items, only those should be activated
 
   for ( unsigned i = first_item; i < lvl1ItemConfig.size(); i++ ) {
      if ( !lvl1ItemConfig[ i ] ) continue; // empty slot
 
      LVL1CTP::Lvl1Item* item =  lvl1ItemConfig[ i ].get();
      *item = LVL1CTP::Lvl1Item( item->name(), item->hashId(), 
                  getBit(bitsBP, i), 
                  getBit(bitsAP, i), 
                  getBit(bitsAV, i), 
                  item->prescaleFactor() );  
      items.push_back(item);
      ATH_MSG_DEBUG("Set bits on "<< item->name() <<" PS="<< item->prescaleFactor() <<"  BP=" <<getBit(bitsBP, i)<<" AP="<<getBit(bitsAP, i)<<" AV="<<getBit(bitsAV, i));
   }
 
  // Fill TBP, TAP in case we're creating the Lvl1Result
   if (lvl1ResultOut) {
      auto lvl1Result = std::make_unique<LVL1CTP::Lvl1Result>(true);
 
      // 1.) TAV
      const std::vector<ROIB::CTPRoI> ctpRoIVecAV = result.cTPResult().TAV();
      for (unsigned int iWord = 0; iWord < ctpRoIVecAV.size(); ++iWord) {
         uint32_t roIWord = ctpRoIVecAV[iWord].roIWord();
         lvl1Result->itemsAfterVeto().push_back(roIWord);
         ATH_MSG_DEBUG("TAV word #" << iWord << " is 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << roIWord << std::dec);
      }
 
      // 1.) TBP
      const std::vector<ROIB::CTPRoI> ctpRoIVecBP = result.cTPResult().TBP();
      for (unsigned int iWord=0; iWord < ctpRoIVecBP.size(); ++iWord) {
         uint32_t roIWord = ctpRoIVecBP[iWord].roIWord();
         lvl1Result->itemsBeforePrescale().push_back(roIWord);
         ATH_MSG_DEBUG( "TBP word #" << iWord << " is 0x" << std::hex
                        << std::setw( 8 ) << std::setfill( '0' ) << roIWord << std::dec);
      }
 
      // 2.) TAP
      const std::vector<ROIB::CTPRoI> ctpRoIVecAP = result.cTPResult().TAP();
      for (unsigned int iWord=0; iWord < ctpRoIVecAP.size(); ++iWord) {
         uint32_t roIWord = ctpRoIVecAP[iWord].roIWord();
         lvl1Result->itemsAfterPrescale().push_back(roIWord);
 
         ATH_MSG_DEBUG("TAP word #" << iWord << " is 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << roIWord << std::dec);
         
      }
      // make sure TBP, TAP, TAV all have 8 entries !
      if (lvl1Result->itemsBeforePrescale().size() < 8) lvl1Result->itemsBeforePrescale().resize(8, 0);
      if (lvl1Result->itemsAfterPrescale().size() < 8) lvl1Result->itemsAfterPrescale().resize(8, 0);
      if (lvl1Result->itemsAfterVeto().size() < 8) lvl1Result->itemsAfterVeto().resize(8, 0);
      *lvl1ResultOut = lvl1Result.get();
      ATH_CHECK(SG::makeHandle(m_l1ResultKey).record( std::move(lvl1Result)), {});
   } // if (lvl1ResultOut)
 
   return items;
}

initialize()

StatusCode HLT::Lvl1ResultAccessTool::initialize ( )

overridevirtual

Definition at line 22 of file Lvl1ResultAccessTool.cxx.

                                    {
 
   ATH_CHECK( m_l1PrescaleSetInputKey.initialize( ) );
   ATH_CHECK( m_l1ResultKey.initialize( ) );
 
   return StatusCode::SUCCESS;
}

isCalibrationEvent()

bool HLT::Lvl1ResultAccessTool::isCalibrationEvent ( const ROIB::RoIBResult & result ) const

overridevirtual

checks if we have calibration items fired in this event

Returns

true if calibration items are present in this event

return false; // in the RUN 2 menu there is currently no such restriction and all kinds of items are on these ctp IDs

Definition at line 71 of file Lvl1ResultAccessTool.cxx.

                                                                              {

   int ctpVersion = result.cTPResult().header().formatVersion() & 0xf ;
   CTPdataformatVersion v(ctpVersion);
   std::vector<ROIB::CTPRoI> ctpRoIVec(result.cTPResult().TAV());
   //  if ( ctpRoIVec.size() >= 8 && (ctpRoIVec[7].roIWord() &  0xE0000000) )
   if ( ctpRoIVec.size()==v.getTAVwords() && ( ctpRoIVec[ctpRoIVec.size()-1].roIWord() & 0xE0000000 ) )
      return true;
   else
      return false;
}

lvl1EMTauJetOverflow()

std::bitset< 3 > HLT::Lvl1ResultAccessTool::lvl1EMTauJetOverflow ( const ROIB::RoIBResult & result )

overridevirtual

Check if there was an overflow in the TOB transmission to CMX.

Parameters

result

reference to RoIBResul object

Returns

overflow bits for EM, Tau and Jet threshold

Definition at line 173 of file Lvl1ResultAccessTool.cxx.

{   
   const int MAXEM = 5;         // see ATR-12285
   const int MAXTAU = 5;
   const int MAXJET = 4;
   
   std::map<std::pair<int,int>, int> em, tau, jet;  // (crate,module) : count
 
   // Count number of RoIs per crate/module
   for (const ROIB::EMTauResult& res : result.eMTauResult()) {
      for (const ROIB::EMTauRoI& roi : res.roIVec()) {
         int c = m_cpDecoder.crate(roi.roIWord());
         int m = m_cpDecoder.module(roi.roIWord());
         int t = m_cpDecoder.roiType(roi.roIWord());
 
         if (t==LVL1::TrigT1CaloDefs::EMRoIWordType) ++em[{c,m}];
         else if (t==LVL1::TrigT1CaloDefs::TauRoIWordType) ++tau[{c,m}];
      }
   }
 
   for (const ROIB::JetEnergyResult& res : result.jetEnergyResult()) {
      for (const ROIB::JetEnergyRoI& roi : res.roIVec()) {
         int c = m_jepDecoder.crate(roi.roIWord());
         int m = m_jepDecoder.module(roi.roIWord());
         int t = m_jepDecoder.roiType(roi.roIWord());
 
         if (t==LVL1::TrigT1CaloDefs::JetRoIWordType) ++jet[{c,m}];
      }
   }
 
   // Check if there was an overflow
   std::bitset<3> overflow;
   overflow[0] = std::count_if(em.begin(), em.end(), [](const decltype(em)::value_type& i){return i.second>MAXEM;});
   overflow[1] = std::count_if(tau.begin(), tau.end(), [](const decltype(tau)::value_type& i){return i.second>MAXTAU;});
   overflow[2] = std::count_if(jet.begin(), jet.end(), [](const decltype(jet)::value_type& i){return i.second>MAXJET;});
 
   if (msgLvl(MSG::DEBUG)) {
      msg() << "EM RoI multiplicities by crate,module: ";
      for (const auto& i : em) msg() << "(" << i.first.first << "," << i.first.second << "):" << i.second << " ";
 
      msg() << endmsg << "Tau RoI multiplicities by crate,module: ";
      for (const auto& i : tau) msg() << "(" << i.first.first << "," << i.first.second << "):" << i.second << " ";
 
      msg() << endmsg << "Jet RoI multiplicities by crate,module: ";
      for (const auto& i : jet) msg() << "(" << i.first.first << "," << i.first.second << "):" << i.second << " ";
      msg() << endmsg;
   }
   
   return overflow;
}

makeLvl1ItemConfig()

std::vector< std::unique_ptr< LVL1CTP::Lvl1Item > > HLT::Lvl1ResultAccessTool::makeLvl1ItemConfig ( const EventContext & context ) const

overridevirtual

Definition at line 36 of file Lvl1ResultAccessTool.cxx.

{
   // vector holding all configured LVL1 items, default initializes to empty unique_ptr
   constexpr size_t numberOfCTPItems = 512; // this is fixed
   std::vector<std::unique_ptr<LVL1CTP::Lvl1Item>> lvl1ItemConfig(numberOfCTPItems);
 
   const TrigConf::L1Menu *l1menu = nullptr;
   if( detStore()->retrieve(l1menu).isFailure() ) {
      ATH_MSG_ERROR("No L1Menu found");
   } else {
      SG::ReadCondHandle<TrigConf::L1PrescalesSet> l1psRH(m_l1PrescaleSetInputKey, context);
      if( !l1psRH.isValid() ) {
         ATH_MSG_ERROR("No valid L1PrescalesSet handle");
      } else {
         const TrigConf::L1PrescalesSet* l1PrescaleSet{*l1psRH};
         if(l1PrescaleSet == nullptr) {
            ATH_MSG_ERROR( "No L1PrescalesSet available");
         } else {
            for(auto & item : *l1menu) {
               double prescale = l1PrescaleSet->getPrescaleFromCut(l1PrescaleSet->prescale(item.name()).cut);
               lvl1ItemConfig[item.ctpId()] = std::make_unique<LVL1CTP::Lvl1Item>( item.name(),
                                                                                   TrigConf::HLTUtils::string2hash(item.name()),
                                                                                   0, 0, 0, prescale);
            }
         }
      }
   }
   return lvl1ItemConfig;
}

Member Data Documentation

m_cpDecoder

LVL1::CPRoIDecoder HLT::Lvl1ResultAccessTool::m_cpDecoder

private

Definition at line 81 of file Lvl1ResultAccessTool.h.

m_jepDecoder

LVL1::JEPRoIDecoder HLT::Lvl1ResultAccessTool::m_jepDecoder

private

Definition at line 80 of file Lvl1ResultAccessTool.h.

m_l1PrescaleSetInputKey

SG::ReadCondHandleKey<TrigConf::L1PrescalesSet> HLT::Lvl1ResultAccessTool::m_l1PrescaleSetInputKey { this, "L1Prescales", "L1Prescales", "L1 prescales set"}

private

access to L1Prescales

Definition at line 84 of file Lvl1ResultAccessTool.h.

{ this, "L1Prescales", "L1Prescales", "L1 prescales set"};

m_l1ResultKey

SG::WriteHandleKey<LVL1CTP::Lvl1Result> HLT::Lvl1ResultAccessTool::m_l1ResultKey { this, "L1Result", "L1Result", "L1 result"}

private

Definition at line 86 of file Lvl1ResultAccessTool.h.

{ this, "L1Result", "L1Result", "L1 result"};

---

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

• Lvl1ResultAccessTool.h
• Lvl1ResultAccessTool.cxx