Trigger configuration service used when reading an xAOD file. More...

#include <xAODConfigSvc.h>

Inheritance diagram for TrigConf::xAODConfigSvc:

Public Member Functions
	xAODConfigSvc (const std::string &name, ISvcLocator *svcLoc)
	Standard service constructor.
virtual StatusCode	initialize () override
	Function initialising the service.
virtual StatusCode	finalize () override
	Function finalising the service.
virtual void	handle (const Incident &inc) override
	Function handling the incoming incidents.
std::string	configurationSource () const override
Implementation of the IILVL1ConfigSvc interface
virtual const CTPConfig *	ctpConfig () const override
	Get the LVL1 trigger menu.
virtual const ThresholdConfig *	thresholdConfig () const override
	Get the LVL1 threshold configuruation (not available from xAOD).
virtual const BunchGroupSet *	bunchGroupSet () const override
	Get the LVL1 bunch group set.
virtual uint32_t	lvl1PrescaleKey () const override
	Get the LVL1 prescale key.
virtual uint32_t	bunchGroupSetKey () const override
	Get the LVL1 bunch group set key.
Implementation of the IIHLTConfigSvc interface
virtual const HLTChainList &	chains () const override
	Get the HLT chains.
virtual const HLTSequenceList &	sequences () const override
	Get the HLT sequences.
virtual uint32_t	masterKey () const override
	Get the Super Master Key.
virtual uint32_t	hltPrescaleKey () const override
	Get the HLT prescale key.
Dummy implementation of the ILVL1ConfigSvc interface
virtual const Muctpi *	muctpiConfig () const override
	Get the MuCTPI's online configuration.
Impliment the JSON config interface.
virtual const HLTMenu &	hltMenu (const EventContext &ctx) const override
	Returns the JSON configured HLTMenu ptree.
virtual const HLTMonitoring &	hltMonitoring (const EventContext &ctx) const override
	Returns the JSON configured HLTMonitoring ptree.
virtual const L1Menu &	l1Menu (const EventContext &ctx) const override
	Returns the JSON configured L1 ptree.
virtual const HLTPrescalesSet &	hltPrescalesSet (const EventContext &ctx) const override
	Returns the JSON configured HLT prescales ptree.
virtual const L1PrescalesSet &	l1PrescalesSet (const EventContext &ctx) const override
	Returns the JSON configured L1 prescales ptree.
virtual const L1BunchGroupSet &	l1BunchGroupSet (const EventContext &ctx) const override
	Returns the JSON configured bunchgroup ptree.

Private Member Functions
StatusCode	readMetadata ()
	Function reading in a new metadata object from the input.
StatusCode	prepareEvent (const EventContext &context)
	Function setting up the service for a new event.
void	copyMetadataToPersonalStore (const xAOD::TriggerMenuJsonContainer input, xAOD::TriggerMenuJsonContainer existing)
	Helper function for copying into the service's private data store.
StatusCode	prepareEventRun3Athena (const EventContext &context)
	Do per-event updating of R3 JSON-based metadata, reading the data direct from the Conditions and Detector stores (UseInFileMetadata=False case).
StatusCode	prepareEventxAODTriggerMenuJson (const xAOD::TrigConfKeys keys, const xAOD::BunchConfKey bgKey, const EventContext &context)
	Do per-event decoding for R3 in-file serialised xAOD::TriggerMenuJson metadata.
StatusCode	prepareEventxAODTriggerMenu (const xAOD::TrigConfKeys *keys, const EventContext &context)
	Do per-event decoding for R2 in-file serialised xAOD::TriggerMenu metadata.
StatusCode	loadPtree (const std::string &humanName, const xAOD::TriggerMenuJsonContainer *metaContainer, const uint32_t keyToCheck, TriggerMenuJsonPtrWrapper &cacheOfLoadedMenuPtr, DataStructure &dataStructure, const bool optional=false)
	Helper function to find a JSON in a given TriggerMenuJsonContainer using a given key, extract its ptree data.

Private Attributes
SG::ReadHandleKey< xAOD::TrigConfKeys >	m_eventKey
SG::ReadHandleKey< xAOD::BunchConfKey >	m_eventBGKey
Gaudi::Property< bool >	m_useInFileMetadata
Gaudi::Property< bool >	m_stopOnFailure {this, "StopOnFailure", true, "Flag for stopping the job in case of a failure"}
bool	m_isInFailure {false}
	Internal state of the service.
std::shared_mutex	m_sharedMutex
	The mutex used to to restrict access to m_tmc when it is being written to.
ServiceHandle< StoreGateSvc >	m_metaStore {this, "MetaDataStore", "StoreGateSvc/InputMetaDataStore"}
	Connection to the metadata store.
bool	m_triggerMenuContainerAvailable {false}
	Is decoded R2 format data available?
bool	m_menuJSONContainerAvailable {false}
	Is decoded R3 format data available?
Names for reading the R2 (and R1) AOD metadata payload
Gaudi::Property< std::string >	m_metaName
Names for reading the R3 AOD metadata payload
Gaudi::Property< std::string >	m_metaNameJSON_hlt
Gaudi::Property< std::string >	m_metaNameJSON_hltmonitoring
Gaudi::Property< std::string >	m_metaNameJSON_l1
Gaudi::Property< std::string >	m_metaNameJSON_hltps
Gaudi::Property< std::string >	m_metaNameJSON_l1ps
Gaudi::Property< std::string >	m_metaNameJSON_bg
Names for reading the R3 payload directly (RAWtoALL)
SG::ReadHandleKey< HLTMenu >	m_hltMenuKey
SG::ReadHandleKey< L1Menu >	m_l1MenuKey
SG::ReadCondHandleKey< TrigConf::HLTPrescalesSet >	m_HLTPrescaleSetKey
SG::ReadCondHandleKey< TrigConf::L1PrescalesSet >	m_L1PrescaleSetKey
SG::ReadCondHandleKey< TrigConf::L1BunchGroupSet >	m_L1BunchGroupSetKey {this, "L1BunchGroup", "L1BunchGroup", "L1 Bunch groups"}
The configuration objects copied from all input files. R1 and R2 AOD
std::unique_ptr< xAOD::TriggerMenuAuxContainer >	m_tmcAux
std::unique_ptr< xAOD::TriggerMenuContainer >	m_tmc
SG::SlotSpecificObj< MenuPtrWrapper >	m_menu
The configuration objects copied from all input files. R3 AOD
std::unique_ptr< xAOD::TriggerMenuJsonAuxContainer >	m_hltJsonAux
std::unique_ptr< xAOD::TriggerMenuJsonContainer >	m_hltJson
std::unique_ptr< xAOD::TriggerMenuJsonAuxContainer >	m_hltmonitoringJsonAux
std::unique_ptr< xAOD::TriggerMenuJsonContainer >	m_hltmonitoringJson
std::unique_ptr< xAOD::TriggerMenuJsonAuxContainer >	m_l1JsonAux
std::unique_ptr< xAOD::TriggerMenuJsonContainer >	m_l1Json
std::unique_ptr< xAOD::TriggerMenuJsonAuxContainer >	m_hltpsJsonAux
std::unique_ptr< xAOD::TriggerMenuJsonContainer >	m_hltpsJson
std::unique_ptr< xAOD::TriggerMenuJsonAuxContainer >	m_l1psJsonAux
std::unique_ptr< xAOD::TriggerMenuJsonContainer >	m_l1psJson
std::unique_ptr< xAOD::TriggerMenuJsonAuxContainer >	m_bgJsonAux
std::unique_ptr< xAOD::TriggerMenuJsonContainer >	m_bgJson
SG::SlotSpecificObj< TriggerMenuJsonPtrWrapper >	m_currentHltJson
SG::SlotSpecificObj< TriggerMenuJsonPtrWrapper >	m_currentHltmonitoringJson
SG::SlotSpecificObj< TriggerMenuJsonPtrWrapper >	m_currentL1Json
SG::SlotSpecificObj< TriggerMenuJsonPtrWrapper >	m_currentHltpsJson
SG::SlotSpecificObj< TriggerMenuJsonPtrWrapper >	m_currentL1psJson
SG::SlotSpecificObj< TriggerMenuJsonPtrWrapper >	m_currentBgJson
SG::SlotSpecificObj< HLTMenu >	m_currentHlt
SG::SlotSpecificObj< HLTMonitoring >	m_currentHltmonitoring
SG::SlotSpecificObj< L1Menu >	m_currentL1
SG::SlotSpecificObj< HLTPrescalesSet >	m_currentHltps
SG::SlotSpecificObj< L1PrescalesSet >	m_currentL1ps
SG::SlotSpecificObj< L1BunchGroupSet >	m_currentBg
The legacy configuration objects which are populated either from a R1, R2 TriggerMenuContainer or the R3 JSONs
The "translated" LVL1 configuration object
SG::SlotSpecificObj< CTPConfig >	m_ctpConfig
SG::SlotSpecificObj< HLTChainList >	m_chainList
	The "translated" HLT configuration object.
SG::SlotSpecificObj< HLTSequenceList >	m_sequenceList
	The "translated" HLT configuration object.
SG::SlotSpecificObj< BunchGroupSet >	m_bgSet
	The "translated" bunch group set object.

Detailed Description

Trigger configuration service used when reading an xAOD file.

   This implementation of the ITrigConfigSvc interface can be
   used when reading an xAOD file in Athena to get the correct
   configuration for the current event.

Author: Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 75 of file xAODConfigSvc.h.

Constructor & Destructor Documentation

◆ xAODConfigSvc()

TrigConf::xAODConfigSvc::xAODConfigSvc	(	const std::string &	name,
		ISvcLocator *	svcLoc )

Standard service constructor.

