Algorithm used to write the RingSets configuration. More...

#include <xAODRingSetConfWriter.h>

Inheritance diagram for Ringer::xAODRingSetConfWriter:

Collaboration diagram for Ringer::xAODRingSetConfWriter:

Public Member Functions
	xAODRingSetConfWriter (const std::string &name, ::ISvcLocator *svcLoc)
	Regular Algorithm constructor.
StatusCode	initialize ()
	Method initialising the algorithm.
StatusCode	execute ()
	Method executing the algorithm.
StatusCode	finalize ()
	Method executing the algorithm.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

StatusCode	copyInputMetaStore ()
	Private methods:
template<class auxT, class T>
StatusCode	searchAndCopyCLID (const ClassID_traits< T > &classID)
	Auxiliary method called by copyInputMetaStore.
template<class auxT, class T>
StatusCode	copyKeyToStore (const std::string &key)
	Retrieve a key and returns a copy of it to outputmeta.
StatusCode	retrieveCaloRingsBuilders ()
	Retrieve CaloRingsBuilder tools.
StatusCode	allocateContainers ()
	Prepare containers to retrieve configurations.
StatusCode	fillConfigurations ()
	Fill the containers with each CaloRingsBuilder tool configuration.

Private Attributes
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

ServiceHandle< StoreGateSvc >	m_metaStore
	Private properties (python configurables):Connection to the (output)metadata store.
ServiceHandle< StoreGateSvc >	m_inputMetaStore
	Connection to the inputMetadata store.
ToolHandleArray< Ringer::ICaloRingsBuilder >	m_crBuilderTools
	Connection to the trigger configuration service.
std::vector< std::string >	m_rsMetaNames
	StoreGate keys for the RingSet configurations.

std::vector< xAOD::RingSetConfContainer * >	m_rsConfContVec
	Private properties (non python configurables):The CaloRings configuration container.

Detailed Description

Algorithm used to write the RingSets configuration.

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

   It assembles the RingSet configuration that is written into
   the metadata TTree of the xAOD file at the end of the job.

This algorithm is based on TrigConfxAOD from Attila Krasznahorkay.

Author: Werner Freund wsfre.nosp@m.und@.nosp@m.cern..nosp@m.ch

Revision: 713521

Date: 2015-12-09 09:53:41 +0100 (Wed, 09 Dec 2015)

Definition at line 47 of file xAODRingSetConfWriter.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ xAODRingSetConfWriter()

Ringer::xAODRingSetConfWriter::xAODRingSetConfWriter	(	const std::string &	name,
		::ISvcLocator *	svcLoc )

Regular Algorithm constructor.

Definition at line 26 of file xAODRingSetConfWriter.cxx.

                                                     : 
  ::AthAlgorithm( name, svcLoc ),
  m_metaStore( "StoreGateSvc/MetaDataStore", name ),
  m_inputMetaStore( "StoreGateSvc/InputMetaDataStore", name )
{
 
  declareProperty( "MetaDataStore", m_metaStore, 
      "The metadata Storage ServiceHandle. If empty, it will use "
      "MetaDataStore service with same name as this algorithm.");
 
  declareProperty( "CaloRingsBuilderTools", m_crBuilderTools ,
      "The CaloRingsBuilder tools handles array.");
 
  declareProperty( "RingSetConfContainerNames", m_rsMetaNames, 
      "The metadata RingSet Configuration container keys to write." );
 
}

Member Function Documentation

◆ allocateContainers()

StatusCode Ringer::xAODRingSetConfWriter::allocateContainers ( )

private

Prepare containers to retrieve configurations.

Definition at line 239 of file xAODRingSetConfWriter.cxx.

{
 
  for (size_t counter = 0; counter < m_rsMetaNames.size(); ++counter)
  {
    // Create an empty RingSetConf container:
    xAOD::RingSetConfAuxContainer* rsAux = new xAOD::RingSetConfAuxContainer();
    xAOD::RingSetConfContainer* rsCont = new xAOD::RingSetConfContainer();
    rsCont->setStore( rsAux );
    m_rsConfContVec.push_back( rsCont );
 
    // Record the RingSet configuration metadata into output container:
    CHECK( m_metaStore->record( rsAux, m_rsMetaNames[counter] + "Aux." ) );
    CHECK( m_metaStore->record( rsCont, m_rsMetaNames[counter] ) );
  }
 
  return StatusCode::SUCCESS;
}

◆ copyInputMetaStore()

StatusCode Ringer::xAODRingSetConfWriter::copyInputMetaStore ( )

private

Private methods:

Retrieve CaloRingsBuilder tools

Definition at line 128 of file xAODRingSetConfWriter.cxx.

{
  ATH_MSG_DEBUG("Checking if it is needed to copy RingSetConf "
      "MetaData on input file.");
 
  CHECK( searchAndCopyCLID< xAOD::RingSetConfAuxContainer >( 
        ClassID_traits< xAOD::RingSetConfContainer >() ) );
 
  return StatusCode::SUCCESS;
}

◆ copyKeyToStore()

template<class auxT, class T>

