#include <L1CaloCondSvc.h>

Inheritance diagram for L1CaloCondSvc:

Collaboration diagram for L1CaloCondSvc:

Public Member Functions
	L1CaloCondSvc (const std::string &name, ISvcLocator *svc)

virtual	~L1CaloCondSvc ()

virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)

virtual StatusCode	initialize ()

virtual StatusCode	finalize ()

template<typename T >
StatusCode	store (const T *&pobj, const std::string &key, const std::string &folder, const std::string &tag) const
	To store a condition object into the COOL DB. More...

template<typename T >
StatusCode	retrieve (T *&pobj, const std::string &key="")
	To retrieve a condition object from the COOL DB. More...

template<typename T , typename FolderMapping >
StatusCode	retrieve (T *&pobj, const FolderMapping &folderKeyMap, const std::string &key="")
	To retrieve a condition object from the COOL DB with custom folder mapping. More...

virtual StatusCode	updateConditions (IOVSVC_CALLBACK_ARGS)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Private Member Functions
template<typename T >
StatusCode	retrieveImpl (T *&pobj, const std::string &key)

template<typename T >
StatusCode	registerCondition (T *&pobj, const std::string &mykey="")

Private Attributes
ServiceHandle< StoreGateSvc >	m_detStore

ServiceHandle< IIOVRegistrationSvc >	m_regSvc

std::string	m_streamName

bool	m_bWriteNewChannels

unsigned int	m_iovBeginRun

unsigned int	m_iovEndRun

unsigned int	m_iovBeginLB

unsigned int	m_iovEndLB

uint64_t	m_iovBeginTime

uint64_t	m_iovEndTime

bool	m_bUseTimeStamp

std::map< std::string, const DataHandle< AthenaAttributeList > * >	m_mDataHandleAttrList

std::map< std::string, const DataHandle< CondAttrListCollection > * >	m_mDataHandleAttrListColl

std::map< std::string, std::vector< IL1CaloPersistenceCapable * > >	m_mConditions

std::map< IL1CaloPersistenceCapable *, std::vector< std::string > >	m_map_conditions2key

Detailed Description

L1CaloCondSvc class.

Service that implement the methods required to store/retrieve inline payload to/from the condition DB

Author: Damien Prieur damie.nosp@m.n.pr.nosp@m.ieur@.nosp@m.cern.nosp@m..ch

Definition at line 38 of file L1CaloCondSvc.h.

Constructor & Destructor Documentation

◆ L1CaloCondSvc()

L1CaloCondSvc::L1CaloCondSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 13 of file L1CaloCondSvc.cxx.

                                                                     :
   AthService(name, svc),
   m_detStore ("DetectorStore", name),
   m_regSvc ("IOVRegistrationSvc", name)
 {
     // declare properties
     declareProperty("StreamName", m_streamName = "COOLStream");
     declareProperty("BeginRun",   m_iovBeginRun   = 0         );
     declareProperty("EndRun",     m_iovEndRun     = 0x7FFFFFFF);
     declareProperty("BeginLB", m_iovBeginLB = 0         );
     declareProperty("EndLB",   m_iovEndLB   = 0xFFFFFFFF);
     declareProperty("BeginTime",   m_iovBeginTime   = 0);
     declareProperty("EndTime",   m_iovEndTime   = 0);
     declareProperty("TimeStamp",   m_bUseTimeStamp   = false);
     declareProperty("WriteNewChannels",   m_bWriteNewChannels   = false);
 }

◆ ~L1CaloCondSvc()

L1CaloCondSvc::~L1CaloCondSvc ( )

virtual

Definition at line 30 of file L1CaloCondSvc.cxx.

30 {}

Member Function Documentation

◆ finalize()

StatusCode L1CaloCondSvc::finalize ( )

virtual