Definition at line 27 of file xAODConfigSvc.cxx.

      : base_class( name, svcLoc ),        
        m_tmcAux( nullptr ), m_tmc( nullptr ), m_menu(),
        m_ctpConfig(), m_chainList(), m_sequenceList(), m_bgSet() {
 
   }

Member Function Documentation

◆ bunchGroupSet()

const BunchGroupSet * TrigConf::xAODConfigSvc::bunchGroupSet ( ) const

overridevirtual

Get the LVL1 bunch group set.

Definition at line 127 of file xAODConfigSvc.cxx.

                                                           {
 
      // Long-term-support interface (including Run 2 AODs)
      if( m_isInFailure ) {
         REPORT_MESSAGE( MSG::FATAL )
            << "Trigger menu not loaded";
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::bunchGroupSet",
                               StatusCode::FAILURE );
      }
 
      // Return the slot-specific pointer:
      return m_bgSet.get();
   }

◆ bunchGroupSetKey()

uint32_t TrigConf::xAODConfigSvc::bunchGroupSetKey ( ) const

overridevirtual

Get the LVL1 bunch group set key.

Definition at line 247 of file xAODConfigSvc.cxx.

                                                  {
      if (!m_useInFileMetadata) {
         const bool firstEvent = !m_currentBg.get()->isInitialized();
         if (firstEvent)
            return std::numeric_limits<uint32_t>::max();
         SG::ReadCondHandle<TrigConf::L1BunchGroupSet> l1BGS(m_L1BunchGroupSetKey);
         if (!l1BGS.isValid())
         {
            REPORT_MESSAGE( MSG::WARNING )
               << "Unable to load " << m_L1BunchGroupSetKey.key() << " from Conditions Store." << endmsg;
            return std::numeric_limits<uint32_t>::max();
         }
         else
            return l1BGS->bgsk();
      } else if (m_menuJSONContainerAvailable)
         return m_currentBg.get()->bgsk();
      else {
         REPORT_MESSAGE( MSG::DEBUG )
            << "There's no way to access the bunch group set key from a legacy AOD!" << endmsg;
         return std::numeric_limits<uint32_t>::max();
      }
   }

◆ chains()

const HLTChainList & TrigConf::xAODConfigSvc::chains ( ) const

overridevirtual

Get the HLT chains.

Definition at line 143 of file xAODConfigSvc.cxx.

                                                   {
 
      // Long-term-support interface (including Run 2 AODs)
      if( m_isInFailure ) {
         REPORT_MESSAGE( MSG::FATAL )
            << "Trigger menu not loaded";
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::chains",
                               StatusCode::FAILURE );
      }
 
      // Return the slot-specifc object:
      return *(m_chainList.get());
   }

◆ configurationSource()

std::string TrigConf::xAODConfigSvc::configurationSource ( ) const

inlineoverride

Definition at line 161 of file xAODConfigSvc.h.

                                                     {
         return "";
      }

◆ copyMetadataToPersonalStore()

void TrigConf::xAODConfigSvc::copyMetadataToPersonalStore	(	const xAOD::TriggerMenuJsonContainer *	input,
		xAOD::TriggerMenuJsonContainer *	existing )

private

Helper function for copying into the service's private data store.

Definition at line 614 of file xAODConfigSvc.cxx.

                                                                                                                                    {
      for ( const xAOD::TriggerMenuJson* inputTriggerMenuJson : *input ) {
         bool alreadyHave = false;
         for( const xAOD::TriggerMenuJson* existingTriggerMenuJson : *existing ) {
            if (inputTriggerMenuJson->key() == existingTriggerMenuJson->key()) {
               alreadyHave = true;
               break;
            }
         }
         if (alreadyHave) {
            continue;
         }
         // Copy this menu JSON into the service's internal cache of all menus
         xAOD::TriggerMenuJson* newTriggerMenuJson = new xAOD::TriggerMenuJson();
         existing->push_back( newTriggerMenuJson ); // Note: 'newTriggerMenuJson' is now memory managed by 'existing'
         *newTriggerMenuJson = *inputTriggerMenuJson; // Perform xAOD copy
         REPORT_MESSAGE( MSG::DEBUG ) << "Imported new configuration: Name = " << newTriggerMenuJson->name() << " Key = " << newTriggerMenuJson->key() << endmsg;
      }
   }

◆ ctpConfig()

const CTPConfig * TrigConf::xAODConfigSvc::ctpConfig ( ) const

overridevirtual

Get the LVL1 trigger menu.

Definition at line 112 of file xAODConfigSvc.cxx.

                                                   {
 
      // Long-term-support interface for (including Run 2 AODs)
      if( m_isInFailure ) {
         REPORT_MESSAGE( MSG::FATAL )
            << "Trigger menu not loaded";
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::ctpConfig",
                               StatusCode::FAILURE );
      }
 
      // Return the slot-specific pointer:
      return m_ctpConfig.get();
   }

◆ finalize()

StatusCode TrigConf::xAODConfigSvc::finalize ( )

overridevirtual

Function finalising the service.

Definition at line 106 of file xAODConfigSvc.cxx.

                                      {
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

◆ handle()

void TrigConf::xAODConfigSvc::handle ( const Incident & inc )

overridevirtual

Function handling the incoming incidents.

Definition at line 405 of file xAODConfigSvc.cxx.

                                                   {
 
      // Tell the user what we're doing:
      REPORT_MESSAGE( MSG::DEBUG ) << "Callback received with incident: "
                     << inc.type() << endmsg;
 
      // If it's a file-beginning incident, let's read in the
      // metadata object:
      if( inc.type() == IncidentType::BeginInputFile ) {
         if( readMetadata().isFailure() && m_stopOnFailure ) {
            REPORT_MESSAGE( MSG::FATAL )
               << "Couldn't read in the input file's metadata";
            throw GaudiException( "Couldn't read in the input file's "
                                  "metadata",
                                  "TrigConf::xAODConfigSvc::handle",
                                  StatusCode::FAILURE );
            return;
         }
      }
      // If it's an event-beginning incident, let's make sure that the
      // correct menu is cached:
      else if( inc.type() == IncidentType::BeginEvent ) {
         if( prepareEvent(inc.context()).isFailure() && m_stopOnFailure ) {
            REPORT_MESSAGE( MSG::FATAL )
               << "Couldn't prepare the trigger configuration for the "
               << "current event";
            throw GaudiException( "Couldn't prepare the trigger configuration "
                                  "for the current event",
                                  "TrigConf::xAODConfigSvc::handle",
                                  StatusCode::FAILURE );
            return;
         }
      }
      // We got some strange incident...
      else {
         REPORT_MESSAGE( MSG::WARNING ) << "Unknown incident type received: "
                          << inc.type() << endmsg;
         return;
      }
 
      // Return gracefully:
      return;
   }

◆ hltMenu()

const HLTMenu & TrigConf::xAODConfigSvc::hltMenu ( const EventContext & ctx ) const

overridevirtual

Returns the JSON configured HLTMenu ptree.

Definition at line 310 of file xAODConfigSvc.cxx.

                                                                      {
      if (!m_useInFileMetadata) {
         SG::ReadHandle<HLTMenu> hltMenuHandle(m_hltMenuKey, ctx);
         if( hltMenuHandle.isValid() ) {
            return *hltMenuHandle;
         }
      }
      if (!m_menuJSONContainerAvailable) {
         REPORT_MESSAGE( MSG::FATAL ) << "Run 3 hltMenu JSON not loaded." << endmsg;
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::hltMenu",
                               StatusCode::FAILURE );
      }
      // Run3: From in-file JSON metadata or JSON from detector store
      return *(m_currentHlt.get(ctx));
   }

◆ hltMonitoring()

const HLTMonitoring & TrigConf::xAODConfigSvc::hltMonitoring ( const EventContext & ctx ) const

overridevirtual

Returns the JSON configured HLTMonitoring ptree.

Definition at line 327 of file xAODConfigSvc.cxx.

                                                                                  {
      if (!m_menuJSONContainerAvailable) {
         REPORT_MESSAGE( MSG::FATAL ) << "Run 3 hltMonitoring JSON not loaded." << endmsg;
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::hltMenu",
                               StatusCode::FAILURE );
      }
      // Run3: From in-file JSON metadata
      return *(m_currentHltmonitoring.get(ctx));
   }

◆ hltPrescaleKey()

uint32_t TrigConf::xAODConfigSvc::hltPrescaleKey ( ) const

overridevirtual

Get the HLT prescale key.

Definition at line 270 of file xAODConfigSvc.cxx.

                                                {
      if (!m_useInFileMetadata) {
 
         const bool firstEvent = !m_currentHltps.get()->isInitialized();
         if (firstEvent) {
            return std::numeric_limits<uint32_t>::max();
         }
 
         SG::ReadCondHandle<HLTPrescalesSet> hltpsRCH(m_HLTPrescaleSetKey);
         if( !hltpsRCH.isValid() ) {
            REPORT_MESSAGE( MSG::WARNING )
                << "Unable to load " << m_HLTPrescaleSetKey.key() << " from Conditions Store." << endmsg;
            return std::numeric_limits<uint32_t>::max();
         } else {
            return hltpsRCH->psk();      
         }
 
      } else if (m_menuJSONContainerAvailable) {
 
         // Run3: From in-file JSON metadata or JSON from conditions store
         return m_currentHltps.get()->psk();
 
      } else {
 
         // Legacy support for R2 AODs
         if( ! m_menu.get()->m_ptr ) {
            REPORT_MESSAGE( MSG::FATAL )
               << "Trigger menu not yet known. Configuration key not returned.";
            throw GaudiException( "Service not initialised correctly",
                                  "TrigConf::xAODConfigSvc::hltPrescaleKey",
                                  StatusCode::FAILURE );
            return 0;
         }
 
         // Return the key from the slot-specific metadata object:
         return m_menu.get()->m_ptr->hltpsk();
 
      }
   }