StatusCode Ringer::xAODRingSetConfWriter::copyKeyToStore ( const std::string & key )

private

Retrieve a key and returns a copy of it to outputmeta.

Definition at line 181 of file xAODRingSetConfWriter.cxx.

{
  typedef typename T::value_type value_type;
  typedef typename T::base_value_type base_value_type;
  // Retrieve container
  const T* cont(nullptr);
  CHECK( m_inputMetaStore->retrieve( cont, key ) );
 
  // Create new containers:
  auxT* contAuxCopy = new auxT;
  T* contCopy = new T;
  contCopy->setStore( contAuxCopy );
 
  // Copy them:
  contCopy->reserve( cont->size() );
  contAuxCopy->reserve( cont->size() );
  ATH_MSG_DEBUG("Copying object with key: " << key);
  for ( const base_value_type* obj : *cont ) {
    ATH_MSG_VERBOSE("Original object:");
    // Print-out object:
    if( msgLevel() <= MSG::VERBOSE ) {
      std::ostringstream str;
      obj->print( str );
      ATH_MSG_VERBOSE( str.str() );
    }
    // Copy object
    value_type objCopy = new (base_value_type)( *obj );
    // Print-out object:
    ATH_MSG_VERBOSE("Copied object:");
    if( msgLevel() <= MSG::VERBOSE ) {
      std::ostringstream str;
      objCopy->print( str );
      ATH_MSG_VERBOSE( str.str() );
    }
    // Add to container
    contCopy->push_back( objCopy );
  }
  
  // And record:
  CHECK( m_metaStore->record( contAuxCopy, key + "Aux.") );
  CHECK( m_metaStore->record( contCopy, key) );
 
  return StatusCode::SUCCESS;
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	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());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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< Algorithm > >::detStore ( ) const

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode Ringer::xAODRingSetConfWriter::execute ( )

Method executing the algorithm.

Definition at line 283 of file xAODRingSetConfWriter.cxx.

{
  // Our execute don't do anything... we don't have any assyncronous change of
  // configuration, so we don't need to keep track of what happens here.
  // Return gracefully:
  return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.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();
}

◆ fillConfigurations()

StatusCode Ringer::xAODRingSetConfWriter::fillConfigurations ( )

private

Fill the containers with each CaloRingsBuilder tool configuration.

Definition at line 259 of file xAODRingSetConfWriter.cxx.

{
 
  for (size_t counter = 0; counter < m_rsConfContVec.size(); ++counter)
  {
    auto& crBuilder = m_crBuilderTools[counter];
 
    // Create the xAOD configuration object (it will populate
    // RingSetConfContainer for us):
    xAOD::RingSetConf::fillRingSetConfContainer( 
        crBuilder->rawConf(), 
        *m_rsConfContVec[counter]);
 
    // Inform what we did:
    ATH_MSG_DEBUG( "Got configuration for " << crBuilder->name() << "." );
 
  }
 
  return StatusCode::SUCCESS;
 
}

◆ finalize()

StatusCode Ringer::xAODRingSetConfWriter::finalize ( )

Method executing the algorithm.

Definition at line 292 of file xAODRingSetConfWriter.cxx.

