TrigConf::xAODMenuWriter Class Reference

Algorithm used to write the light-weight xAOD configuration in the Run3 JSON format. More...

#include <xAODMenuWriter.h>

Inheritance diagram for TrigConf::xAODMenuWriter:

Collaboration diagram for TrigConf::xAODMenuWriter:

Public Member Functions
	xAODMenuWriter (const std::string &name, ISvcLocator *svcLoc)
	Regular Algorithm constructor. More...
virtual	~xAODMenuWriter () override=default
virtual StatusCode	initialize () override
	Function initialising the algorithm. More...
virtual StatusCode	execute (const EventContext &ctx) const override
	Function executing the algorithm. More...
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef std::pair< uint32_t, std::pair< uint32_t, uint32_t > >	TrigKey_t
	Trigger configuration key type (used just internally) More...
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey
SG::ReadHandleKey< TrigConf::HLTMonitoring >	m_HLTMonitoringKey
SG::ReadHandleKey< TrigConf::L1Menu >	m_L1MenuKey
SG::ReadCondHandleKey< TrigConf::HLTPrescalesSet >	m_HLTPrescaleSetInputKey
SG::ReadCondHandleKey< TrigConf::L1PrescalesSet >	m_L1PrescaleSetInputKey
SG::ReadCondHandleKey< TrigConf::L1BunchGroupSet >	m_bgInputKey
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
ServiceHandle< StoreGateSvc >	m_metaStore
ToolHandle< IKeyWriterTool >	m_keyWriterTool
xAOD::TriggerMenuJsonContainer *m_menuJSON_hlt	ATLAS_THREAD_SAFE {}
xAOD::TriggerMenuJsonContainer *m_menuJSON_hltmonitoring	ATLAS_THREAD_SAFE {}
xAOD::TriggerMenuJsonContainer *m_menuJSON_l1	ATLAS_THREAD_SAFE {}
xAOD::TriggerMenuJsonContainer *m_menuJSON_hltps	ATLAS_THREAD_SAFE {}
xAOD::TriggerMenuJsonContainer *m_menuJSON_l1ps	ATLAS_THREAD_SAFE {}
xAOD::TriggerMenuJsonContainer *m_menuJSON_bg	ATLAS_THREAD_SAFE {}
std::set< uint32_t > m_converted_smk	ATLAS_THREAD_SAFE
	Trigger configuration keys that are already converted. More...
std::set< uint32_t > m_converted_hltpsk	ATLAS_THREAD_SAFE
std::set< uint32_t > m_converted_l1psk	ATLAS_THREAD_SAFE
std::set< uint32_t > m_converted_bg	ATLAS_THREAD_SAFE
std::mutex	m_mutex
	The mutex to prevent us from writing more than one configuration at a time. More...
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Algorithm used to write the light-weight xAOD configuration in the Run3 JSON format.

   This algorithm needs to be scheduled in jobs that write xAOD
   files in Athena in order to write the trigger configuration
   into the output file.

   It puts a tiny amount of information into each event that is
   later used to find the correct configuration of the events,
   and also assembles the configuration metadata that is written
   into the metadata TTree of the xAOD file at the end of the job.

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

Tim Martin Tim.M.nosp@m.arti.nosp@m.n@cer.nosp@m.n.ch

Definition at line 54 of file xAODMenuWriter.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TrigKey_t

typedef std::pair< uint32_t, std::pair< uint32_t, uint32_t > > TrigConf::xAODMenuWriter::TrigKey_t

private

Trigger configuration key type (used just internally)

Definition at line 113 of file xAODMenuWriter.h.

Constructor & Destructor Documentation

xAODMenuWriter()

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

Regular Algorithm constructor.

Definition at line 38 of file xAODMenuWriter.cxx.

       : AthReentrantAlgorithm(name, svcLoc),
         m_metaStore("MetaDataStore", name)
   {
   }

~xAODMenuWriter()

virtual TrigConf::xAODMenuWriter::~xAODMenuWriter ( )

overridevirtualdefault

Member Function Documentation

cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TrigConf::xAODMenuWriter::execute ( const EventContext &  ctx ) const

overridevirtual

Function executing the algorithm.