◆ hltPrescalesSet()

const HLTPrescalesSet & TrigConf::xAODConfigSvc::hltPrescalesSet ( const EventContext & ctx ) const

overridevirtual

Returns the JSON configured HLT prescales ptree.

Definition at line 355 of file xAODConfigSvc.cxx.

                                                                                      {
      if (!m_useInFileMetadata) {
         SG::ReadCondHandle<HLTPrescalesSet> hltpsRCH(m_HLTPrescaleSetKey, ctx);
         if( hltpsRCH.isValid() ) {
            return **hltpsRCH;
         }
      }
      if (!m_menuJSONContainerAvailable) {
         REPORT_MESSAGE( MSG::FATAL ) << "Run 3 hltPrescalesSet JSON not loaded." << endmsg;
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::hltPrescalesSet",
                               StatusCode::FAILURE );
      }
      // Run3: From in-file JSON metadata or JSON from conditions store
      return *(m_currentHltps.get(ctx));
   }

◆ initialize()

StatusCode TrigConf::xAODConfigSvc::initialize ( )

overridevirtual

Function initialising the service.

Definition at line 34 of file xAODConfigSvc.cxx.

                                        {
 
      // Greet the user:
      ATH_MSG_INFO( "Initialising" );
 
      // Note this is a service, there is NO scheduler propagation of these read handle keys to clients of this service.
      // We still however use the ReadHandle mechanism to consume the collection, along with validation checks.
      // Attempting to use this service when no eventKey is available will cause the service to fail.
      // Attempting to use this service when no eventBGKey is available will return empty bunch group data.
      CHECK( m_eventKey.initialize() );
      CHECK( m_eventBGKey.initialize() );
 
      CHECK( m_hltMenuKey.initialize() );
      CHECK( m_l1MenuKey.initialize() );
 
      // Set up the callbacks for the service:
      ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
      CHECK( incSvc.retrieve() );
      incSvc->addListener( this, IncidentType::BeginEvent, 0,
                           m_stopOnFailure );
 
      if (m_useInFileMetadata) {
        // Retrieve the needed service(s):
        CHECK( m_metaStore.retrieve() );
 
        // Set up the callbacks for the service:
        ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
        incSvc->addListener( this, IncidentType::BeginInputFile, 0,
                             m_stopOnFailure );
 
        // Internal holder for R2 payloads
        m_tmcAux = std::make_unique<xAOD::TriggerMenuAuxContainer>();
        m_tmc    = std::make_unique<xAOD::TriggerMenuContainer>();
        m_tmc->setStore( m_tmcAux.get() );
 
        // Internal holders for R3 payloads
        m_hltJsonAux = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
        m_hltJson    = std::make_unique<xAOD::TriggerMenuJsonContainer>();
        m_hltJson->setStore( m_hltJsonAux.get() );
 
        m_hltmonitoringJsonAux = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
        m_hltmonitoringJson    = std::make_unique<xAOD::TriggerMenuJsonContainer>();
        m_hltmonitoringJson->setStore( m_hltmonitoringJsonAux.get() );
 
        m_l1JsonAux = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
        m_l1Json    = std::make_unique<xAOD::TriggerMenuJsonContainer>();
        m_l1Json->setStore( m_l1JsonAux.get() );
 
        m_hltpsJsonAux = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
        m_hltpsJson    = std::make_unique<xAOD::TriggerMenuJsonContainer>();
        m_hltpsJson->setStore( m_hltpsJsonAux.get() );
 
        m_l1psJsonAux = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
        m_l1psJson    = std::make_unique<xAOD::TriggerMenuJsonContainer>();
        m_l1psJson->setStore( m_l1psJsonAux.get() );
 
        m_bgJsonAux = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
        m_bgJson    = std::make_unique<xAOD::TriggerMenuJsonContainer>();
        m_bgJson->setStore( m_bgJsonAux.get() );
      }
 
      ATH_CHECK( m_HLTPrescaleSetKey.initialize( !m_useInFileMetadata ) );
      ATH_CHECK( m_L1PrescaleSetKey.initialize( !m_useInFileMetadata ) );
      ATH_CHECK( m_L1BunchGroupSetKey.initialize( !m_useInFileMetadata ) );
 
      // Reset the internal flag:
      m_isInFailure = false;
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

◆ l1BunchGroupSet()

const L1BunchGroupSet & TrigConf::xAODConfigSvc::l1BunchGroupSet ( const EventContext & ctx ) const

overridevirtual

Returns the JSON configured bunchgroup ptree.

Definition at line 389 of file xAODConfigSvc.cxx.

                                                                                      {
      if (!m_useInFileMetadata) {
         SG::ReadCondHandle<L1BunchGroupSet> l1BGS(m_L1BunchGroupSetKey, ctx);
         if( l1BGS.isValid() )
            return **l1BGS;
      }
      if (!m_menuJSONContainerAvailable) {
         REPORT_MESSAGE( MSG::FATAL ) << "Run 3 l1BunchGroupSet JSON not loaded." << endmsg;
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::l1BunchGroupSet",
                               StatusCode::FAILURE );
      }
      // Run3: From in-file JSON metadata or JSON from conditions store
      return *(m_currentBg.get(ctx));
   }

◆ l1Menu()

const L1Menu & TrigConf::xAODConfigSvc::l1Menu ( const EventContext & ctx ) const

overridevirtual

Returns the JSON configured L1 ptree.

Definition at line 338 of file xAODConfigSvc.cxx.

                                                                    {
      if (!m_useInFileMetadata) {
         SG::ReadHandle<L1Menu> l1MenuHandle(m_l1MenuKey, ctx);
         if( l1MenuHandle.isValid() ) {
            return *l1MenuHandle;
         }
      }
      if (!m_menuJSONContainerAvailable) {
         REPORT_MESSAGE( MSG::FATAL ) << "Run 3 l1Menu JSON not loaded." << endmsg;
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::l1Menu",
                               StatusCode::FAILURE );
      }
      // Run3: From in-file JSON metadata or JSON from detector store
      return *(m_currentL1.get(ctx));
   }

◆ l1PrescalesSet()

const L1PrescalesSet & TrigConf::xAODConfigSvc::l1PrescalesSet ( const EventContext & ctx ) const

overridevirtual

Returns the JSON configured L1 prescales ptree.

Definition at line 372 of file xAODConfigSvc.cxx.

                                                                                    {
      if (!m_useInFileMetadata) {
         SG::ReadCondHandle<L1PrescalesSet> l1psRCH(m_L1PrescaleSetKey, ctx);
         if( l1psRCH.isValid() ) {
            return **l1psRCH;
         }
      }
      if(!m_menuJSONContainerAvailable) {
         REPORT_MESSAGE( MSG::FATAL ) << "Run 3 l1PrescalesSet JSON not loaded." << endmsg;
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::l1PrescalesSet",
                               StatusCode::FAILURE );
      }
      // Run3: From in-file JSON metadata or JSON from conditions store
      return *(m_currentL1ps.get(ctx));
   }

◆ loadPtree()

StatusCode TrigConf::xAODConfigSvc::loadPtree	(	const std::string &	humanName,
		const xAOD::TriggerMenuJsonContainer *	metaContainer,
		const uint32_t	keyToCheck,
		TriggerMenuJsonPtrWrapper &	cacheOfLoadedMenuPtr,
		DataStructure &	dataStructure,
		const bool	optional = false )

private

Helper function to find a JSON in a given TriggerMenuJsonContainer using a given key, extract its ptree data.

Parameters

humanName	Name to print if things go wrong
metaContainer	Metadata container of TriggerMenuJson objects from which to load a ptree
keyToCheck	The key of the ptree to load
cacheOfLoadedMenuPtr	Slot's cache of the currently loaded TriggerMenuJson
DataStructure	dataStructure object to fill with the TriggerMenuJson's payload
optional	Set to true if it is expected in some valid scenarios for the payload to be missing

Definition at line 952 of file xAODConfigSvc.cxx.

                                                            {
      xAOD::TriggerMenuJsonContainer::const_iterator menu_itr = metaContainer->begin();
      xAOD::TriggerMenuJsonContainer::const_iterator menu_end = metaContainer->end();
      const xAOD::TriggerMenuJson* ptrToLocatedMenu = nullptr;
      cacheOfLoadedMenuPtr.m_ptr = nullptr;
      for( ; menu_itr != menu_end; ++menu_itr ) {
         // Check if this is the menu we're looking for:
         if( keyToCheck != (*menu_itr)->key() ) continue;
         // Remember its pointer:
         ptrToLocatedMenu = *menu_itr;
         cacheOfLoadedMenuPtr.m_ptr = ptrToLocatedMenu;
         std::stringstream rawData;
         rawData << ptrToLocatedMenu->payload();
         dataStructure.clear();
         try {
            boost::property_tree::ptree pt;
            boost::property_tree::read_json(rawData, pt);
            dataStructure.setData(std::move(pt));
         } catch (const boost::property_tree::json_parser_error& e) {
            REPORT_MESSAGE( MSG::FATAL ) << "Unable to decode a JSON trigger menu metadata payload for " << humanName << " with key " << keyToCheck << endmsg;
            REPORT_MESSAGE( MSG::FATAL ) << e.what();
            return StatusCode::FAILURE;
         }
         break;
      }
 
      if (not optional and ptrToLocatedMenu == nullptr) {
         REPORT_MESSAGE( MSG::FATAL )
            << "Couldn't find configuration for current event"
            << ", Requested key=" << keyToCheck
            << ", Requested menu=" << humanName
            << endmsg;
         return StatusCode::FAILURE;
      }
      return StatusCode::SUCCESS;
   }