{
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode Ringer::xAODRingSetConfWriter::initialize ( )

Method initialising the algorithm.

Definition at line 46 of file xAODRingSetConfWriter.cxx.

                                             {
 
  // Greet the user:
  ATH_MSG_INFO( "Initialising" );
 
  // Make sure that configuration param are equivalent in size:
  if ( m_crBuilderTools.size() != m_rsMetaNames.size() )
  {
 
    ATH_MSG_ERROR("Configuration error: every CaloRingsBuilder should "
        "have its own RingSet/CaloRings names "
        "set via the RingSetConfMetaNames "
        "python configurable.");
 
    ATH_MSG_ERROR("The retrieven m_RingSet names are: " << m_rsMetaNames );
    ATH_MSG_ERROR("The retrieven m_crBuilderTools names are: " 
        << [this]()
        {
          std::vector<std::string> names;
          for ( const auto& tool : m_crBuilderTools )
          {
            names.push_back( tool.name() );
          }
          return names;
        }()
      );
 
    return StatusCode::FAILURE;
  }
 
  // Display the configuration:
  ATH_MSG_DEBUG( "RingSetConfMetaNames = " << m_rsMetaNames );
  if ( msg().level() <= MSG::DEBUG ){ // Display 
    std::vector<std::string> toolNames;
    toolNames.reserve( m_crBuilderTools.size() );
    for ( const auto &tool : m_crBuilderTools ){
      toolNames.push_back( tool.name() );
    }
    ATH_MSG_DEBUG( "CaloRingsBuilderTools = " << toolNames );
  }
 
  ATH_MSG_VERBOSE( "inputMetaStore = " << m_inputMetaStore->dump() );
 
  // Retrieve the necessary service(s):
  CHECK( m_metaStore.retrieve() );
  CHECK( m_inputMetaStore.retrieve() );
 
  // Now work to set xAOD RingSet/CaloRings configuration metadata available on
  // the output meta store:
  CHECK( retrieveCaloRingsBuilders() );
  CHECK( allocateContainers() );
  CHECK( fillConfigurations() );
 
  // NOTE: This must be called after fillConfigurations, otherwise it will
  // attempt to fill those configurations retrieven from the builders.
  CHECK( copyInputMetaStore() );
 
  // Print-out configurations:
  ATH_MSG_DEBUG("There are available a total of " << m_rsConfContVec.size() << " RingSetConfContainer(s).");
  for ( const auto* c : m_rsConfContVec ) {
    if ( nullptr != c ) {
      if ( msg().level() <= MSG::VERBOSE ) {
        for ( const auto *const r : *c ){
          std::ostringstream str;
          r->print( str );
          ATH_MSG_VERBOSE( str.str() );
        }
      }
    } else {
      ATH_MSG_WARNING("Container " << c << "is empty!");
    }
  }
 
  ATH_MSG_DEBUG("Obtained configuration succesfully.");
 
  ATH_MSG_VERBOSE( "outputMetaStore = " << m_metaStore->dump() );
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< 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.

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< 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< 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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ retrieveCaloRingsBuilders()

StatusCode Ringer::xAODRingSetConfWriter::retrieveCaloRingsBuilders ( )

private

Retrieve CaloRingsBuilder tools.

Definition at line 228 of file xAODRingSetConfWriter.cxx.

{
  ATH_MSG_INFO("Retrieving " << m_crBuilderTools.size() <<
    " reader tools for " << name() );
 
  ATH_CHECK(m_crBuilderTools.retrieve());
 
  return StatusCode::SUCCESS;
}

◆ searchAndCopyCLID()

template<class auxT, class T>

StatusCode Ringer::xAODRingSetConfWriter::searchAndCopyCLID ( const ClassID_traits< T > & classID )

private

Auxiliary method called by copyInputMetaStore.

Definition at line 141 of file xAODRingSetConfWriter.cxx.

{
  std::vector< std::string > ringConfKeys;
 
  // Retrieve our container keys:
  m_inputMetaStore->keys( classID.ID() , ringConfKeys); 
  
  ATH_MSG_DEBUG( "Available keys with type(" << classID.typeName() << ") are: " 
      << ringConfKeys );
 
  // Now loop retrieving them and recording on the outputContainer:
  for ( const auto &key : ringConfKeys ) 
  {
    if (key[0] == ';' && key[3] == ';') continue; // ignore versioned keys
    ATH_MSG_VERBOSE( "Attempting to copy " << key );
 
    // Check if this meta isn't already available in output, if so, do not copy it:
    if ( std::any_of( m_rsMetaNames.begin(), m_rsMetaNames.end(),  
        [&key](std::string &builderKey){
          return (builderKey == key) || ((builderKey + "Aux.") == key);
        } ) )
    {
      ATH_MSG_VERBOSE( "This key is already going to be built "
          "(outputMetaNames = " << m_rsMetaNames << ")"
          ", it will NOT be copied!" );
      continue;
    }
 
    // Retrieve and record its copy in output store
    CHECK( (copyKeyToStore<auxT, T>( key )) ); 
    ATH_MSG_INFO( "Successfully copied key " << key );
  }
 
  return StatusCode::SUCCESS;
 
}

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<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< 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< 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

◆ m_crBuilderTools

ToolHandleArray< Ringer::ICaloRingsBuilder > Ringer::xAODRingSetConfWriter::m_crBuilderTools

private

Connection to the trigger configuration service.

Definition at line 71 of file xAODRingSetConfWriter.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_inputMetaStore

ServiceHandle< StoreGateSvc > Ringer::xAODRingSetConfWriter::m_inputMetaStore

private

Connection to the inputMetadata store.

Definition at line 69 of file xAODRingSetConfWriter.h.

◆ m_metaStore

ServiceHandle< StoreGateSvc > Ringer::xAODRingSetConfWriter::m_metaStore

private

Private properties (python configurables):Connection to the (output)metadata store.

Definition at line 67 of file xAODRingSetConfWriter.h.

◆ m_rsConfContVec

std::vector< xAOD::RingSetConfContainer* > Ringer::xAODRingSetConfWriter::m_rsConfContVec

private

Private properties (non python configurables):The CaloRings configuration container.

Definition at line 79 of file xAODRingSetConfWriter.h.

◆ m_rsMetaNames

std::vector<std::string> Ringer::xAODRingSetConfWriter::m_rsMetaNames

private

StoreGate keys for the RingSet configurations.

Definition at line 73 of file xAODRingSetConfWriter.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ xAODRingSetConfWriter()

Member Function Documentation

◆ allocateContainers()

◆ copyInputMetaStore()

◆ copyKeyToStore()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillConfigurations()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ retrieveCaloRingsBuilders()

◆ searchAndCopyCLID()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_crBuilderTools

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_inputMetaStore

◆ m_metaStore

◆ m_rsConfContVec

◆ m_rsMetaNames

◆ m_varHandleArraysDeclared

◆ m_vhka