Definition at line 139 of file xAODMenuWriter.cxx.

   {
 
      // Create the keys in the "internal format":
      TrigKey_t ckeys;
 
      // Write to SG via writer tool.
      // Get keys back via pass-by-reference
      ATH_CHECK(m_keyWriterTool->writeKeys(ctx, /*SMK*/ ckeys.first, /*L1PSK*/ ckeys.second.first, /*HLTPSK*/ ckeys.second.second));
 
      uint32_t bunchgroupKey = 0;
      ATH_CHECK(m_keyWriterTool->writeBunchgroupKey(ctx, bunchgroupKey));
 
      // The following code must only run on one event at a time
      std::lock_guard<std::mutex> lock(m_mutex);
 
      if (!m_converted_smk.insert(ckeys.first).second) {
         ATH_MSG_VERBOSE("Already converted SMK: " << ckeys.first);
      } else {
         ATH_MSG_DEBUG("Filling HLT Menu information for SMK:" << ckeys.first);
         SG::ReadHandle<TrigConf::HLTMenu> hltMenuHandle(m_HLTMenuKey, ctx);
         ATH_CHECK(hltMenuHandle.isValid());
         std::stringstream hltTriggerMenuJson;
         hltMenuHandle->printRaw(hltTriggerMenuJson);
         xAOD::TriggerMenuJson *hlt = new xAOD::TriggerMenuJson();
         m_menuJSON_hlt->push_back(hlt); // Now owned by MetaDataStore
         hlt->setKey(ckeys.first);
         hlt->setName(hltMenuHandle->name());
         hlt->setPayload(hltTriggerMenuJson.str());
         ATH_MSG_DEBUG("Filling HLT Monitoring information for SMK:" << ckeys.first);
         SG::ReadHandle<TrigConf::HLTMonitoring> hltMonitoringHandle(m_HLTMonitoringKey, ctx);
         if (hltMonitoringHandle.isValid()) {
            std::stringstream hltMonitoringJson;
            hltMonitoringHandle->printRaw(hltMonitoringJson);
            xAOD::TriggerMenuJson *hltmonitoring = new xAOD::TriggerMenuJson();
            m_menuJSON_hltmonitoring->push_back(hltmonitoring); // Now owned by MetaDataStore
            hltmonitoring->setKey(ckeys.first);
            hltmonitoring->setName(hltMonitoringHandle->name());
            hltmonitoring->setPayload(hltMonitoringJson.str());
         } else {
            ATH_MSG_DEBUG("No HLT Monitoring JSON available - skipping.");
         }
         ATH_MSG_DEBUG("Filling L1 information for SMK:" << ckeys.first);
         SG::ReadHandle<TrigConf::L1Menu> l1MenuHandle = SG::makeHandle(m_L1MenuKey, ctx);
         ATH_CHECK(l1MenuHandle.isValid());
         std::stringstream l1TriggerMenuJson;
         l1MenuHandle->printRaw(l1TriggerMenuJson);
         xAOD::TriggerMenuJson *l1 = new xAOD::TriggerMenuJson();
         m_menuJSON_l1->push_back(l1); // Now owned by MetaDataStore
         l1->setKey(ckeys.first);
         l1->setName(l1MenuHandle->name());
         l1->setPayload(l1TriggerMenuJson.str());
      }
 
      if (!m_converted_hltpsk.insert(ckeys.second.second).second) {
         ATH_MSG_VERBOSE("Already converted HLTPSK: " << ckeys.second.second);
      } else {
         ATH_MSG_DEBUG("Filling prescale information for HLTPSK:" << ckeys.second.second);
         SG::ReadCondHandle<TrigConf::HLTPrescalesSet> hltPSHandle(m_HLTPrescaleSetInputKey, ctx);
         ATH_CHECK(hltPSHandle.isValid());
         std::stringstream hltPSJSON;
         hltPSHandle->printRaw(hltPSJSON);
         xAOD::TriggerMenuJson *hltps = new xAOD::TriggerMenuJson();
         m_menuJSON_hltps->push_back(hltps); // Now owned by MetaDataStore
         hltps->setKey(ckeys.second.second);
         hltps->setName(hltPSHandle->name());
         hltps->setPayload(hltPSJSON.str());
      }
 
      if (!m_converted_l1psk.insert(ckeys.second.first).second) {
         ATH_MSG_VERBOSE("Already converted LVL1PSK: " << ckeys.second.first);
      } else {
         ATH_MSG_DEBUG("Filling prescale information for LVL1PSK:" << ckeys.second.first);
         SG::ReadCondHandle<TrigConf::L1PrescalesSet> l1PSHandle(m_L1PrescaleSetInputKey, ctx);
         ATH_CHECK(l1PSHandle.isValid());
         std::stringstream l1PSJSON;
         l1PSHandle->printRaw(l1PSJSON);
         xAOD::TriggerMenuJson *l1ps = new xAOD::TriggerMenuJson();
         m_menuJSON_l1ps->push_back(l1ps); // Now owned by MetaDataStore
         l1ps->setKey(ckeys.second.first);
         l1ps->setName(l1PSHandle->name());
         l1ps->setPayload(l1PSJSON.str());
      }
 
      if (!m_converted_bg.insert(bunchgroupKey).second) {
         ATH_MSG_VERBOSE("Already converted Bunchgroup Key: " << bunchgroupKey);
      } else {
         ATH_MSG_DEBUG("Filling prescale information for Bunchgroup Key:" << bunchgroupKey);
         SG::ReadCondHandle<TrigConf::L1BunchGroupSet> bunchgroupHandle(m_bgInputKey, ctx);
         ATH_CHECK(bunchgroupHandle.isValid());
         std::stringstream l1BunchgroupJSON;
         bunchgroupHandle->printRaw(l1BunchgroupJSON);
         xAOD::TriggerMenuJson *l1bg = new xAOD::TriggerMenuJson();
         m_menuJSON_bg->push_back(l1bg); // Now owned by MetaDataStore
         l1bg->setKey(bunchgroupKey);
         l1bg->setName(bunchgroupHandle->name());
         l1bg->setPayload(l1BunchgroupJSON.str());
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 79 of file AthReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

initialize()

StatusCode TrigConf::xAODMenuWriter::initialize ( )

overridevirtual

Function initialising the algorithm.

Definition at line 45 of file xAODMenuWriter.cxx.

   {
 
      // Greet the user:
      ATH_MSG_INFO("Initialising");
      ATH_MSG_VERBOSE("MetaDataStore = " << m_metaStore);
 
      // Retrieve the necessary service(s):
      ATH_CHECK(m_metaStore.retrieve());
 
      ATH_CHECK(m_keyWriterTool.retrieve());
 
      ATH_CHECK(m_HLTMenuKey.initialize());             // ReadHandleKey, but DetStore (so renounce)
      renounce(m_HLTMenuKey);
      ATH_CHECK(m_HLTMonitoringKey.initialize());       // ReadHandleKey, but DetStore (so renounce)
      renounce(m_HLTMonitoringKey);
      ATH_CHECK(m_HLTPrescaleSetInputKey.initialize()); // ReadCondHandleKey
 
      ATH_CHECK(m_L1MenuKey.initialize());             // ReadHandleKey, but DetStore (so renounce)
      renounce(m_L1MenuKey);
      ATH_CHECK(m_L1PrescaleSetInputKey.initialize()); // ReadCondHandleKey
 
      ATH_CHECK(m_bgInputKey.initialize()); // ReadCondHandleKey
 
      // HLT JSON object - contains HLT menus
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> aux_hlt = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> hlt = std::make_unique<xAOD::TriggerMenuJsonContainer>();
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_hlt = hlt.get(); // Keep a cached pointer from which we can add to the output metastore
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_hlt->setStore(aux_hlt.get());
 
      ATH_CHECK(m_metaStore->record(std::move(aux_hlt), m_metaNameJSON_hlt + "Aux."));
      ATH_CHECK(m_metaStore->record(std::move(hlt), m_metaNameJSON_hlt));
 
      // HLT Monitoring JSON object - contains Monitoring groups for HLT menus
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> aux_hltmonitoring = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> hltmonitoring = std::make_unique<xAOD::TriggerMenuJsonContainer>();
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_hltmonitoring = hltmonitoring.get(); // Keep a cached pointer from which we can add to the output metastore
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_hltmonitoring->setStore(aux_hltmonitoring.get());
 
      ATH_CHECK(m_metaStore->record(std::move(aux_hltmonitoring), m_metaNameJSON_hltmonitoring + "Aux."));
      ATH_CHECK(m_metaStore->record(std::move(hltmonitoring), m_metaNameJSON_hltmonitoring));
 
      // L1 JSON object - contains L1 menus
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> aux_l1 = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> l1 = std::make_unique<xAOD::TriggerMenuJsonContainer>();
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_l1 = l1.get(); // Keep a cached pointer from which we can add to the output metastore
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_l1->setStore(aux_l1.get());
 
      ATH_CHECK(m_metaStore->record(std::move(aux_l1), m_metaNameJSON_l1 + "Aux."));
      ATH_CHECK(m_metaStore->record(std::move(l1), m_metaNameJSON_l1));
 
      // HLT PS JSON object - contains prescales sets for HLT menus
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> aux_hltps = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> hltps = std::make_unique<xAOD::TriggerMenuJsonContainer>();
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_hltps = hltps.get(); // Keep a cached pointer from which we can add to the output metastore
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_hltps->setStore(aux_hltps.get());
 
      ATH_CHECK(m_metaStore->record(std::move(aux_hltps), m_metaNameJSON_hltps + "Aux."));
      ATH_CHECK(m_metaStore->record(std::move(hltps), m_metaNameJSON_hltps));
 
      // L1 PS JSON object - contains prescales sets for L1 menus
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> aux_l1ps = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> l1ps = std::make_unique<xAOD::TriggerMenuJsonContainer>();
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_l1ps = l1ps.get(); // Keep a cached pointer from which we can add to the output metastore
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_l1ps->setStore(aux_l1ps.get());
 
      ATH_CHECK(m_metaStore->record(std::move(aux_l1ps), m_metaNameJSON_l1ps + "Aux."));
      ATH_CHECK(m_metaStore->record(std::move(l1ps), m_metaNameJSON_l1ps));
 
      // Bunchgroup JSON object - contains bungchgroup configuration
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> aux_bg = std::make_unique<xAOD::TriggerMenuJsonAuxContainer>();
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> bg = std::make_unique<xAOD::TriggerMenuJsonContainer>();
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_bg = bg.get(); // Keep a cached pointer from which we can add to the output metastore
      // cppcheck-suppress danglingLifetime; false positive
      m_menuJSON_bg->setStore( aux_bg.get() );
 
      ATH_CHECK( m_metaStore->record(std::move(aux_bg), m_metaNameJSON_bg + "Aux." ) );
      ATH_CHECK( m_metaStore->record(std::move(bg), m_metaNameJSON_bg ) );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state, const EventContext &  ctx  ) const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

{
  return Gaudi::Algorithm::sysExecute (ctx);
}

sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

                                                {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/10]

xAOD::TriggerMenuJsonContainer* m_menuJSON_hlt TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 116 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [2/10]

xAOD::TriggerMenuJsonContainer* m_menuJSON_hltmonitoring TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 117 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [3/10]

xAOD::TriggerMenuJsonContainer* m_menuJSON_l1 TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 118 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [4/10]

xAOD::TriggerMenuJsonContainer* m_menuJSON_hltps TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 119 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [5/10]

xAOD::TriggerMenuJsonContainer* m_menuJSON_l1ps TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 120 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [6/10]

xAOD::TriggerMenuJsonContainer* m_menuJSON_bg TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 121 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [7/10]

std::set< uint32_t > m_converted_smk TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE

mutableprivate

Trigger configuration keys that are already converted.

Definition at line 124 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [8/10]

std::set< uint32_t > m_converted_hltpsk TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 125 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [9/10]

std::set< uint32_t > m_converted_l1psk TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 126 of file xAODMenuWriter.h.

ATLAS_THREAD_SAFE [10/10]

std::set< uint32_t > m_converted_bg TrigConf::xAODMenuWriter::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 127 of file xAODMenuWriter.h.

m_bgInputKey

SG::ReadCondHandleKey<TrigConf::L1BunchGroupSet> TrigConf::xAODMenuWriter::m_bgInputKey

private

Initial value:

{this, "L1BunchGroup", "L1BunchGroup", 
        "L1BunchGroupSet condition handl"}

Definition at line 85 of file xAODMenuWriter.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

m_HLTMenuKey

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

private

Initial value:

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

Definition at line 70 of file xAODMenuWriter.h.

m_HLTMonitoringKey

SG::ReadHandleKey<TrigConf::HLTMonitoring> TrigConf::xAODMenuWriter::m_HLTMonitoringKey

private

Initial value:

{this, "HLTMonitoringMenu", "DetectorStore+HLTMonitoringMenu",
        "HLT Monitoring key"}

Definition at line 73 of file xAODMenuWriter.h.

m_HLTPrescaleSetInputKey

SG::ReadCondHandleKey<TrigConf::HLTPrescalesSet> TrigConf::xAODMenuWriter::m_HLTPrescaleSetInputKey

private

Initial value:

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

Definition at line 79 of file xAODMenuWriter.h.

m_keyWriterTool

ToolHandle<IKeyWriterTool> TrigConf::xAODMenuWriter::m_keyWriterTool

private

Initial value:

{this, "KeyWriterTool", "KeyWriterTool/OfflineKeyWriterTool", 
          "Writes the keys which are configured when the trigger configuration is written to in-file metadata."}

Definition at line 109 of file xAODMenuWriter.h.

m_L1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> TrigConf::xAODMenuWriter::m_L1MenuKey

private

Initial value:

{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu",
        "L1 Menu key"}

Definition at line 76 of file xAODMenuWriter.h.

m_L1PrescaleSetInputKey

SG::ReadCondHandleKey<TrigConf::L1PrescalesSet> TrigConf::xAODMenuWriter::m_L1PrescaleSetInputKey

private

Initial value:

{this, "L1Prescales", "L1Prescales", 
        "L1 prescales set condition handle"}

Definition at line 82 of file xAODMenuWriter.h.

m_metaNameJSON_bg

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

private

Initial value:

{this, "JSONMetaObjectNameBunchgroup", "TriggerMenuJson_BG",
        "StoreGate key for the xAOD::TriggerMenuJson BunchGroup configuration object"}

Definition at line 103 of file xAODMenuWriter.h.

m_metaNameJSON_hlt

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

private

Initial value:

{this, "JSONMetaObjectNameHLT", "TriggerMenuJson_HLT",
        "StoreGate key for the xAOD::TriggerMenuJson HLT configuration object"}

Definition at line 88 of file xAODMenuWriter.h.

m_metaNameJSON_hltmonitoring

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

private

Initial value:

{this, "JSONMetaObjectNameHLTMonitoring", "TriggerMenuJson_HLTMonitoring",
        "StoreGate key for the xAOD::TriggerMenuJson HLT Monitoring configuration object"}

Definition at line 91 of file xAODMenuWriter.h.

m_metaNameJSON_hltps

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

private

Initial value:

{this, "JSONMetaObjectNameHLTPS", "TriggerMenuJson_HLTPS",
        "StoreGate key for the xAOD::TriggerMenuJson HLT prescales configuration object"}

Definition at line 97 of file xAODMenuWriter.h.

m_metaNameJSON_l1

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

private

Initial value:

{this, "JSONMetaObjectNameL1", "TriggerMenuJson_L1",
        "StoreGate key for the xAOD::TriggerMenuJson L1 configuration object"}

Definition at line 94 of file xAODMenuWriter.h.

m_metaNameJSON_l1ps

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

private

Initial value:

{this, "JSONMetaObjectNameL1PS", "TriggerMenuJson_L1PS",
        "StoreGate key for the xAOD::TriggerMenuJson L1 prescales configuration object"}

Definition at line 100 of file xAODMenuWriter.h.

m_metaStore

ServiceHandle< StoreGateSvc > TrigConf::xAODMenuWriter::m_metaStore

private

Initial value:

{this, "MetaDataStore", "MetaDataStore",
        "The MetaDataStore"}

Definition at line 106 of file xAODMenuWriter.h.

m_mutex

std::mutex TrigConf::xAODMenuWriter::m_mutex

mutableprivate

The mutex to prevent us from writing more than one configuration at a time.

Definition at line 130 of file xAODMenuWriter.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• xAODMenuWriter.h
• xAODMenuWriter.cxx