◆ lvl1PrescaleKey()

uint32_t TrigConf::xAODConfigSvc::lvl1PrescaleKey ( ) const

overridevirtual

Get the LVL1 prescale key.

Definition at line 208 of file xAODConfigSvc.cxx.

                                                 {
      if (!m_useInFileMetadata) {
 
         const bool firstEvent = !m_currentL1ps.get()->isInitialized();
         if (firstEvent) {
            return std::numeric_limits<uint32_t>::max();
         }
 
         SG::ReadCondHandle<L1PrescalesSet> l1psRCH(m_L1PrescaleSetKey);
         if( !l1psRCH.isValid() ) {
            REPORT_MESSAGE( MSG::WARNING )
                << "Unable to load " << m_L1PrescaleSetKey.key() << " from Conditions Store." << endmsg;
            return std::numeric_limits<uint32_t>::max();
         } else {
            return l1psRCH->psk();
         }
 
      } else if (m_menuJSONContainerAvailable) {
         
         // Run3: From in-file JSON metadata or JSON from conditions store
         return m_currentL1ps.get()->psk();
 
      } else {
 
         // Legacy support for R2 AODs
         if( ! m_menu.get()->m_ptr ) {
            REPORT_MESSAGE( MSG::ERROR )
               << "Trigger menu not yet known. Configuration key not returned.";
            throw GaudiException( "Service not initialised correctly",
                                  "TrigConf::xAODConfigSvc::lvl1PrescaleKey",
                                  StatusCode::FAILURE );
            return 0;
         }
 
         // Return the key from the slot-specific metadata object:
         return m_menu.get()->m_ptr->l1psk();
      }
   }

◆ masterKey()

uint32_t TrigConf::xAODConfigSvc::masterKey ( ) const

overridevirtual

Get the Super Master Key.

Definition at line 173 of file xAODConfigSvc.cxx.

                                           {
      if (!m_useInFileMetadata) {
 
         SG::ReadHandle<HLTMenu> hltMenuHandle(m_hltMenuKey);  // No context - Detector Store
         if( !hltMenuHandle.isValid() ) {
            REPORT_MESSAGE( MSG::WARNING )
                << "Unable to load " << m_hltMenuKey.key() << " from Detector Store." << endmsg;
            return std::numeric_limits<uint32_t>::max();
         } else {
            return hltMenuHandle->smk();
         }
 
      } else if (m_menuJSONContainerAvailable) {
 
         // Run3: From in-file JSON metadata or JSON from conditions store
         return m_currentHlt.get()->smk();
 
      } else {
 
         // Legacy support for R2 AODs
         if( ! m_menu.get()->m_ptr ) {
            REPORT_MESSAGE( MSG::FATAL )
               << "Trigger menu not yet known. Configuration key not returned.";
            throw GaudiException( "Service not initialised correctly",
                                  "TrigConf::xAODConfigSvc::masterKey",
                                  StatusCode::FAILURE );
            return 0;
         }
 
         // Return the key from the slot-specific metadata object:
         return m_menu.get()->m_ptr->smk();
 
      }
   }

◆ muctpiConfig()

virtual const Muctpi * TrigConf::xAODConfigSvc::muctpiConfig ( ) const

inlineoverridevirtual

Get the MuCTPI's online configuration.

Definition at line 129 of file xAODConfigSvc.h.

                                                          {
         return 0;
      }

◆ prepareEvent()

StatusCode TrigConf::xAODConfigSvc::prepareEvent ( const EventContext & context )

private

Function setting up the service for a new event.

Definition at line 634 of file xAODConfigSvc.cxx.

                                                                     {
 
      if (!m_useInFileMetadata) { // Run 3 RAWtoALL decoding mode
         return prepareEventRun3Athena(context);
      }
 
      // Otherwise we're dealing with in-file data
      // Read the current event's trigger keys:
      SG::ReadHandle<xAOD::TrigConfKeys> keysRH(m_eventKey, context);
      const xAOD::TrigConfKeys* keys = nullptr;
      if( keysRH.isValid() ) {
         keys = keysRH.cptr();
      } else {
         // Update the internal flag:
         m_isInFailure = true;
         // Decide what to do:
         if( m_stopOnFailure ) {
            REPORT_MESSAGE( MSG::FATAL )
               << "Coudln't retrieve xAOD::TrigConfKeys";
            return StatusCode::FAILURE;
         } else {
            REPORT_MESSAGE( MSG::DEBUG ) << "Coudln't retrieve xAOD::TrigConfKeys" << endmsg;
            return StatusCode::SUCCESS;
         }
      }
 
      SG::ReadHandle<xAOD::BunchConfKey> bgKeyRH(m_eventBGKey, context);
      const xAOD::BunchConfKey* bgKey = nullptr;
      if (bgKeyRH.isValid()) {
         bgKey = bgKeyRH.cptr();
      } // Note: This is optional, no errors if it cannot be found
 
      if (m_menuJSONContainerAvailable) { // Run 3 AOD decoding mode
         return prepareEventxAODTriggerMenuJson(keys, bgKey, context);
      } else if (m_triggerMenuContainerAvailable) {  // Run 2 AOD decoding mode
         return prepareEventxAODTriggerMenu(keys, context);
      }
      ATH_MSG_ERROR( "Both m_menuJSONContainerAvailable and m_triggerMenuContainerAvailable are false" );
      return StatusCode::FAILURE;
   }

◆ prepareEventRun3Athena()

StatusCode TrigConf::xAODConfigSvc::prepareEventRun3Athena ( const EventContext & context )

private

Do per-event updating of R3 JSON-based metadata, reading the data direct from the Conditions and Detector stores (UseInFileMetadata=False case).

Definition at line 724 of file xAODConfigSvc.cxx.

                                                                               {
      HLTMenu&         currentHlt   = *(m_currentHlt.get(context));
      L1Menu&          currentL1    = *(m_currentL1.get(context));
      HLTPrescalesSet& currentHltps = *(m_currentHltps.get(context));
      L1PrescalesSet&  currentL1ps  = *(m_currentL1ps.get(context));
      L1BunchGroupSet& currentBg    = *(m_currentBg.get(context));
 
      // There is only the beginEvent incident when reading the data from the Detector and Conditions stores.
      // So only one thread may be active at one time on these (slot-specific) objects. Hence we do not need to lock like
      // we do when we also have to deal with the possibility of concurrent beginFile incidents.
 
      bool validConfig = true;
 
      // In the beginEvent incident _before_ the first event, we cannot read the prescales (conditions) but we can still
      // read the menu (detector store).
      const bool firstEvent = (!currentHlt.isInitialized() and !currentHltps.isInitialized());
 
      SG::ReadHandle<HLTMenu> hltMenuHandle(m_hltMenuKey, context);
      if( !hltMenuHandle.isValid() ) {
          REPORT_MESSAGE( MSG::WARNING )
             << "Unable to load " << m_hltMenuKey.key() << " from Detector Store." << endmsg;
      } else {
         if (!currentHlt.isInitialized() or currentHlt.smk() != hltMenuHandle->smk()) {
            validConfig = false;
            currentHlt.clear();
            currentHlt.setData( hltMenuHandle->data() );
            currentHlt.setSMK( hltMenuHandle->smk() );
         }
      }
 
      SG::ReadHandle<L1Menu> l1MenuHandle(m_l1MenuKey, context);
      if( !l1MenuHandle.isValid() ) {
          REPORT_MESSAGE( MSG::WARNING )
             << "Unable to load " << m_l1MenuKey.key() << " from Detector Store." << endmsg;
      } else {
         if (!currentL1.isInitialized() or currentL1.smk() != l1MenuHandle->smk()) {
            validConfig = false;
            currentL1.clear();
            currentL1.setData( l1MenuHandle->data() );
            currentL1.setSMK( l1MenuHandle->smk() );
         }
      }
 
      if (firstEvent) {
 
          REPORT_MESSAGE( MSG::DEBUG )
             << "L1 and HLT prescales will not be available via the TrigConf::xAODConfigSvc in the first "
             << "event when running with UseInFileMetadata=False" << endmsg;
             
      } else {
 
         SG::ReadCondHandle<L1PrescalesSet> l1psRCH(m_L1PrescaleSetKey, context);
         if( !l1psRCH.isValid() ) {
             REPORT_MESSAGE( MSG::WARNING )
                << "Unable to load " << m_L1PrescaleSetKey.key() << " from Conditions Store." << endmsg;
         } else {
            if (!currentL1ps.isInitialized() or currentL1ps.psk() != l1psRCH->psk()) {
               validConfig = false;
               currentL1ps.clear();
               currentL1ps.setData( l1psRCH->data() );
               currentL1ps.setPSK( l1psRCH->psk() );
            }
         }
   
         SG::ReadCondHandle<HLTPrescalesSet> hltpsRCH(m_HLTPrescaleSetKey, context);
         if( !hltpsRCH.isValid() ) {
             REPORT_MESSAGE( MSG::WARNING )
                << "Unable to load " << m_HLTPrescaleSetKey.key() << " from Conditions Store." << endmsg;
         } else {
            if (!currentHltps.isInitialized() or currentHltps.psk() != hltpsRCH->psk()) {
               validConfig = false;
               currentHltps.clear();
               currentHltps.setData( hltpsRCH->data() );
               currentHltps.setPSK( hltpsRCH->psk() );
            }        
         }
   
         // Bunchgroup data are not accessible via this service in this mode as the conditions alg uses a different
         // format to the JSON interface used by the trigger.
 
      }
 
      if (validConfig) {
         REPORT_MESSAGE( MSG::DEBUG )
           << "Configuration matches the loaded one, nothing to do." << endmsg;
         return StatusCode::SUCCESS;
      }
 
      CTPConfig& ctpConfig = *(m_ctpConfig.get(context));
      HLTChainList& chainList = *(m_chainList.get(context));
      HLTSequenceList& sequenceList = *(m_sequenceList.get(context));
      BunchGroupSet& bgSet = *(m_bgSet.get(context));
 
      // Copy data into legacy long-term-support interfaces
      CHECK( prepareTriggerMenu( currentHlt,
                                 currentL1,
                                 currentHltps,
                                 currentL1ps,
                                 currentBg,
                                 ctpConfig,
                                 chainList,
                                 sequenceList,
                                 bgSet,
                                 msg() ) );
 
      REPORT_MESSAGE( MSG::INFO ) << "Loaded Trigger configuration from Conditions Store and Detector Store:"
          << "  SMK = " << (currentHlt.isInitialized() ? std::to_string(currentHlt.smk()) : std::string("UNKNOWN"))
          << ", L1PSK = " << (currentL1ps.isInitialized() ? std::to_string(currentL1ps.psk()) : std::string("UNKNOWN"))
          << ", HLTPSK = " << (currentHltps.isInitialized() ? std::to_string(currentHltps.psk()) : std::string("UNKNOWN"))
          << ", BGSK = " << (currentBg.isInitialized() ? std::to_string(currentBg.bgsk()) : std::string("UNKNOWN")) << endmsg;
 
      REPORT_MESSAGE( MSG::DEBUG ) << "ctpConfig.menu().size() = " << ctpConfig.menu().size()
         << " chainList.size() = " << chainList.size()
         << " sequenceList.size() = " << sequenceList.size()
         << " bgSet.bunchGroups().size() = " << bgSet.bunchGroups().size() << endmsg;
 
      return StatusCode::SUCCESS;
   }

