TagInfoMgr Class Reference

This is a Athena service which manages detector description tag information. More...

#include <TagInfoMgr.h>

Inheritance diagram for TagInfoMgr:

Collaboration diagram for TagInfoMgr:

Classes
class	SvcFactory
	Allow the factory class access to the constructor. More...

Public Member Functions
	TagInfoMgr (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters:
	~TagInfoMgr ()
Basic service methods
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	finalize () override
Method to allow clients add in tags as: tag name, tag value
virtual StatusCode	addTag (const std::string &tagName, const std::string &tagValue) override
	Method to allow clients add in tags as: tag name, tag value.
virtual StatusCode	removeTagFromInput (const std::string &tagName) override
	Method to allow clients to remove a tag which may have come in on the input.
virtual std::string	findTag (const std::string &name) const override final
	Find tag by name, return by value.
virtual std::string	findInputTag (const std::string &name) const override final
	Find tag by its name - for input tags, return by value.
virtual NameTagPairVec	getInputTags () const override final
	Return a vector with all current input tags.
virtual std::string	dumpTagInfoToStr () const override final
	Dump the content of the current TagInfo to std::string for debug.
virtual void	printTags (MsgStream &log) const override final
	Printout method.
virtual void	addListener (Listener *listener) override final
	Add a Listener to the notification list for TagInfo changes.
virtual void	removeListener (Listener *listener) override final
	Remove a Listener from the notification list for TagInfo changes.

TagInfo management methods:
class	SvcFactory< TagInfoMgr >
	forward declaration
Gaudi::Property< std::map< std::string, std::string > >	m_extraTagValuePairs { this, "ExtraTagValuePairs", {}, "key/value pairs to be added" }
	Extra tags/values pairs added in my jobOptions.
std::map< std::string, std::string >	m_extraTagValuePairsViaInterface
	Extra tags/values pairs added in via interface.
std::set< std::string >	m_tagsToBeRemoved
	Extra tags to be removed.
ServiceHandle< StoreGateSvc >	m_storeGate { this, "StoreGateSvc", "StoreGateSvc" }
	The event store.
ServiceHandle< StoreGateSvc >	m_detStore { this, "DetectorStore", "DetectorStore" }
	The detector store.
ServiceHandle< IIOVDbSvc >	m_iovDbSvc { this, "IOVDbSvc", "IOVDbSvc" }
	Access to IOVDbSvc interface - used to register callback.
PublicToolHandle< IIOVDbMetaDataTool >	m_metaDataTool { this, "IOVDbMetaDataTool", "IOVDbMetaDataTool" }
	Access to iov meta data tool.
bool	m_isFirstBeginRun { true }
	Flag to identify the first BeginRun incident.
EventIDBase::number_type	m_conditionsRun { EventIDBase::UNDEFNUM }
	conditionsRun from the first BeginRun incident (HLT)
EventIDBase::number_type	m_currentRun { EventIDBase::UNDEFNUM }
	current run number from BeginRun incident
IOVRange	m_lastIOVRange { IOVRange(IOVTime(), IOVTime()) }
	IOVRange of last TagInfo added to the file meta data.
TagInfo	m_tagInfo
	The Tags.
std::set< Listener * >	m_listeners
	List of listeners notified when the TagInfo changed.
std::shared_mutex m_mutex	ATLAS_THREAD_SAFE
	mutex to protect internal data in MT
void	handle (const Incident &incident) override final
StatusCode	updateTagInfo ()
	Update Tags when input tags (/TagInfo in-file metadata) change.
void	notifyListeners () const
	Notify all listeners that the Tags were updated.
	TagInfoMgr ()
	TagInfoMgr (const TagInfoMgr &)
TagInfoMgr &	operator= (const TagInfoMgr &)
StatusCode	getRunNumber (unsigned int &runNumber)
StatusCode	fillTagInfo (const CondAttrListCollection *tagInfoCond)
StatusCode	fillMetaData (const CondAttrListCollection *tagInfoCond)

Detailed Description

This is a Athena service which manages detector description tag information.

It maintains a TagInfo object in the Detector Store with current tag values.

The tags to fill the TagInfo object may come from a variety of sources: i.e. the tags specified by the GeoModelSvc and IOVDbSvc, or the tags stored in the incoming EventInfo object, or the TagInfo object itself may be in the IOV DB. The TagInfoMgr itself only adds in tags from the incoming event. Others are added by external clients.

The interface provides a 'input' method to allow client to add in their own tags:

virtual StatusCode addTag(const std::string& tagName, const std::string& tagValue) = 0;

The full set of tags in TagInfo are copied each event into EventInfo (specifically EventType) to be written out in the event stream. Currently, the tags are NOT written to the IOV DB via the TagInfoMgr.

Definition at line 67 of file TagInfoMgr.h.

Constructor & Destructor Documentation

TagInfoMgr() [1/3]

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

Constructor with parameters:

Definition at line 42 of file TagInfoMgr.cxx.

                                                                      :
    base_class(name, pSvcLocator)
{}

~TagInfoMgr()

TagInfoMgr::~TagInfoMgr

(

)

Definition at line 46 of file TagInfoMgr.cxx.

{}

TagInfoMgr() [2/3]

TagInfoMgr::TagInfoMgr ( )

private

TagInfoMgr() [3/3]

TagInfoMgr::TagInfoMgr ( const TagInfoMgr & )

private

Member Function Documentation

addListener()

void TagInfoMgr::addListener ( Listener * listener )

finaloverridevirtual

Add a Listener to the notification list for TagInfo changes.

Definition at line 690 of file TagInfoMgr.cxx.

{
   std::unique_lock guard(m_mutex);
   m_listeners.insert( listener );
}

addTag()

StatusCode TagInfoMgr::addTag ( const std::string & tagName, const std::string & tagValue )

overridevirtual

Method to allow clients add in tags as: tag name, tag value.

Definition at line 624 of file TagInfoMgr.cxx.

{
    // Add name/value to input vector
    ATH_MSG_DEBUG("addTag - adding name/value pairs: " << tagName << " " << tagValue);
    std::unique_lock  guard( m_mutex );
    m_extraTagValuePairsViaInterface[tagName]=tagValue;
    return StatusCode::SUCCESS;
}

dumpTagInfoToStr()

std::string TagInfoMgr::dumpTagInfoToStr ( ) const

finaloverridevirtual

Dump the content of the current TagInfo to std::string for debug.

Definition at line 674 of file TagInfoMgr.cxx.

{
   std::shared_lock guard(m_mutex);
   return m_tagInfo.str();
}

fillMetaData()

StatusCode TagInfoMgr::fillMetaData ( const CondAttrListCollection * tagInfoCond )

private

Register folder in the IOV Db MetaData

Definition at line 281 of file TagInfoMgr.cxx.

{
    // fillMetaData is called at the beginning of the job and for each
    // new file being read in.
    //
    // Fill IOV object in metadata store with information from tag
    // info. 
    //
    // For the IOV we use the IOV from the input conditions. For the first input
    // file, we use the incoming IOV if the current run falls within the IOV
    // range. If not we set the IOV to runNumber to runNumber + 1. For
    // subsequent input files, if the runNumber falls within the previous IOV
    // range, then we set the new IOV to [runNumber, lastStop), otherwise the
    // IOV is set to [runNumber, runNumber+1). This latter is used for the
    // zerobias overlaying.
    //
 
    ATH_MSG_DEBUG( "entering fillMetaData");
 
    // Get run number for IOV
    EventIDBase::number_type runNumber = EventIDBase::UNDEFNUM;
 
    if( m_currentRun != EventIDBase::UNDEFNUM ) {
        runNumber = m_currentRun;
    }
    else if( m_conditionsRun != EventIDBase::UNDEFNUM ) {
        // Not completely sure of the use-case for the setting of the conditions run number, but
        // this will be used if the current run number has not been set. RDS 2020/08
        runNumber = m_conditionsRun;
        ATH_MSG_INFO( "fillMetaData: Using conditions run number: " << m_conditionsRun << " rather then current run number: " << m_currentRun);
    } else {
       // For simulation, we may be in the initialization phase and
       // must get the run number from the event selector
       if (StatusCode::SUCCESS != getRunNumber (runNumber)) {
           ATH_MSG_ERROR( "fillMetaData:  Could not get event info neither via retrieve nor from the EventSelectror");      
           return (StatusCode::FAILURE);
       }
    }
    
    // Copy tags to AttributeList
    coral::AttributeList attrList;
    EventType::NameTagPairVec pairs;
    m_tagInfo.getTags(pairs);
    ATH_MSG_DEBUG( "fillMetaData: Adding value/tag pairs to file meta data: ");
    for (unsigned int i = 0; i < pairs.size(); ++i) {
        attrList.extend(pairs[i].first, "string");
        attrList[pairs[i].first].setValue(pairs[i].second);
        ATH_MSG_DEBUG( pairs[i].first << " " << pairs[i].second);
    }
    
    // Fill collection
    CondAttrListCollection* attrListColl = new CondAttrListCollection(true);
    attrListColl->add(0, attrList);
    // Set IOV:
 
    if (tagInfoCond) {
        // set to the IOV of the incoming conditions
        //  if run num is in previous IOV, set new IOV to be [runNum, lastStop)
        IOVTime testTime(runNumber, 0);
        IOVTime start = m_lastIOVRange.start();
        IOVTime stop  = m_lastIOVRange.stop();
        bool isFirstIOVCheck = false;
        if (!start.isValid() || !stop.isValid()) {
            // Start of job, set lastIOVRange to the incoming IOV
            IOVRange minRange = tagInfoCond->minRange();
            start = minRange.start();
            stop  = minRange.stop();
            ATH_MSG_DEBUG( "IOV minRange from IOVMetaData: " << tagInfoCond->minRange());
            m_lastIOVRange = IOVRange(start, stop);
            isFirstIOVCheck = true;
        }
        if (m_lastIOVRange.isInRange(testTime)) {
            // set start to runNumber after the 
            if (!isFirstIOVCheck) start = testTime; 
            ATH_MSG_DEBUG( "fillMetaData: run number is in previous IOVRange: " << runNumber << " " << m_lastIOVRange);
        }
        else {
            // Out of range
            start = testTime;
            stop  = IOVTime(runNumber + 1, 0);
            ATH_MSG_DEBUG( "fillMetaData: run number is outside of previous IOVRange: " << runNumber << " " << m_lastIOVRange << ". Reset range to run number.");
        }
        attrListColl->addNewStart(start);
        attrListColl->addNewStop (stop);
        m_lastIOVRange = IOVRange(start, stop);
        ATH_MSG_DEBUG( "fillMetaData: start, stop: " << start << " " << stop);
    }
    else {
        // set to the IOV of this run to run+1
        attrListColl->addNewStart(IOVTime(runNumber, 0));
        attrListColl->addNewStop(IOVTime(runNumber + 1, 0));
    }
    
    if (StatusCode::SUCCESS != m_metaDataTool->registerFolder("/TagInfo")) {
        ATH_MSG_ERROR( "fillMetaData: Unable to register folder for TagInfo with meta data tool ");
        return StatusCode::FAILURE;
    }
 
    // Add payload
    if (StatusCode::SUCCESS != m_metaDataTool->addPayload("/TagInfo", attrListColl)) {
        ATH_MSG_ERROR( "fillMetaData: Unable to register folder for TagInfo with meta data tool ");
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
 
}

fillTagInfo()

StatusCode TagInfoMgr::fillTagInfo ( const CondAttrListCollection * tagInfoCond )

private

Definition at line 96 of file TagInfoMgr.cxx.

{
 
    // Fill tag info
    //
    //   We first fill normal tag and input tags with tags coming from
    //   either the EventInfo object or the tag info object coming
    //   from COOL
    //
    //   Then we fill in tags with list of extra tags which are the
    //   current tags for this job. These normally will "over ride"
    //   the tags coming from either COOL/EventInfo. And, of course,
    //   they are not saved as input tags.
    //
 
    // Get the messaging service, print where you are
    ATH_MSG_DEBUG( "fillTagInfo: ");
    // clear existing tags
    m_tagInfo = TagInfo();
 
    // Add tags to TagInfo
 
    if (tagInfoCond) {
        // Coming from COOL
        ATH_MSG_DEBUG( "fillTagInfo: - reading Tags from infile IOV metadata");
 
        // tagInfoCond->dump();
 
        CondAttrListCollection::const_iterator itr     = tagInfoCond->begin();
        if (itr != tagInfoCond->end()) {
            const coral::AttributeList& attrList = (*itr).second;
            coral::AttributeList::const_iterator itAttrList = attrList.begin();
            coral::AttributeList::const_iterator itLast     = attrList.end();
            for (; itAttrList != itLast; ++itAttrList) {
                // Add current tags:
                // -----------------
                // Assumption is that tags from file meta data should
                // be the "first ones in" and there should not be any
                // clash with existing tags. Return WARNING if this
                // happens
                const std::string& name  = (*itAttrList).specification().name();
                const std::string& value = (*itAttrList).data<std::string>();
                // First make sure that this tag name is not on the
                // list of those to be removed
                if (m_tagsToBeRemoved.find(name) == m_tagsToBeRemoved.end()) {
                    if (m_tagInfo.addTag(EventType::NameTagPair(name, value)).isFailure()) {
                        ATH_MSG_WARNING( "fillTagInfo: Unable to add value/tag to TagInfo " 
                              << name << " " << value);
                    }
                    ATH_MSG_DEBUG( "fillTagInfo: Added name/tag to TagInfo " 
                      << name << " " << value);
                }
                else
                   ATH_MSG_DEBUG( "fillTagInfo: Did NOT add tag - on remove list: name/tag: " 
                                  << name << " " << value);
 
                // Duplicate as input tags:
                // ------------------------
                // Assumption is that tags from file meta data should
                // be the "first ones in" and there should not be any
                // clash with existing tags. Return WARNING if this
                // happens
                if (m_tagInfo.addInputTag(EventType::NameTagPair(name, value)).isFailure()) {
                    ATH_MSG_WARNING( "fillTagInfo: Unable to add value/tag to TagInfo as input tag " 
                          << name << " " << value);
                }
                ATH_MSG_DEBUG( "fillTagInfo: Added value/tag to TagInfo as input tag " 
                          << name << " " << value);
            }
        }
        else {
            // error! 
            ATH_MSG_DEBUG( "fillTagInfo:  Could not get attribute list");      
            return (StatusCode::FAILURE);
        }
    }
    else {
        // **********************************************************
        // Get tags from EventInfo/EventType  
        // **********************************************************
        // ***** NOTE: THIS PART IS FOR BACKWARDS COMPATIBILITY *****
        // *****       TAGS ARE NOW WRITTEN TO FILE META DATA   *****
        // *****       THIS CAN BE REMOVED WHEN NO FILES ARE    *****
        // *****        READ WITH TAGS IN EVENT INFO            *****
        // *****        RDS 04/2009                             *****
        // **********************************************************
        //MN: 2021-2022 and still not clear what to do with this part
       
        ATH_MSG_DEBUG( "fillTagInfo: Reading Tags from EventInfo");
        const EventInfo* evtH = m_storeGate->tryConstRetrieve<EventInfo>();
        if( !evtH ) {
            // For simulation, we may be in the initialzation phase
            // and we cannot get EventInfo. We simply skip this step,
            // assuming that most times the information is coming in
            // via conditions/file meta data.
            ATH_MSG_DEBUG( "fillTagInfo:  Could not find EventInfo - skipping the filling of TagInfo from input EventInfo");
        }
        else {
            ATH_MSG_DEBUG( "fillTagInfo: Event ID: ["
                  << evtH->event_ID()->run_number()   << ","
                  << evtH->event_ID()->event_number() << ":"
                  << evtH->event_ID()->time_stamp() << "] " );
            EventType::NameTagPairVec pairs1;
            evtH->event_type()->get_detdescr_tags(pairs1);
 
            if(pairs1.size()) {
                ATH_MSG_DEBUG( "fillTagInfo: Pairs from EventType:");
            }
            else {
                ATH_MSG_DEBUG( "fillTagInfo: EventInfo/EventType has no tags");
            }
            for (unsigned int i = 0; i < pairs1.size(); ++i) {
                ATH_MSG_DEBUG( "fillTagInfo: " << pairs1[i].first << " : "
                      << pairs1[i].second
                     );
                // Add current tags:
                // -----------------
                // Assumption is that EventInfo tags should be the
                // "first ones in" and there should not be any clash
                // with existing tags. Return ERROR if this happens
 
                // First make sure that this tag name is not on the
                // list of those to be removed
                std::string& name = pairs1[i].first;
                if (m_tagsToBeRemoved.find(name) == m_tagsToBeRemoved.end()) {
                    if (m_tagInfo.addTag(pairs1[i]).isFailure()) {
                        ATH_MSG_ERROR( "fillTagInfo: Unable to add tag to TagInfo: name/tag " 
                              << pairs1[i].first << " : "
                              << pairs1[i].second);
                        return (StatusCode::FAILURE);
                    } 
                    else ATH_MSG_DEBUG( "fillTagInfo: Added name/tag to TagInfo " 
                                        << pairs1[i].first << " : "
                                        << pairs1[i].second );
                } else
                   ATH_MSG_DEBUG( "fillTagInfo: Did NOT add tag - on remove list: name/tag: " 
                                  << pairs1[i].first << " : "
                                  << pairs1[i].second );
 
                // Duplicate as input tags:
                // ------------------------
                // Assumption is that EventInfo tags should be the
                // "first ones in" and there should not be any clash
                // with existing tags. Return ERROR if this happens
                if (m_tagInfo.addInputTag(pairs1[i]).isFailure()) {
                    ATH_MSG_ERROR( "fillTagInfo: Unable to add input tag to TagInfo: name/tag " 
                        << pairs1[i].first << " : "
                        << pairs1[i].second);
                    return (StatusCode::FAILURE);
                } 
            }
            ATH_MSG_DEBUG( "fillTagInfo: Added EventInfo tags to TagInfo current/input");
 
        }
    }
    
    // Dump out contents of TagInfo
    ATH_MSG_DEBUG( "fillTagInfo: print out tags before adding extra tags");
    ATH_MSG_DEBUG(m_tagInfo.str());
 
 
    // Add in any extra tag value pairs if specified
    std::map<std::string,std::string> valueTagPairs(m_extraTagValuePairs);
    // Add in pairs from interface
    for (auto & tv : m_extraTagValuePairsViaInterface) {
      valueTagPairs[tv.first]=tv.second;
    }
 
    for (auto& tv : valueTagPairs) {
      ATH_MSG_DEBUG( "fillTagInfo: Adding extra value/tag pair: " << tv.first << " " << tv.second);
      if (m_tagInfo.addTag(EventType::NameTagPair(tv.first,tv.second), true).isFailure()) {
    ATH_MSG_WARNING( "fillTagInfo: Extra value/tag not added to TagInfo ");
      }
    }
 
    // Dump out contents of TagInfo
    ATH_MSG_DEBUG( "fillTagInfo: print out tags");
    ATH_MSG_DEBUG(m_tagInfo.str());
    
    return StatusCode::SUCCESS;
 
}

finalize()

StatusCode TagInfoMgr::finalize ( )

overridevirtual

Definition at line 88 of file TagInfoMgr.cxx.

{
  ATH_MSG_DEBUG( "finalize()");
  return StatusCode::SUCCESS;
}

findInputTag()

std::string TagInfoMgr::findInputTag ( const std::string & name ) const

finaloverridevirtual

Find tag by its name - for input tags, return by value.

Definition at line 658 of file TagInfoMgr.cxx.

{
   std::shared_lock guard(m_mutex);
   return m_tagInfo.findInputTag(name);
}

findTag()

std::string TagInfoMgr::findTag ( const std::string & name ) const

finaloverridevirtual

Find tag by name, return by value.

Definition at line 647 of file TagInfoMgr.cxx.

{
   std::shared_lock guard(m_mutex);
   const auto iter = m_extraTagValuePairsViaInterface.find(name);
   if( iter != m_extraTagValuePairsViaInterface.end() ) {
      return iter->second;
   }
   return m_tagInfo.findTag(name);
}

getInputTags()

ITagInfoMgr::NameTagPairVec TagInfoMgr::getInputTags ( ) const

finaloverridevirtual

Return a vector with all current input tags.

Definition at line 666 of file TagInfoMgr.cxx.

{
   std::shared_lock guard(m_mutex);
   return m_tagInfo.getInputTags();
}

getRunNumber()

StatusCode TagInfoMgr::getRunNumber ( unsigned int & runNumber )

private

Definition at line 392 of file TagInfoMgr.cxx.

{
    // check if EventSelector is being used to override run numbers if
    // so, we return the runNumber from the properties of the
    // EventSelector
 
    // Get run number parameter from the EventSelector 
    ATH_MSG_DEBUG( "getRunNumber: check if tag is set in jobOpts");
    // Get name of event selector from the application manager to
    // make sure we get the one for MC signal events
    SmartIF<IProperty> appMgr(serviceLocator()->service("ApplicationMgr"));
    ATH_CHECK( appMgr.isValid() );
 
    StringProperty property("EvtSel", "");
    StatusCode sc = appMgr->getProperty(&property);
    if (!sc.isSuccess()) {
        ATH_MSG_ERROR( "getRunNumber: unable to get EvtSel: found " << property.value());
        return StatusCode::FAILURE;
    }
    // Get EventSelector for ApplicationMgr
    std::string eventSelector = property.value();
    SmartIF<IProperty> evtSel(serviceLocator()->service(eventSelector));
    ATH_CHECK( evtSel.isValid() );
 
    BooleanProperty overrideRunNumber = BooleanProperty("OverrideRunNumber", false);
    sc = evtSel->getProperty(&overrideRunNumber);
    if (!sc.isSuccess()) {
        // Not all EventSelectors have this property, but we should
        // not get here if the ES is not one for simulation => return failure
        ATH_MSG_WARNING( "getRunNumber: unable to get OverrideRunNumber property from EventSelector ");
        return StatusCode::FAILURE;
    }
    if (overrideRunNumber.value()) {
        IntegerProperty runNumberProp = IntegerProperty("RunNumber", 0);
        sc = evtSel->getProperty(&runNumberProp);
        if (!sc.isSuccess()) {
            ATH_MSG_ERROR( "getRunNumber: unable to get RunNumber from EventSelector: found " 
                << runNumberProp.value());
            return StatusCode::FAILURE;
        }
        else {
            runNumber = runNumberProp.value();
            ATH_MSG_DEBUG( "getRunNumber: Run number:  "
                  << runNumber << " obtained from "
                  << eventSelector);
        }
    }
    else {
        ATH_MSG_ERROR( "getRunNumber: OverrideRunNumber from EventSelector is false ");
        return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
}

handle()

void TagInfoMgr::handle ( const Incident & incident )

finaloverride

This method is called at the both the BeginRun and BeginInputFile incidents:

1) For the first begin run, we retrieve the TagInfo and set up IOVDbSvc so that is can use TagInfo to define its hierarchical tags. The member m_currentRun is saved to be used for the IOV in fillMetaData.

2) Then whenever a new file is opened (BeginInputFile), we use the TagInfo object from the detector store to "re-fill" and overwrite the newly merged TagInfo meta data in the output meta data store. We receive BeginInputFile AFTER the IOVDbMetaDataTool has done this automatic merging, so that we can safely overwrite with the desired TagInfo information for this job/run. As well, if there is a second BeginRun during the processing, here we update m_currentRun and overwrite again the TagInfo in the
meta store with the new run which will just extend the IOV of the TagInfo meta data.

Definition at line 449 of file TagInfoMgr.cxx.

                                      {

 
    // Get the messaging service, print where you are
    ATH_MSG_DEBUG( "handle: received incident of type " << inc.type()
                   << " from " << inc.source());
 
    const EventIDBase eventID =  inc.context().eventID();
 
    if (inc.type() == IncidentType::BeginRun) {
       // For begin run, reset the current run number
 
       // get conditionsRun from the Context - can be used if no EventID in the SG (for HLT)
       m_conditionsRun = Atlas::getExtendedEventContext(inc.context()).conditionsRun();
 
       // Set current run number to be used for fillMetaData
       m_currentRun = eventID.run_number();
 
       ATH_MSG_DEBUG( "handle: BeginRun incident - Event ID: ["
                      << eventID.run_number()   << ","
                      << eventID.lumi_block() << ":"
                      << eventID.time_stamp() << "] ");
       if( m_conditionsRun != EventIDBase::UNDEFNUM ) {
          ATH_MSG_DEBUG( "handle: conditionsRun = " << m_conditionsRun);
       }
       if( m_currentRun != EventIDBase::UNDEFNUM ) {
          ATH_MSG_DEBUG( "handle: currentRun = " << m_currentRun);
       }
    }
 
    // At first BeginRun we retrieve TagInfo and trigger IOVDbSvc to use it
    if (inc.type() == IncidentType::BeginRun && m_isFirstBeginRun) {
 
        // No longer first BeginRun 
        m_isFirstBeginRun = false; 
 
        // For the moment, we must set IOVDbSvc into the BeginRun
        // state to be able to access TagInfo from the file meta data
 
        // create IOV time from current event coming in with BeginRun incident
        EventIDBase::number_type  run = eventID.run_number();
        EventIDBase::number_type  lb  = eventID.lumi_block();
        IOVTime curTime;
        curTime.setRunEvent(run, lb);
 
        // save both seconds and ns offset for timestamp
        uint64_t nsTime = eventID.time_stamp()*1000000000LL;
        nsTime         += eventID.time_stamp_ns_offset();
        curTime.setTimestamp(nsTime);
 
        if (StatusCode::SUCCESS != m_iovDbSvc->signalBeginRun(curTime, inc.context()))
        {
            ATH_MSG_ERROR( "Unable to signal begin run to IOVDbSvc");
            throw GaudiException( "Unable to signal begin run to IOVDbSvc", "TagInfoMgr::handle", StatusCode::FAILURE );
        }
        ATH_MSG_DEBUG( "Signaled begin run to IOVDbSvc " << curTime);
        
        // For BeginRun, update TagInfo
        if( updateTagInfo().isFailure() ) {
           throw GaudiException( "updateTagInfo ERROR:", "TagInfoMgr::handle", StatusCode::FAILURE );
        }
 
            // May have pre-existing TagInfo with incorrect IOV
            // range. Try dropping and retrieving again.
            //    bool sc = m_iovDbSvc->dropObject("/TagInfo");  //MN: No idea what that was supposed to do
 
    // Process TagInfo by IOVDbSvc
        if (m_iovDbSvc->processTagInfo().isFailure() ) {
           throw GaudiException( "iovDbSvc::processTagInfo ERROR", "TagInfoMgr::handle", StatusCode::FAILURE );
        }
        ATH_MSG_DEBUG( "handle: TagInfo successfully processed by IOVDbSvc to register callback");
        notifyListeners();
    }
    else if ((inc.type() == IncidentType::BeginInputFile || inc.type() == IncidentType::BeginRun)
             && !m_isFirstBeginRun)
    {
       // For a new file incident or a subsequent begin run incident, we must "refill" the meta
       // data store with the current value of the TagInfo folder in the detector store.
       if( updateTagInfo().isFailure() ) {
          throw GaudiException( "updateTagInfo ERROR:", "TagInfoMgr::handle", StatusCode::FAILURE );
       }
       notifyListeners();
    }
}

initialize()

StatusCode TagInfoMgr::initialize ( )

overridevirtual

Definition at line 50 of file TagInfoMgr.cxx.

{
    ATH_CHECK( AthService::initialize() );
 
    // Get the messaging service, print where you are
    ATH_MSG_DEBUG( "initialize()");
    
    if (msgLvl(MSG::DEBUG)) {
        ATH_MSG_DEBUG( "ExtraTagValuePairs " );
        for (auto& tv : m_extraTagValuePairs) {
            ATH_MSG_DEBUG( " Value/tag pair: " << tv.first << " " << tv.second );
        }
    }
 
    // To copy TagInfo to EventInfo, we set listener to the
    // IncidentSvc for BeginRun and BeginInputFile
    ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", name());
 
    // Add BeginRun to trigger tag extraction and writing to output
    // file meta data
    incSvc->addListener( this, "BeginRun", 100);
 
    // Add BeginInputFile to trigger refilling meta data store after a new input file - priority has
    // to be < 50 to be run after IOVDbMetaDataTool (triggered by MetaDataSvc), which is merging
    // the input meta data from the new file into the output file metadata.
    incSvc->addListener(this, "BeginInputFile", 50); // 
 
    return StatusCode::SUCCESS;
}

notifyListeners()

void TagInfoMgr::notifyListeners

(

)

const

Notify all listeners that the Tags were updated.

Definition at line 559 of file TagInfoMgr.cxx.

{
   ATH_MSG_DEBUG( "notifyListeners  (" << m_listeners.size() <<" registered)");
 
   m_mutex.lock_shared();
   // Make a copy to use outside of the lock.
   const std::set<Listener*> listeners = m_listeners;
   m_mutex.unlock_shared();
 
   for( auto listener : listeners ) {
      listener->tagInfoUpdated();
   }
}

operator=()

TagInfoMgr & TagInfoMgr::operator= ( const TagInfoMgr & )

private

printTags()

void TagInfoMgr::printTags ( MsgStream & log ) const

finaloverridevirtual

Printout method.

Definition at line 682 of file TagInfoMgr.cxx.

{
   std::shared_lock guard(m_mutex);
   m_tagInfo.printTags(log);
}

removeListener()

void TagInfoMgr::removeListener ( Listener * listener )

finaloverridevirtual

Remove a Listener from the notification list for TagInfo changes.

Definition at line 697 of file TagInfoMgr.cxx.

{
   std::unique_lock guard(m_mutex);
   m_listeners.erase( listener );
}

removeTagFromInput()

StatusCode TagInfoMgr::removeTagFromInput ( const std::string & tagName )

overridevirtual

Method to allow clients to remove a tag which may have come in on the input.

Definition at line 637 of file TagInfoMgr.cxx.

{
    // Add name/value to input vector
    ATH_MSG_DEBUG( "removeTagFromInput - adding tag name to be removed: " << tagName);
    std::unique_lock  guard( m_mutex );
    m_tagsToBeRemoved.insert(tagName);
    return StatusCode::SUCCESS;
}

start()

StatusCode TagInfoMgr::start ( )

overridevirtual

Definition at line 81 of file TagInfoMgr.cxx.

{
    ATH_MSG_DEBUG( "start()");
    return StatusCode::SUCCESS;
}

updateTagInfo()

StatusCode TagInfoMgr::updateTagInfo

(

)

Update Tags when input tags (/TagInfo in-file metadata) change.

Definition at line 575 of file TagInfoMgr.cxx.

                          {
 
    // Fill the TagInfo object
    //   The tag info may come from either the input file meta data or
    //   the currently available EventInfo object
    ATH_MSG_DEBUG( "updateTagInfo: getting /TagInfo");
 
    // Check whether TagInfo is coming from file meta data or the
    // input event
    const CondAttrListCollection* attrListColl = 0;
    if (m_detStore->contains<CondAttrListCollection>("/TagInfo")) { 
        if (m_detStore->retrieve( attrListColl, "/TagInfo" ).isFailure() ) {
            ATH_MSG_ERROR( "updateTagInfo: No TagInfo meta data in DetectorStore");
            return StatusCode::FAILURE ;
        }
        else {
            ATH_MSG_DEBUG( "updateTagInfo: Retrieved TagInfo meta data from detStore. size " << attrListColl->size());
        }
    }
    else {
        ATH_MSG_DEBUG( "updateTagInfo: det store does NOT contain AttrListColl for TagInfo");
    }
 
    // Fill TagInfo from (file meta data) conditions if they exist. If
    // they are empty, we restore from the saved TagInfo
    // information. Otherwise we fill from from event info (OLD and
    // most likely not used anymore. RDS 08/2012).
    if (attrListColl && attrListColl->size() == 0) {
        ATH_MSG_DEBUG( "updateTagInfo: /TagInfo empty - do nothing");
        ATH_MSG_DEBUG(m_tagInfo.str());
        return StatusCode::SUCCESS;
    }
 
    std::unique_lock guard(m_mutex);
    ATH_CHECK( fillTagInfo(attrListColl) );
    if (attrListColl) ATH_MSG_DEBUG( "updateTagInfo: Filled TagInfo from file meta data ");
    else ATH_MSG_DEBUG( "updateTagInfo: Filled TagInfo from input event ");
    
    // Copy TagInfo to meta data store for writing to file meta data
    ATH_CHECK( fillMetaData(attrListColl) );
    ATH_MSG_DEBUG( "updateTagInfo: Wrote TagInfo to MetaDataStore ");
 
    return StatusCode::SUCCESS;
}

Friends And Related Symbol Documentation

SvcFactory< TagInfoMgr >

friend class SvcFactory< TagInfoMgr >

friend

forward declaration

Definition at line 123 of file TagInfoMgr.h.

Member Data Documentation

ATLAS_THREAD_SAFE

std::shared_mutex m_mutex TagInfoMgr::ATLAS_THREAD_SAFE

mutableprivate

mutex to protect internal data in MT

Definition at line 193 of file TagInfoMgr.h.

m_conditionsRun

EventIDBase::number_type TagInfoMgr::m_conditionsRun { EventIDBase::UNDEFNUM }

private

conditionsRun from the first BeginRun incident (HLT)

Definition at line 178 of file TagInfoMgr.h.

{ EventIDBase::UNDEFNUM };

m_currentRun

EventIDBase::number_type TagInfoMgr::m_currentRun { EventIDBase::UNDEFNUM }

private

current run number from BeginRun incident

Definition at line 181 of file TagInfoMgr.h.

{ EventIDBase::UNDEFNUM };

m_detStore

ServiceHandle<StoreGateSvc> TagInfoMgr::m_detStore { this, "DetectorStore", "DetectorStore" }

private

The detector store.

Definition at line 166 of file TagInfoMgr.h.

{ this, "DetectorStore", "DetectorStore" };

m_extraTagValuePairs

Gaudi::Property<std::map<std::string,std::string> > TagInfoMgr::m_extraTagValuePairs { this, "ExtraTagValuePairs", {}, "key/value pairs to be added" }

private

Extra tags/values pairs added in my jobOptions.

Definition at line 154 of file TagInfoMgr.h.

{ this, "ExtraTagValuePairs", {}, "key/value pairs to be added" };

m_extraTagValuePairsViaInterface

std::map<std::string,std::string> TagInfoMgr::m_extraTagValuePairsViaInterface

private

Extra tags/values pairs added in via interface.

Definition at line 157 of file TagInfoMgr.h.

m_iovDbSvc

ServiceHandle<IIOVDbSvc> TagInfoMgr::m_iovDbSvc { this, "IOVDbSvc", "IOVDbSvc" }

private

Access to IOVDbSvc interface - used to register callback.

Definition at line 169 of file TagInfoMgr.h.

{ this, "IOVDbSvc", "IOVDbSvc" };

m_isFirstBeginRun

bool TagInfoMgr::m_isFirstBeginRun { true }

private

Flag to identify the first BeginRun incident.

Definition at line 175 of file TagInfoMgr.h.

{ true };

m_lastIOVRange

IOVRange TagInfoMgr::m_lastIOVRange { IOVRange(IOVTime(), IOVTime()) }

private

IOVRange of last TagInfo added to the file meta data.

Definition at line 184 of file TagInfoMgr.h.

{ IOVRange(IOVTime(), IOVTime()) };

m_listeners

std::set< Listener* > TagInfoMgr::m_listeners

private

List of listeners notified when the TagInfo changed.

Definition at line 190 of file TagInfoMgr.h.

m_metaDataTool

PublicToolHandle<IIOVDbMetaDataTool> TagInfoMgr::m_metaDataTool { this, "IOVDbMetaDataTool", "IOVDbMetaDataTool" }

private

Access to iov meta data tool.

Definition at line 172 of file TagInfoMgr.h.

{ this, "IOVDbMetaDataTool", "IOVDbMetaDataTool" };

m_storeGate

ServiceHandle<StoreGateSvc> TagInfoMgr::m_storeGate { this, "StoreGateSvc", "StoreGateSvc" }

private

The event store.

Definition at line 163 of file TagInfoMgr.h.

{ this, "StoreGateSvc", "StoreGateSvc" };

m_tagInfo

TagInfo TagInfoMgr::m_tagInfo

private

The Tags.

Definition at line 187 of file TagInfoMgr.h.

m_tagsToBeRemoved

std::set<std::string> TagInfoMgr::m_tagsToBeRemoved

private

Extra tags to be removed.

Definition at line 160 of file TagInfoMgr.h.

---

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

• TagInfoMgr.h
• TagInfoMgr.cxx