AthenaPoolAddressProviderSvc Class Reference

This class is the EventSelector and AddressProvider for event data. More...

#include <AthenaPoolAddressProviderSvc.h>

Inheritance diagram for AthenaPoolAddressProviderSvc:

Collaboration diagram for AthenaPoolAddressProviderSvc:

Public Member Functions
	AthenaPoolAddressProviderSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor. More...
virtual	~AthenaPoolAddressProviderSvc ()
	Destructor. More...
virtual StatusCode	initialize () override
	Required of all Gaudi Services. More...
virtual StatusCode	preLoadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
	Get all addresses from provider. More...
virtual StatusCode	loadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
	Get all addresses for this event from provider. More...
virtual StatusCode	updateAddress (StoreID::type storeID, SG::TransientAddress *tad, const EventContext &ctx) override
	Update a transient address. More...

Private Member Functions
StoreGateSvc *	eventStore () const
	Return pointer to active event SG. More...

Private Attributes
ServiceHandle< StoreGateSvc >	m_metaDataStore
ServiceHandle< IClassIDSvc >	m_clidSvc
Guid	m_guid
std::unordered_set< std::string >	m_dhFormKeys
	Set of DataHeader form keys for which we've already done registerKeys. More...
Gaudi::Property< std::string >	m_dataHeaderKey
Gaudi::Property< std::string >	m_attrListKey

Detailed Description

This class is the EventSelector and AddressProvider for event data.

Definition at line 28 of file AthenaPoolAddressProviderSvc.h.

Constructor & Destructor Documentation

AthenaPoolAddressProviderSvc()

AthenaPoolAddressProviderSvc::AthenaPoolAddressProviderSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Standard Service Constructor.

Definition at line 31 of file AthenaPoolAddressProviderSvc.cxx.

                                                                                                          :
    base_class(name, pSvcLocator),
    m_metaDataStore("StoreGateSvc/MetaDataStore", name),
    m_clidSvc("ClassIDSvc", name),
    m_guid() {
}

~AthenaPoolAddressProviderSvc()

AthenaPoolAddressProviderSvc::~AthenaPoolAddressProviderSvc ( )

virtual

Destructor.

Definition at line 38 of file AthenaPoolAddressProviderSvc.cxx.

                                                            {
}

Member Function Documentation

eventStore()

StoreGateSvc * AthenaPoolAddressProviderSvc::eventStore ( ) const

private

Return pointer to active event SG.

Definition at line 41 of file AthenaPoolAddressProviderSvc.cxx.

                                                             {
   return StoreGateSvc::currentStoreGate();
}

initialize()

StatusCode AthenaPoolAddressProviderSvc::initialize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 45 of file AthenaPoolAddressProviderSvc.cxx.

                                                    {
 
   ATH_CHECK( m_metaDataStore.retrieve() );
   ATH_CHECK( m_clidSvc.retrieve() );
 
   return StatusCode::SUCCESS;
}

loadAddresses()

StatusCode AthenaPoolAddressProviderSvc::loadAddresses ( StoreID::type  storeID, IAddressProvider::tadList &  tads  )

overridevirtual

Get all addresses for this event from provider.

Parameters

storeID	[IN] store ID, this function only preloads event store addresses.
tads	[OUT] list of the transient addresses which were preloaded.

Only call registerKeys() if we haven't seen this form before.

Definition at line 81 of file AthenaPoolAddressProviderSvc.cxx.

                                       {
   if (storeID != StoreID::EVENT_STORE && storeID != StoreID::PILEUP_STORE) {
      return StatusCode::SUCCESS;
   }
 
   Guid thisFile = Guid::null();
   const DataHeader* dataHeader = nullptr;
   if (dataHeader == nullptr) { // New file (or reading DataHeader)
      SG::ReadHandle<DataHeader> eventDataHeader(m_dataHeaderKey.value(), eventStore()->name());
      if (!eventDataHeader.isValid()) {
         ATH_MSG_ERROR("Cannot retrieve DataHeader from StoreGate: " << m_dataHeaderKey);
         return StatusCode::FAILURE;
      }
      dataHeader = eventDataHeader.cptr();
   }
   // second data header
   if (m_attrListKey.value() != "") {
      const AthenaAttributeList* attrList = nullptr;
      std::string tokenStr;
      if (eventStore()->retrieve(attrList, m_attrListKey.value()).isSuccess()) {
         try {
            tokenStr = (*attrList)["eventRef_secondary"].data<std::string>();
            ATH_MSG_DEBUG("found AthenaAttribute, name = eventRef_secondary = " << tokenStr);
         } catch (std::exception &e) {
            ATH_MSG_ERROR(e.what());
            return StatusCode::FAILURE;
         }
      } else {
         ATH_MSG_ERROR("Cannot find AthenaAttribute, key = " << m_attrListKey.value());
         return StatusCode::FAILURE;
      }
      IOpaqueAddress* iop = new GenericAddress(pool::POOL_StorageType.type(), ClassID_traits<DataHeader>::ID(), tokenStr, "SecondaryEventSelector");
      if (!eventStore()->recordAddress(iop).isSuccess()) {
         ATH_MSG_ERROR("Cannot record address to StoreGate with token string: " << tokenStr);
         return StatusCode::FAILURE;
      }
      ATH_MSG_DEBUG("Created dataHeader SecondaryEventSelector");
   }
   bool doRegister = dataHeader->dhFormToken().empty() ||
     m_dhFormKeys.emplace (dataHeader->dhFormToken()).second;
   ATH_MSG_DEBUG("The current Event contains: " << dataHeader->size() << " objects");
   for (const auto& element : *dataHeader) {
      if (doRegister) {
         EventSelectorAthenaPoolUtil::registerKeys(element, eventStore());
      }
      SG::TransientAddress* tadd = element.getAddress(pool::POOL_StorageType.type());
      if (tadd->clID() == ClassID_traits<DataHeader>::ID()) { // self reference
         delete tadd; tadd = nullptr;
      } else {
         ATH_MSG_DEBUG("loadAddresses: DataObject address, clid = " << tadd->clID() << ", name = " << tadd->name());
         tadd->setProvider(this, storeID);
         tads.push_back(tadd);
      }
   }
   m_guid = thisFile;
   return StatusCode::SUCCESS;
}