◆ prepareEventxAODTriggerMenu()

StatusCode TrigConf::xAODConfigSvc::prepareEventxAODTriggerMenu	(	const xAOD::TrigConfKeys *	keys,
		const EventContext &	context )

private

Do per-event decoding for R2 in-file serialised xAOD::TriggerMenu metadata.

Definition at line 676 of file xAODConfigSvc.cxx.

                                                                                                                  {
      const xAOD::TriggerMenu* loadedMenuInSlot = m_menu.get(context)->m_ptr;
 
      // Check if we have the correct menu already:
      if( loadedMenuInSlot != nullptr && xAODKeysMatch( keys, loadedMenuInSlot ) ) {
         REPORT_MESSAGE( MSG::DEBUG )
           << "Configuration matches the loaded one, nothing to do." << endmsg;
         return StatusCode::SUCCESS;
      }
 
      // If not, let's look for the correct configuration:
      // Open a shared lock. OK for multiple events to search at the same time,
      // but prevent the extension of m_tmc from a BeginInputFile incident.
      std::shared_lock lockShared(m_sharedMutex);
 
      xAOD::TriggerMenuContainer::const_iterator menu_itr = m_tmc->begin();
      xAOD::TriggerMenuContainer::const_iterator menu_end = m_tmc->end();
      for( ; menu_itr != menu_end; ++menu_itr ) {
         // Check if this is the menu we're looking for:
         if( ! xAODKeysMatch( keys, *menu_itr ) ) continue;
         // Remember it's pointer:
         loadedMenuInSlot = *menu_itr;
         m_menu.get(context)->m_ptr = loadedMenuInSlot;
         // Cache the menu's configuration.
         CTPConfig& ctpConfig = *(m_ctpConfig.get(context));
         HLTChainList& chainList = *(m_chainList.get(context));
         HLTSequenceList& sequenceList = *(m_sequenceList.get(context));
         BunchGroupSet& bgSet = *(m_bgSet.get(context));
         CHECK( prepareTriggerMenu( loadedMenuInSlot, ctpConfig,
                                    chainList, sequenceList,
                                    bgSet, msg() ) );
         REPORT_MESSAGE( MSG::DEBUG ) << "ctpConfig.menu().size() = " << ctpConfig.menu().size()
            << " chainList.size() = " << chainList.size()
            << " sequenceList.size() = " << sequenceList.size()
            << " bgSet.bunchGroups().size() = " << bgSet.bunchGroups().size() << endmsg;
         // We're done:
         return StatusCode::SUCCESS;
      }
 
      // Apparently we didn't find the correct menu!
      REPORT_MESSAGE( MSG::FATAL )
         << "Couldn't find configuration for current event (SMK:"
         << keys->smk() << ", L1PSK:" << keys->l1psk()
         << ", HLTPSK:" << keys->hltpsk() << ")";
      return StatusCode::FAILURE;
   }

◆ prepareEventxAODTriggerMenuJson()

StatusCode TrigConf::xAODConfigSvc::prepareEventxAODTriggerMenuJson	(	const xAOD::TrigConfKeys *	keys,
		const xAOD::BunchConfKey *	bgKey,
		const EventContext &	context )

private

Do per-event decoding for R3 in-file serialised xAOD::TriggerMenuJson metadata.

Definition at line 845 of file xAODConfigSvc.cxx.

                                                                                                                                                     {
      const xAOD::TriggerMenuJson* loadedHltJson = m_currentHltJson.get(context)->m_ptr;
      const xAOD::TriggerMenuJson* loadedL1Json = m_currentL1Json.get(context)->m_ptr;
      const xAOD::TriggerMenuJson* loadedHltpsJson = m_currentHltpsJson.get(context)->m_ptr;
      const xAOD::TriggerMenuJson* loadedL1psJson = m_currentL1psJson.get(context)->m_ptr;
      const xAOD::TriggerMenuJson* loadedBgJson = m_currentBgJson.get(context)->m_ptr;
 
      bool validConfig = true;
      if (loadedHltJson == nullptr || loadedHltJson->key() != keys->smk()) {
         validConfig = false;
      }
      // The check on loadedHltJson is good also for loadedHltmonitoringJson
      if (loadedL1Json == nullptr || loadedL1Json->key() != keys->smk()) {
         validConfig = false;
      }
      if (loadedHltpsJson == nullptr || loadedHltpsJson->key() != keys->hltpsk()) {
         validConfig = false;
      }
      if (loadedL1psJson == nullptr || loadedL1psJson->key() != keys->l1psk()) {
         validConfig = false;
      }
      if (bgKey) {
         if (loadedBgJson == nullptr || loadedBgJson->key() != static_cast<unsigned int>(bgKey->id())) {
             validConfig = false;
         }
      }
 
      if (validConfig) {
         REPORT_MESSAGE( MSG::DEBUG )
           << "Configuration matches the loaded one, nothing to do." << endmsg;
         return StatusCode::SUCCESS;
      }
 
      // If not, let's look for the correct configuration:
      // Open a shared lock. OK for multiple events to search at the same time,
      // but prevent the extension of m_hltJson et. al. from a BeginInputFile incident.
      std::shared_lock lockShared(m_sharedMutex);
 
      TriggerMenuJsonPtrWrapper& currentHltJson = *(m_currentHltJson.get(context));
      TriggerMenuJsonPtrWrapper& currentHltmonitoringJson = *(m_currentHltmonitoringJson.get(context));
      TriggerMenuJsonPtrWrapper& currentL1Json = *(m_currentL1Json.get(context));
      TriggerMenuJsonPtrWrapper& currentHltpsJson = *(m_currentHltpsJson.get(context));
      TriggerMenuJsonPtrWrapper& currentL1psJson = *(m_currentL1psJson.get(context));
      TriggerMenuJsonPtrWrapper& currentBgJson = *(m_currentBgJson.get(context));
 
      TrigConf::HLTMenu& currentHlt = *(m_currentHlt.get(context));
      TrigConf::HLTMonitoring& currentHltmonitoring = *(m_currentHltmonitoring.get(context));
      TrigConf::L1Menu& currentL1 = *(m_currentL1.get(context));
      TrigConf::HLTPrescalesSet& currentHltps = *(m_currentHltps.get(context));
      TrigConf::L1PrescalesSet& currentL1ps = *(m_currentL1ps.get(context));
      TrigConf::L1BunchGroupSet& currentBg = *(m_currentBg.get(context));
 
      ATH_CHECK( loadPtree("HLT Menu", m_hltJson.get(), keys->smk(), currentHltJson, currentHlt) );
      ATH_CHECK( loadPtree("HLT Monitoring", m_hltmonitoringJson.get(), keys->smk(), currentHltmonitoringJson, currentHltmonitoring, /*optional=*/true) );
      ATH_CHECK( loadPtree("L1 Menu",  m_l1Json.get(), keys->smk(), currentL1Json, currentL1) );
      ATH_CHECK( loadPtree("HLT Prescales", m_hltpsJson.get(), keys->hltpsk(), currentHltpsJson, currentHltps) );
      ATH_CHECK( loadPtree("L1 Prescales", m_l1psJson.get(), keys->l1psk(), currentL1psJson, currentL1ps) );
      if (bgKey) {
         ATH_CHECK( loadPtree("Bunchgroups", m_bgJson.get(), bgKey->id(), currentBgJson, currentBg) );
      }
 
      // Loading the payload doesn't additionally let the object know about its own key. We can load this in now too.
      // The current*Json objects were updated by loadPtree to point to the entry with the correct key.
      // We don't set this in loadPtree as the poperties are on the derived objects, not the base DataStructure.
      currentHlt.setSMK( currentHltJson.m_ptr->key() );
      if (currentHltmonitoringJson.m_ptr) {
         currentHltmonitoring.setSMK( currentHltmonitoringJson.m_ptr->key() );
      }
      currentL1.setSMK( currentL1Json.m_ptr->key() );
      currentHltps.setPSK( currentHltpsJson.m_ptr->key() );
      currentL1ps.setPSK( currentL1psJson.m_ptr->key() );
      if (bgKey) {
         currentBg.setBGSK( currentBgJson.m_ptr->key() );
      }
 
      CTPConfig& ctpConfig = *(m_ctpConfig.get(context));
      HLTChainList& chainList = *(m_chainList.get(context));
      HLTSequenceList& sequenceList = *(m_sequenceList.get(context));
      BunchGroupSet& bgSet = *(m_bgSet.get(context));
 
      // Copy data into legacy long-term-support interfaces
      CHECK( prepareTriggerMenu( currentHlt,
                                 currentL1,
                                 currentHltps,
                                 currentL1ps,
                                 currentBg,
                                 ctpConfig,
                                 chainList,
                                 sequenceList,
                                 bgSet,
                                 msg() ) );
 
      REPORT_MESSAGE( MSG::INFO ) << "Loaded xAOD::TriggerMenuJson configuration:"
          << "  SMK = " << keys->smk()
          << ", L1PSK = " << keys->l1psk()
          << ", HLTPSK = " << keys->hltpsk()
          << ", BGSK = " << (bgKey ? std::to_string(bgKey->id()) : std::string("UNKNOWN")) << endmsg;
 
      REPORT_MESSAGE( MSG::DEBUG ) << "ctpConfig.menu().size() = " << ctpConfig.menu().size()
         << " chainList.size() = " << chainList.size()
         << " sequenceList.size() = " << sequenceList.size()
         << " bgSet.bunchGroups().size() = " << bgSet.bunchGroups().size() << endmsg;
 
      return StatusCode::SUCCESS;
 
   }