Definition at line 55 of file L1CaloCondSvc.cxx.

 {
     ATH_MSG_DEBUG("in finalize()");
  
     std::map<std::string, const DataHandle<AthenaAttributeList>* >::iterator it_AttrList = m_mDataHandleAttrList.begin();
     for(;it_AttrList!=m_mDataHandleAttrList.end();++it_AttrList) {
         delete it_AttrList->second;
     }
  
     std::map<std::string, const DataHandle<CondAttrListCollection>* >::iterator it_AttrListColl = m_mDataHandleAttrListColl.begin();
     for(;it_AttrListColl!=m_mDataHandleAttrListColl.end();++it_AttrListColl) {
         delete it_AttrListColl->second;
     }
  
     return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode L1CaloCondSvc::initialize ( )

virtual

Definition at line 47 of file L1CaloCondSvc.cxx.

 {
   ATH_CHECK( AthService::initialize() );
   ATH_CHECK( m_detStore.retrieve() );
   ATH_CHECK( m_regSvc.retrieve() );
   return StatusCode::SUCCESS;
 }

◆ interfaceID()

const InterfaceID & L1CaloCondSvc::interfaceID ( )

inlinestatic

Definition at line 114 of file L1CaloCondSvc.h.

                                                      {
   static const InterfaceID IID_L1CaloCondSvc("L1CaloCondSvc",1,0);
   return IID_L1CaloCondSvc;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ queryInterface()

StatusCode L1CaloCondSvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)

virtual

Definition at line 32 of file L1CaloCondSvc.cxx.

 {
   ATH_MSG_DEBUG("in queryInterface()");
  
   if (L1CaloCondSvc::interfaceID().versionMatch(riid)) {
     ATH_MSG_DEBUG("matched L1CaloCondSvc");
     *ppvInterface=(L1CaloCondSvc*)this;
   } else {
     ATH_MSG_DEBUG("Default to Service interface");
     return AthService::queryInterface(riid,ppvInterface);
   }
   return StatusCode::SUCCESS;
 }

◆ registerCondition()

template<typename T >

StatusCode L1CaloCondSvc::registerCondition	(	T *&	pobj,
		const std::string &	mykey = `""`
	)

private

◆ retrieve() [1/2]

template<typename T , typename FolderMapping >

StatusCode L1CaloCondSvc::retrieve	(	T *&	pobj,
		const FolderMapping &	folderKeyMap,
		const std::string &	key = `""`
	)

To retrieve a condition object from the COOL DB with custom folder mapping.

Warning: Only objects that implement the IL1CaloPersistenceCapable interface can be retrieved using this method

◆ retrieve() [2/2]

template<typename T >

StatusCode L1CaloCondSvc::retrieve	(	T *&	pobj,
		const std::string &	key = `""`
	)

To retrieve a condition object from the COOL DB.

Warning: Only objects that implement the IL1CaloPersistenceCapable interface can be retrieved using this method

◆ retrieveImpl()

template<typename T >

StatusCode L1CaloCondSvc::retrieveImpl	(	T *&	pobj,
		const std::string &	key
	)

private

◆ store()

template<typename T >

StatusCode L1CaloCondSvc::store	(	const T *&	pobj,
		const std::string &	key,
		const std::string &	folder,
		const std::string &	tag
	)		const

To store a condition object into the COOL DB.

Warning: Only objects that implement the IL1CaloPersistenceCapable interface can be stored using this method

◆ updateConditions()

StatusCode L1CaloCondSvc::updateConditions ( IOVSVC_CALLBACK_ARGS )

virtual

Definition at line 72 of file L1CaloCondSvc.cxx.

                                                                        {
  
  
 //  ATH_MSG_INFO("ACH updateConditions()");
         ATH_MSG_VERBOSE("updateConditions()");
  
     // set to store the list of objects to be updated.
     std::set<IL1CaloPersistenceCapable*> vToBeUpdated;
  
     // loop over the keys of folders that have new conditions to be cached
     std::list<std::string>::const_iterator itr;
     for(itr=keys.begin(); itr!=keys.end(); ++itr) {
         std::string key = *itr;
 //      ATH_MSG_INFO("ACH key = " << key);
                 ATH_MSG_VERBOSE("key = " << key);
  
         // find the current key in the map
         std::map<std::string, std::vector<IL1CaloPersistenceCapable*> >::const_iterator it_map = m_mConditions.find(key);
         if(it_map!=m_mConditions.end()) {
  
             // loop over objects that depend on the current folder/key
             std::vector<IL1CaloPersistenceCapable*> vObjs = it_map->second;
             std::vector<IL1CaloPersistenceCapable*>::const_iterator it_vObjs = vObjs.begin();
             for(;it_vObjs!=vObjs.end();++it_vObjs) {
                 IL1CaloPersistenceCapable* pobj = *it_vObjs;
                 vToBeUpdated.insert(pobj);
             }
         }
     }
  
     // form here vToBeUpdated contains the list of objects to be updated
     // loop over them, get the required datahandles and pass them to pobj
     std::set<IL1CaloPersistenceCapable*>::const_iterator it_set = vToBeUpdated.begin();
     for(;it_set!=vToBeUpdated.end();++it_set) {
         IL1CaloPersistenceCapable* pobj = *it_set;
  
         // get the keys/folders required by current object
         std::vector<std::string> vCoolInputKeys = pobj->coolInputKeys();
                 
     std::vector<std::string> otherkeys = m_map_conditions2key[pobj];
     vCoolInputKeys.insert(vCoolInputKeys.end(),otherkeys.begin(),otherkeys.end());
                 
         std::string conditionType = pobj->conditionType();
 //                 ATH_MSG_INFO("ACH conditionType = "<<conditionType);
  
         if(conditionType=="CondAttrListCollection") {
  
             // will contain pointer to the CondAttrListCollection(s) required by pobj to populate itself.
             std::map<std::string, const CondAttrListCollection*> condAttrListCollectionMap;
  
             // loop onver input keys, to get the corresponding datahandle
             std::vector<std::string>::const_iterator it_coolInputKeys = vCoolInputKeys.begin();
             for(;it_coolInputKeys!=vCoolInputKeys.end();++it_coolInputKeys) {
                 std::string key = *it_coolInputKeys;
 //              ATH_MSG_INFO("ACH update key = " << key);
                                 std::map<std::string, const DataHandle<CondAttrListCollection>* >::iterator it = m_mDataHandleAttrListColl.find(key);
                                 if (it != m_mDataHandleAttrListColl.end()) {
                    const DataHandle<CondAttrListCollection>& dh = *m_mDataHandleAttrListColl[key];
                    const CondAttrListCollection* attrListCollection = &(*dh);
                    if (attrListCollection) {
 //                  ATH_MSG_INFO("ACH attrListCollection = "<<attrListCollection);
                     condAttrListCollectionMap[key] = (CondAttrListCollection*)attrListCollection;
                     }
                                 }
             }
 //          ATH_MSG_INFO("ACH condAttrListCollectionMap size is "<<condAttrListCollectionMap.size());
             pobj->makeTransient(condAttrListCollectionMap);
  
         } else if(conditionType=="AthenaAttributeList"){
 /*
             const DataHandle<AthenaAttributeList>& dh = *m_mDataHandleAttrList[key];
  
             const AthenaAttributeList* athenaAttributeList = &(*dh);
             pobj->makeTransient(athenaAttributeList);
 */
         } else {
             ATH_MSG_ERROR("Condition type " << conditionType<< "not recognized by L1CaloCondSvc");
             return StatusCode::FAILURE;
         }
  
     }
  
  
  
 /*
         std::map<std::string, std::vector<IL1CaloPersistenceCapable*> >::const_iterator it_obj = m_mConditions.find(key);
         if(it_obj!=m_mConditions.end()) {
  
             IL1CaloPersistenceCapable* pobj = it_obj->second;
  
             std::string conditionType = pobj->conditionType();
             if(conditionType=="CondAttrListCollection") {
  
                 const DataHandle<CondAttrListCollection>& dh = *m_mDataHandleAttrListColl[key];
  
                 const CondAttrListCollection* attrListCollection = &(*dh);
                 pobj->makeTransient(attrListCollection);
  
             } else if(conditionType=="AthenaAttributeList"){
  
                 const DataHandle<AthenaAttributeList>& dh = *m_mDataHandleAttrList[key];
  
                 const AthenaAttributeList* athenaAttributeList = &(*dh);
                 pobj->makeTransient(athenaAttributeList);
  
             } else {
                 log << MSG::ERROR << "Condition type " << conditionType<< "not recognized by L1CaloCondSvc" << endmsg;
                 return StatusCode::FAILURE;
             }
         }
 */
  
  
     ATH_MSG_VERBOSE("end of L1CaloCondSvc::updateConditions(IOVSVC_CALLBACK_ARGS_P(/*I*/, keys))");
     return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_bUseTimeStamp

bool L1CaloCondSvc::m_bUseTimeStamp

private

Definition at line 98 of file L1CaloCondSvc.h.

◆ m_bWriteNewChannels

bool L1CaloCondSvc::m_bWriteNewChannels

private

Definition at line 89 of file L1CaloCondSvc.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> L1CaloCondSvc::m_detStore

private

Definition at line 83 of file L1CaloCondSvc.h.

◆ m_iovBeginLB

unsigned int L1CaloCondSvc::m_iovBeginLB

private

Definition at line 94 of file L1CaloCondSvc.h.

◆ m_iovBeginRun

unsigned int L1CaloCondSvc::m_iovBeginRun

private

Definition at line 92 of file L1CaloCondSvc.h.

◆ m_iovBeginTime

uint64_t L1CaloCondSvc::m_iovBeginTime

private

Definition at line 96 of file L1CaloCondSvc.h.

◆ m_iovEndLB

unsigned int L1CaloCondSvc::m_iovEndLB

private

Definition at line 95 of file L1CaloCondSvc.h.

◆ m_iovEndRun

unsigned int L1CaloCondSvc::m_iovEndRun

private

Definition at line 93 of file L1CaloCondSvc.h.

◆ m_iovEndTime

uint64_t L1CaloCondSvc::m_iovEndTime

private

Definition at line 97 of file L1CaloCondSvc.h.

◆ m_map_conditions2key

std::map<IL1CaloPersistenceCapable*,std::vector<std::string> > L1CaloCondSvc::m_map_conditions2key

private

Definition at line 110 of file L1CaloCondSvc.h.

◆ m_mConditions

std::map<std::string, std::vector<IL1CaloPersistenceCapable*> > L1CaloCondSvc::m_mConditions

private

Definition at line 109 of file L1CaloCondSvc.h.

◆ m_mDataHandleAttrList

std::map<std::string, const DataHandle<AthenaAttributeList>* > L1CaloCondSvc::m_mDataHandleAttrList

private

Definition at line 107 of file L1CaloCondSvc.h.

◆ m_mDataHandleAttrListColl

std::map<std::string, const DataHandle<CondAttrListCollection>* > L1CaloCondSvc::m_mDataHandleAttrListColl

private

Definition at line 108 of file L1CaloCondSvc.h.

◆ m_regSvc

ServiceHandle<IIOVRegistrationSvc> L1CaloCondSvc::m_regSvc

private

Definition at line 84 of file L1CaloCondSvc.h.

◆ m_streamName

std::string L1CaloCondSvc::m_streamName

private

Definition at line 87 of file L1CaloCondSvc.h.

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ L1CaloCondSvc()

◆ ~L1CaloCondSvc()

Member Function Documentation

◆ finalize()

◆ initialize()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ queryInterface()

◆ registerCondition()

◆ retrieve() [1/2]

◆ retrieve() [2/2]

◆ retrieveImpl()

◆ store()

◆ updateConditions()

Member Data Documentation

◆ m_bUseTimeStamp

◆ m_bWriteNewChannels

◆ m_detStore

◆ m_iovBeginLB

◆ m_iovBeginRun

◆ m_iovBeginTime

◆ m_iovEndLB

◆ m_iovEndRun

◆ m_iovEndTime

◆ m_map_conditions2key

◆ m_mConditions

◆ m_mDataHandleAttrList

◆ m_mDataHandleAttrListColl

◆ m_regSvc

◆ m_streamName