preLoadAddresses()

StatusCode AthenaPoolAddressProviderSvc::preLoadAddresses ( StoreID::type  storeID, IAddressProvider::tadList &  tads  )

overridevirtual

Get all addresses from provider.

Called before begin event.

Parameters

storeID	[IN] store ID, this function only preloads detector store addresses.
tads	[OUT] list of the transient addresses which were preloaded.

Definition at line 53 of file AthenaPoolAddressProviderSvc.cxx.

                                       {
   if (storeID != StoreID::DETECTOR_STORE) {
      return StatusCode::SUCCESS;
   }
   ServiceHandle<StoreGateSvc> detectorStoreSvc("DetectorStore", name());
   ATH_CHECK( detectorStoreSvc.retrieve() );
 
   SG::ReadHandle<DataHeader> dataHeader("CondProxyProvider", detectorStoreSvc->name());
   if (!dataHeader.isValid()) {
      ATH_MSG_DEBUG("Cannot retrieve DataHeader from DetectorStore.");
      return StatusCode::SUCCESS;
   }
   ATH_MSG_DEBUG("The current File contains: " << dataHeader->size() << " objects");
   for (const auto& element : *dataHeader) {
      SG::TransientAddress* tadd = element.getAddress(pool::POOL_StorageType.type());
      if (tadd->clID() == ClassID_traits<DataHeader>::ID()) {
         delete tadd; tadd = nullptr;
      } else {
         ATH_MSG_DEBUG("preLoadAddresses: DataObject address, clid = " << tadd->clID() << ", name = " << tadd->name());
         tads.push_back(tadd);
      }
      EventSelectorAthenaPoolUtil::registerKeys(element, &*detectorStoreSvc);
   }
 
   return StatusCode::SUCCESS;
}

updateAddress()

StatusCode AthenaPoolAddressProviderSvc::updateAddress ( StoreID::type  storeID, SG::TransientAddress *  tad, const EventContext &  ctx  )

overridevirtual

Update a transient address.

Parameters

storeID	[IN] store ID, this function only preloads event store addresses.
tad	[IN] transient address to be updated.

Definition at line 141 of file AthenaPoolAddressProviderSvc.cxx.

                                                                              {
   return StatusCode::FAILURE;
}

Member Data Documentation

m_attrListKey

Gaudi::Property<std::string> AthenaPoolAddressProviderSvc::m_attrListKey

private

Initial value:

{this, "AttributeListKey", {},
     "Attribute list key of a secondary input file. If non-zero, creates a new IOpaqueAddress for that file and records it."}

Definition at line 65 of file AthenaPoolAddressProviderSvc.h.

m_clidSvc

ServiceHandle<IClassIDSvc> AthenaPoolAddressProviderSvc::m_clidSvc

private

Definition at line 56 of file AthenaPoolAddressProviderSvc.h.

m_dataHeaderKey

Gaudi::Property<std::string> AthenaPoolAddressProviderSvc::m_dataHeaderKey

private

Initial value:

{this, "DataHeaderKey", "EventSelector",
       "StoreGate key of event entry object"}

Definition at line 62 of file AthenaPoolAddressProviderSvc.h.

m_dhFormKeys

std::unordered_set<std::string> AthenaPoolAddressProviderSvc::m_dhFormKeys

private

Set of DataHeader form keys for which we've already done registerKeys.

Definition at line 59 of file AthenaPoolAddressProviderSvc.h.

m_guid

Guid AthenaPoolAddressProviderSvc::m_guid

private

Definition at line 57 of file AthenaPoolAddressProviderSvc.h.

m_metaDataStore

ServiceHandle<StoreGateSvc> AthenaPoolAddressProviderSvc::m_metaDataStore

private

Definition at line 55 of file AthenaPoolAddressProviderSvc.h.

---

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

• AthenaPoolAddressProviderSvc.h
• AthenaPoolAddressProviderSvc.cxx