◆ readMetadata()

StatusCode TrigConf::xAODConfigSvc::readMetadata ( )

private

Function reading in a new metadata object from the input.

Definition at line 449 of file xAODConfigSvc.cxx.

                                          {
 
      // Only one thread at a time is allowed to process a new file being opened
      // and this should only happen when it is not being iterated over
      // as part of the BeginEvent incident.
      std::unique_lock lockUnique(m_sharedMutex);
 
      m_triggerMenuContainerAvailable = true;
      m_menuJSONContainerAvailable = true;
 
      // Read the R2 metadata object...
      const xAOD::TriggerMenuContainer* input_tmc = nullptr;
      if( !m_metaStore->contains<xAOD::TriggerMenuContainer>(m_metaName)
          or m_metaStore->retrieve( input_tmc, m_metaName ).isFailure() )
      {
         m_triggerMenuContainerAvailable = false;
      }
 
      // Read the R3 metadata object...
      const xAOD::TriggerMenuJsonContainer* input_hlt = nullptr;
      const xAOD::TriggerMenuJsonContainer* input_hltmonitoring = nullptr;
      const xAOD::TriggerMenuJsonContainer* input_l1 = nullptr;
      const xAOD::TriggerMenuJsonContainer* input_hltps = nullptr;
      const xAOD::TriggerMenuJsonContainer* input_l1ps = nullptr;
      const xAOD::TriggerMenuJsonContainer* input_bg = nullptr;
      if( !m_metaStore->contains<xAOD::TriggerMenuJsonContainer>(m_metaNameJSON_hlt)
          or m_metaStore->retrieve( input_hlt, m_metaNameJSON_hlt ).isFailure() )
      {
         m_menuJSONContainerAvailable = false;
      }
      if( !m_metaStore->contains<xAOD::TriggerMenuJsonContainer>(m_metaNameJSON_hltmonitoring)
          or m_metaStore->retrieve( input_hltmonitoring, m_metaNameJSON_hltmonitoring ).isFailure() )
      {
         // m_menuJSONContainerAvailable = false;
         // Currently planning on only storing these data in MC. Hence this has to be an optional input.
      }
      if( !m_metaStore->contains<xAOD::TriggerMenuJsonContainer>(m_metaNameJSON_l1)
          or m_metaStore->retrieve( input_l1, m_metaNameJSON_l1 ).isFailure() )
      {
         m_menuJSONContainerAvailable = false;
      }
      if( !m_metaStore->contains<xAOD::TriggerMenuJsonContainer>(m_metaNameJSON_hltps)
          or m_metaStore->retrieve( input_hltps, m_metaNameJSON_hltps ).isFailure() )
      {
         m_menuJSONContainerAvailable = false;
      }
      if( !m_metaStore->contains<xAOD::TriggerMenuJsonContainer>(m_metaNameJSON_l1ps)
          or m_metaStore->retrieve( input_l1ps, m_metaNameJSON_l1ps ).isFailure() )
      {
         m_menuJSONContainerAvailable = false;
      }
      if( !m_metaStore->contains<xAOD::TriggerMenuJsonContainer>(m_metaNameJSON_bg)
          or m_metaStore->retrieve( input_bg, m_metaNameJSON_bg ).isFailure() )
      {
         // m_menuJSONContainerAvailable = false;
         // This was not written up to the end of 2021, we have to make it optional for at least a while
      }
 
      if (!m_triggerMenuContainerAvailable && !m_menuJSONContainerAvailable) {
         // Update the internal flag:
         m_isInFailure = true;
         // Decide what to do:
         if( m_stopOnFailure ) {
            REPORT_MESSAGE( MSG::FATAL ) << "Couldn't retrieve xAOD::TriggerMenuContainer or xAOD::TriggerMenuJsonContainer(s)" << endmsg;
            return StatusCode::FAILURE;
         } else {
            REPORT_MESSAGE( MSG::WARNING ) << "Couldn't retrieve xAOD::TriggerMenuContainer or xAOD::TriggerMenuJsonContainer(s)" << endmsg;
            return StatusCode::SUCCESS;
         }
      }
 
      // From file #2 and onward, check for mixed-messages from the input files.
      // Note from the check just above, we know that we have at least one type of data available on this input file
      //
      // We do this as we currently have just two "available" flags, for the two data formats. Not two per slot
      if (m_tmc->size() > 0 && !m_triggerMenuContainerAvailable && m_menuJSONContainerAvailable) {
         m_isInFailure = true;
         m_triggerMenuContainerAvailable = false;
         m_menuJSONContainerAvailable = false;
         if( m_stopOnFailure ) {
            REPORT_MESSAGE( MSG::FATAL )
               << "In this input file we found xAOD::TriggerMenuJsonContainer(s), but no xAOD::TriggerMenuContainer. "
               << "This is inconsistent with previous input files." << endmsg;
               return StatusCode::FAILURE;
         } else {
            REPORT_MESSAGE( MSG::WARNING )
               << "In this input file we found xAOD::TriggerMenuJsonContainer(s), but no xAOD::TriggerMenuContainer. "
               << "This is inconsistent with previous input files." << endmsg;
            return StatusCode::SUCCESS;
         }
      }
      if (m_hltJson->size() > 0 && !m_menuJSONContainerAvailable && m_triggerMenuContainerAvailable) {
         m_isInFailure = true;
         m_triggerMenuContainerAvailable = false;
         m_menuJSONContainerAvailable = false;
         if( m_stopOnFailure ) {
            REPORT_MESSAGE( MSG::FATAL )
               << "In this input file we found xAOD::TriggerMenuContainer, but no xAOD::TriggerMenuJsonContainer. "
               << "This is inconsistent with previous input files." << endmsg;
               return StatusCode::FAILURE;
         } else {
            REPORT_MESSAGE( MSG::WARNING )
               << "In this input file we found xAOD::TriggerMenuContainer, but no xAOD::TriggerMenuJsonContainer. "
               << "This is inconsistent with previous input files." << endmsg;
            return StatusCode::SUCCESS;
         }
      }
 
      // Let the user know what happened:
      REPORT_MESSAGE( MSG::DEBUG ) << "Loaded trigger configuration metadata container(s)"  << endmsg;
 
      // If available, give preference to the R3 format
      if (m_menuJSONContainerAvailable) {
 
         copyMetadataToPersonalStore(input_hlt, m_hltJson.get());
         if (input_hltmonitoring) {
            copyMetadataToPersonalStore(input_hltmonitoring, m_hltmonitoringJson.get());
         }
         copyMetadataToPersonalStore(input_l1, m_l1Json.get());
         copyMetadataToPersonalStore(input_hltps, m_hltpsJson.get());
         copyMetadataToPersonalStore(input_l1ps, m_l1psJson.get());
         if (input_bg) {
            copyMetadataToPersonalStore(input_bg, m_bgJson.get());
         }
 
         return StatusCode::SUCCESS;
 
      } else if (m_triggerMenuContainerAvailable) { // Otherwise load the Run 2 format
 
         // A little sanity check:
         if( ! input_tmc->size() ) {
            REPORT_MESSAGE( MSG::WARNING ) << "No trigger configurations are available on the input" << endmsg;
            return StatusCode::SUCCESS;
         }
 
         // Copy in new menus
         for ( const xAOD::TriggerMenu* inputMenu : *input_tmc ) {
            bool alreadyHave = false;
            for( const xAOD::TriggerMenu* existingMenu : *m_tmc ) {
               if (xAODKeysMatch(inputMenu, existingMenu)) {
                  alreadyHave = true;
                  break;
               }
            }
            if (alreadyHave) {
               continue;
            }
            // Copy this menu into the service's internal cache of all menus
            xAOD::TriggerMenu* newMenu = new xAOD::TriggerMenu();
            m_tmc->push_back( newMenu ); // Note: 'newMenu' is now memory managed by m_tmc
            *newMenu = *inputMenu;
            REPORT_MESSAGE( MSG::DEBUG ) << "Imported new configuration: SMK = " << newMenu->smk()
               << ", L1PSK = " << newMenu->l1psk()
               << ", HLTPSK = " << newMenu->hltpsk() << endmsg;
         }
 
         return StatusCode::SUCCESS;
 
      } // m_menuJSONContainerAvailable or m_triggerMenuContainerAvailable
 
      //Should never get here (due to check above)
      ATH_MSG_ERROR( "Both m_menuJSONContainerAvailable and m_triggerMenuContainerAvailable are false" );
      return StatusCode::FAILURE;
   }

◆ sequences()

const HLTSequenceList & TrigConf::xAODConfigSvc::sequences ( ) const

overridevirtual

Get the HLT sequences.

Definition at line 158 of file xAODConfigSvc.cxx.

                                                         {
 
      // Long-term-support interface (including Run 2 AODs)
      if( m_isInFailure ) {
         REPORT_MESSAGE( MSG::FATAL )
            << "Trigger menu not loaded";
         throw GaudiException( "Service not initialised correctly",
                               "TrigConf::xAODConfigSvc::chains",
                               StatusCode::FAILURE );
      }
 
      // Return the slot-specific object:
      return *(m_sequenceList.get());
   }

◆ thresholdConfig()

virtual const ThresholdConfig * TrigConf::xAODConfigSvc::thresholdConfig ( ) const

inlineoverridevirtual

Get the LVL1 threshold configuruation (not available from xAOD).

Definition at line 93 of file xAODConfigSvc.h.

                                                                      {
         return 0;
      }

Member Data Documentation

◆ m_bgJson

std::unique_ptr<xAOD::TriggerMenuJsonContainer> TrigConf::xAODConfigSvc::m_bgJson

private

Definition at line 280 of file xAODConfigSvc.h.

◆ m_bgJsonAux

std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> TrigConf::xAODConfigSvc::m_bgJsonAux

private

Definition at line 279 of file xAODConfigSvc.h.

◆ m_bgSet

SG::SlotSpecificObj<BunchGroupSet> TrigConf::xAODConfigSvc::m_bgSet

private

The "translated" bunch group set object.

Definition at line 313 of file xAODConfigSvc.h.

◆ m_chainList

SG::SlotSpecificObj<HLTChainList> TrigConf::xAODConfigSvc::m_chainList

private

The "translated" HLT configuration object.

Definition at line 309 of file xAODConfigSvc.h.

◆ m_ctpConfig

SG::SlotSpecificObj<CTPConfig> TrigConf::xAODConfigSvc::m_ctpConfig

private

Definition at line 307 of file xAODConfigSvc.h.

◆ m_currentBg

SG::SlotSpecificObj<L1BunchGroupSet> TrigConf::xAODConfigSvc::m_currentBg

private

Definition at line 296 of file xAODConfigSvc.h.

◆ m_currentBgJson

SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> TrigConf::xAODConfigSvc::m_currentBgJson

private

Definition at line 288 of file xAODConfigSvc.h.

◆ m_currentHlt

SG::SlotSpecificObj<HLTMenu> TrigConf::xAODConfigSvc::m_currentHlt

private

Definition at line 291 of file xAODConfigSvc.h.

◆ m_currentHltJson

SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> TrigConf::xAODConfigSvc::m_currentHltJson

private

Definition at line 283 of file xAODConfigSvc.h.

◆ m_currentHltmonitoring

SG::SlotSpecificObj<HLTMonitoring> TrigConf::xAODConfigSvc::m_currentHltmonitoring

private

Definition at line 292 of file xAODConfigSvc.h.

◆ m_currentHltmonitoringJson

SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> TrigConf::xAODConfigSvc::m_currentHltmonitoringJson

private

Definition at line 284 of file xAODConfigSvc.h.

◆ m_currentHltps

SG::SlotSpecificObj<HLTPrescalesSet> TrigConf::xAODConfigSvc::m_currentHltps

private

Definition at line 294 of file xAODConfigSvc.h.

◆ m_currentHltpsJson

SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> TrigConf::xAODConfigSvc::m_currentHltpsJson

private

Definition at line 286 of file xAODConfigSvc.h.

◆ m_currentL1

SG::SlotSpecificObj<L1Menu> TrigConf::xAODConfigSvc::m_currentL1

private

Definition at line 293 of file xAODConfigSvc.h.

◆ m_currentL1Json

SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> TrigConf::xAODConfigSvc::m_currentL1Json

private

Definition at line 285 of file xAODConfigSvc.h.

◆ m_currentL1ps

SG::SlotSpecificObj<L1PrescalesSet> TrigConf::xAODConfigSvc::m_currentL1ps

private

Definition at line 295 of file xAODConfigSvc.h.

◆ m_currentL1psJson

SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> TrigConf::xAODConfigSvc::m_currentL1psJson

private

Definition at line 287 of file xAODConfigSvc.h.

◆ m_eventBGKey

SG::ReadHandleKey<xAOD::BunchConfKey> TrigConf::xAODConfigSvc::m_eventBGKey

private

Initial value:

{this, "BGKeysObjectName", "BunchConfKey",

"Key for the event-level bunchgroup configuration identifier object. Only written from late 2021, optional input."}

Definition at line 200 of file xAODConfigSvc.h.

200 {this, "BGKeysObjectName", "BunchConfKey",

201 "Key for the event-level bunchgroup configuration identifier object. Only written from late 2021, optional input."};

◆ m_eventKey

SG::ReadHandleKey<xAOD::TrigConfKeys> TrigConf::xAODConfigSvc::m_eventKey

private

Initial value:

{this, "EventObjectName", "TrigConfKeys",

"Key for the event-level configuration identifier object"}

Definition at line 197 of file xAODConfigSvc.h.

197 {this, "EventObjectName", "TrigConfKeys",

198 "Key for the event-level configuration identifier object"};

◆ m_hltJson

std::unique_ptr<xAOD::TriggerMenuJsonContainer> TrigConf::xAODConfigSvc::m_hltJson

private

Definition at line 270 of file xAODConfigSvc.h.

◆ m_hltJsonAux

std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> TrigConf::xAODConfigSvc::m_hltJsonAux

private

Definition at line 269 of file xAODConfigSvc.h.

◆ m_hltMenuKey

SG::ReadHandleKey<HLTMenu> TrigConf::xAODConfigSvc::m_hltMenuKey

private

Initial value:

{this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu",

"HLT Menu Key, for when UseInFileMetadata=False. From the DetectorStore."}

Definition at line 233 of file xAODConfigSvc.h.

233 {this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu",

234 "HLT Menu Key, for when UseInFileMetadata=False. From the DetectorStore."};

◆ m_hltmonitoringJson

std::unique_ptr<xAOD::TriggerMenuJsonContainer> TrigConf::xAODConfigSvc::m_hltmonitoringJson

private

Definition at line 272 of file xAODConfigSvc.h.

◆ m_hltmonitoringJsonAux

std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> TrigConf::xAODConfigSvc::m_hltmonitoringJsonAux

private

Definition at line 271 of file xAODConfigSvc.h.

◆ m_HLTPrescaleSetKey

SG::ReadCondHandleKey<TrigConf::HLTPrescalesSet> TrigConf::xAODConfigSvc::m_HLTPrescaleSetKey

private

Initial value:

{this, "HLTPrescales", "HLTPrescales",

"HLT prescales set condition handle, for when UseInFileMetadata=False"}

Definition at line 239 of file xAODConfigSvc.h.

239 {this, "HLTPrescales", "HLTPrescales",

240 "HLT prescales set condition handle, for when UseInFileMetadata=False"};

◆ m_hltpsJson

std::unique_ptr<xAOD::TriggerMenuJsonContainer> TrigConf::xAODConfigSvc::m_hltpsJson

private

Definition at line 276 of file xAODConfigSvc.h.

◆ m_hltpsJsonAux

std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> TrigConf::xAODConfigSvc::m_hltpsJsonAux

private

Definition at line 275 of file xAODConfigSvc.h.

◆ m_isInFailure

bool TrigConf::xAODConfigSvc::m_isInFailure {false}

private

Internal state of the service.

Definition at line 254 of file xAODConfigSvc.h.

254{false};

◆ m_L1BunchGroupSetKey

SG::ReadCondHandleKey<TrigConf::L1BunchGroupSet> TrigConf::xAODConfigSvc::m_L1BunchGroupSetKey {this, "L1BunchGroup", "L1BunchGroup", "L1 Bunch groups"}

private

Definition at line 245 of file xAODConfigSvc.h.

245{this, "L1BunchGroup", "L1BunchGroup", "L1 Bunch groups"};

◆ m_l1Json

std::unique_ptr<xAOD::TriggerMenuJsonContainer> TrigConf::xAODConfigSvc::m_l1Json

private

Definition at line 274 of file xAODConfigSvc.h.

◆ m_l1JsonAux

std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> TrigConf::xAODConfigSvc::m_l1JsonAux

private

Definition at line 273 of file xAODConfigSvc.h.

◆ m_l1MenuKey

SG::ReadHandleKey<L1Menu> TrigConf::xAODConfigSvc::m_l1MenuKey

private

Initial value:

{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu",

"L1 Menu Key, for when UseInFileMetadata=False. From the DetectorStore"}

Definition at line 236 of file xAODConfigSvc.h.

236 {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu",

237 "L1 Menu Key, for when UseInFileMetadata=False. From the DetectorStore"};

◆ m_L1PrescaleSetKey

SG::ReadCondHandleKey<TrigConf::L1PrescalesSet> TrigConf::xAODConfigSvc::m_L1PrescaleSetKey

private

Initial value:

{this, "L1Prescales", "L1Prescales",

"L1 prescales set condition handle, for when UseInFileMetadata=False"}

Definition at line 242 of file xAODConfigSvc.h.

242 {this, "L1Prescales", "L1Prescales",

243 "L1 prescales set condition handle, for when UseInFileMetadata=False"};

◆ m_l1psJson

std::unique_ptr<xAOD::TriggerMenuJsonContainer> TrigConf::xAODConfigSvc::m_l1psJson

private

Definition at line 278 of file xAODConfigSvc.h.

◆ m_l1psJsonAux

std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> TrigConf::xAODConfigSvc::m_l1psJsonAux

private

Definition at line 277 of file xAODConfigSvc.h.

◆ m_menu

SG::SlotSpecificObj<MenuPtrWrapper> TrigConf::xAODConfigSvc::m_menu

private

Definition at line 263 of file xAODConfigSvc.h.

◆ m_menuJSONContainerAvailable

bool TrigConf::xAODConfigSvc::m_menuJSONContainerAvailable {false}

private

Is decoded R3 format data available?

Definition at line 322 of file xAODConfigSvc.h.

322{false};

◆ m_metaName

Gaudi::Property<std::string> TrigConf::xAODConfigSvc::m_metaName

private

Initial value:

{this, "MetaObjectName", "TriggerMenu",

"Key for the trigger configuration metadata object"}

Definition at line 205 of file xAODConfigSvc.h.

205 {this, "MetaObjectName", "TriggerMenu",

206 "Key for the trigger configuration metadata object"};

◆ m_metaNameJSON_bg

Gaudi::Property< std::string > TrigConf::xAODConfigSvc::m_metaNameJSON_bg

private

Initial value:

{this, "JSONMetaObjectNameBunchgroup", "TriggerMenuJson_BG",

"StoreGate key for the xAOD::TriggerMenuJson BunchGroup configuration object"}

Definition at line 226 of file xAODConfigSvc.h.

226 {this, "JSONMetaObjectNameBunchgroup", "TriggerMenuJson_BG",

227 "StoreGate key for the xAOD::TriggerMenuJson BunchGroup configuration object"};

◆ m_metaNameJSON_hlt

Gaudi::Property< std::string > TrigConf::xAODConfigSvc::m_metaNameJSON_hlt

private

Initial value:

{this, "JSONMetaObjectNameHLT", "TriggerMenuJson_HLT",

"StoreGate key for the xAOD::TriggerMenuJson HLT configuration object"}

Definition at line 211 of file xAODConfigSvc.h.

211 {this, "JSONMetaObjectNameHLT", "TriggerMenuJson_HLT",

212 "StoreGate key for the xAOD::TriggerMenuJson HLT configuration object"};

◆ m_metaNameJSON_hltmonitoring

Gaudi::Property< std::string > TrigConf::xAODConfigSvc::m_metaNameJSON_hltmonitoring

private

Initial value:

{this, "JSONMetaObjectNameHLTMonitoring", "TriggerMenuJson_HLTMonitoring",

"StoreGate key for the xAOD::TriggerMenuJson HLT monitoring configuration object"}

Definition at line 214 of file xAODConfigSvc.h.

214 {this, "JSONMetaObjectNameHLTMonitoring", "TriggerMenuJson_HLTMonitoring",

215 "StoreGate key for the xAOD::TriggerMenuJson HLT monitoring configuration object"};

◆ m_metaNameJSON_hltps

Gaudi::Property< std::string > TrigConf::xAODConfigSvc::m_metaNameJSON_hltps

private

Initial value:

{this, "JSONMetaObjectNameHLTPS", "TriggerMenuJson_HLTPS",

"StoreGate key for the xAOD::TriggerMenuJson HLT prescales configuration object"}

Definition at line 220 of file xAODConfigSvc.h.

220 {this, "JSONMetaObjectNameHLTPS", "TriggerMenuJson_HLTPS",

221 "StoreGate key for the xAOD::TriggerMenuJson HLT prescales configuration object"};

◆ m_metaNameJSON_l1

Gaudi::Property< std::string > TrigConf::xAODConfigSvc::m_metaNameJSON_l1

private

Initial value:

{this, "JSONMetaObjectNameL1", "TriggerMenuJson_L1",

"StoreGate key for the xAOD::TriggerMenuJson L1 configuration object"}

Definition at line 217 of file xAODConfigSvc.h.

217 {this, "JSONMetaObjectNameL1", "TriggerMenuJson_L1",

218 "StoreGate key for the xAOD::TriggerMenuJson L1 configuration object"};

◆ m_metaNameJSON_l1ps

Gaudi::Property< std::string > TrigConf::xAODConfigSvc::m_metaNameJSON_l1ps

private

Initial value:

{this, "JSONMetaObjectNameL1PS", "TriggerMenuJson_L1PS",

"StoreGate key for the xAOD::TriggerMenuJson L1 prescales configuration object"}

Definition at line 223 of file xAODConfigSvc.h.

223 {this, "JSONMetaObjectNameL1PS", "TriggerMenuJson_L1PS",

224 "StoreGate key for the xAOD::TriggerMenuJson L1 prescales configuration object"};

◆ m_metaStore

ServiceHandle< StoreGateSvc > TrigConf::xAODConfigSvc::m_metaStore {this, "MetaDataStore", "StoreGateSvc/InputMetaDataStore"}

private

Connection to the metadata store.

Definition at line 317 of file xAODConfigSvc.h.

317{this, "MetaDataStore", "StoreGateSvc/InputMetaDataStore"};

◆ m_sequenceList

SG::SlotSpecificObj<HLTSequenceList> TrigConf::xAODConfigSvc::m_sequenceList

private

The "translated" HLT configuration object.

Definition at line 311 of file xAODConfigSvc.h.

◆ m_sharedMutex

std::shared_mutex TrigConf::xAODConfigSvc::m_sharedMutex

private

The mutex used to to restrict access to m_tmc when it is being written to.

Definition at line 300 of file xAODConfigSvc.h.

◆ m_stopOnFailure

Gaudi::Property<bool> TrigConf::xAODConfigSvc::m_stopOnFailure {this, "StopOnFailure", true, "Flag for stopping the job in case of a failure"}

private

Definition at line 252 of file xAODConfigSvc.h.

252{this, "StopOnFailure", true, "Flag for stopping the job in case of a failure"};

◆ m_tmc

std::unique_ptr<xAOD::TriggerMenuContainer> TrigConf::xAODConfigSvc::m_tmc

private

Definition at line 260 of file xAODConfigSvc.h.

◆ m_tmcAux

std::unique_ptr<xAOD::TriggerMenuAuxContainer> TrigConf::xAODConfigSvc::m_tmcAux

private

Definition at line 259 of file xAODConfigSvc.h.

◆ m_triggerMenuContainerAvailable

bool TrigConf::xAODConfigSvc::m_triggerMenuContainerAvailable {false}

private

Is decoded R2 format data available?

Definition at line 320 of file xAODConfigSvc.h.

320{false};

◆ m_useInFileMetadata

Gaudi::Property<bool> TrigConf::xAODConfigSvc::m_useInFileMetadata

private

Initial value:

{this, "UseInFileMetadata", true, "Flag for reading all configuration from the input POOL file(s). "
        "This mode should be used everywhere except for: RAWtoALL from bytestream. "
        "If set to false, only the R3 configuration is supported."}

Definition at line 248 of file xAODConfigSvc.h.

                                             {this, "UseInFileMetadata", true, "Flag for reading all configuration from the input POOL file(s). "
        "This mode should be used everywhere except for: RAWtoALL from bytestream. "
        "If set to false, only the R3 configuration is supported."};

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ xAODConfigSvc()

Member Function Documentation

◆ bunchGroupSet()

◆ bunchGroupSetKey()

◆ chains()

◆ configurationSource()

◆ copyMetadataToPersonalStore()

◆ ctpConfig()

◆ finalize()

◆ handle()

◆ hltMenu()

◆ hltMonitoring()

◆ hltPrescaleKey()

◆ hltPrescalesSet()

◆ initialize()

◆ l1BunchGroupSet()

◆ l1Menu()

◆ l1PrescalesSet()

◆ loadPtree()

◆ lvl1PrescaleKey()

◆ masterKey()

◆ muctpiConfig()

◆ prepareEvent()

◆ prepareEventRun3Athena()

◆ prepareEventxAODTriggerMenu()

◆ prepareEventxAODTriggerMenuJson()

◆ readMetadata()

◆ sequences()

◆ thresholdConfig()

Member Data Documentation

◆ m_bgJson

◆ m_bgJsonAux

◆ m_bgSet

◆ m_chainList

◆ m_ctpConfig

◆ m_currentBg

◆ m_currentBgJson

◆ m_currentHlt

◆ m_currentHltJson

◆ m_currentHltmonitoring

◆ m_currentHltmonitoringJson

◆ m_currentHltps

◆ m_currentHltpsJson

◆ m_currentL1

◆ m_currentL1Json

◆ m_currentL1ps

◆ m_currentL1psJson

◆ m_eventBGKey

◆ m_eventKey

◆ m_hltJson

◆ m_hltJsonAux

◆ m_hltMenuKey

◆ m_hltmonitoringJson

◆ m_hltmonitoringJsonAux

◆ m_HLTPrescaleSetKey

◆ m_hltpsJson

◆ m_hltpsJsonAux

◆ m_isInFailure

◆ m_L1BunchGroupSetKey

◆ m_l1Json

◆ m_l1JsonAux

◆ m_l1MenuKey

◆ m_L1PrescaleSetKey

◆ m_l1psJson

◆ m_l1psJsonAux

◆ m_menu

◆ m_menuJSONContainerAvailable

◆ m_metaName

◆ m_metaNameJSON_bg

◆ m_metaNameJSON_hlt

◆ m_metaNameJSON_hltmonitoring

◆ m_metaNameJSON_hltps

◆ m_metaNameJSON_l1

◆ m_metaNameJSON_l1ps

◆ m_metaStore