The default ATLAS batch event loop manager. More...

#include <AthenaHiveEventLoopMgr.h>

Inheritance diagram for AthenaHiveEventLoopMgr:

Public Types
typedef IEvtSelector::Context	EvtContext
typedef std::list< SmartIF< IAlgorithm > >	ListAlg

Public Member Functions
StatusCode	getEventRoot (IOpaqueAddress *&refpAddr)
	Create event address using event selector.
	AthenaHiveEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
	Standard Constructor.
virtual	~AthenaHiveEventLoopMgr ()
	Standard Destructor.
virtual StatusCode	initialize () override
	implementation of IAppMgrUI::initalize
virtual StatusCode	finalize () override
	implementation of IAppMgrUI::finalize
virtual StatusCode	nextEvent (int maxevt) override
	implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately
virtual StatusCode	executeEvent (EventContext &&ctx) override
	implementation of IEventProcessor::executeEvent(void* par)
virtual StatusCode	executeRun (int maxevt) override
	implementation of IEventProcessor::executeRun(int maxevt)
virtual StatusCode	stopRun () override
	implementation of IEventProcessor::stopRun()
virtual StatusCode	stop () override
	implementation of IService::stop
virtual StatusCode	seek (int evt) override
	Seek to a given event.
virtual int	curEvent () const override
	Return the current event count.
virtual int	size () override
	Return the size of the collection.
virtual void	handle (const Incident &inc) override
	IIncidentListenet interfaces.
virtual const std::string &	name () const override
virtual void	modifyEventContext (EventContext &ctx, const EventID &eID, bool consume_modifier_stream)
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Protected Types
typedef ServiceHandle< IIncidentSvc >	IIncidentSvc_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t
typedef ServiceHandle< IDataManagerSvc >	IDataManagerSvc_t
typedef ServiceHandle< IConversionSvc >	IConversionSvc_t
typedef ServiceHandle< IEvtIdModifierSvc >	IEvtIdModifierSvc_t
typedef EventID::number_type	number_type
typedef IAthenaEvtLoopPreSelectTool	tool_type
typedef ToolHandleArray< tool_type >	tool_store
typedef tool_store::const_iterator	tool_iterator
typedef std::vector< unsigned int >	tool_stats
typedef tool_stats::const_iterator	tool_stats_iterator

Protected Member Functions
void	setupPreSelectTools (Gaudi::Details::PropertyBase &)
	property update handler:sets up the Pre-selection tools
virtual StatusCode	writeHistograms (bool force=false)
	Dump out histograms as needed.
virtual StatusCode	executeAlgorithms ()
	Run the algorithms for the current event.
StatusCode	initializeAlgorithms ()
	Initialize all algorithms and output streams.
StatusCode	clearWBSlot (int evtSlot)
	Clear a slot in the WB.
int	declareEventRootAddress (EventContext &)
	Declare the root address of the event.
virtual EventContext	createEventContext () override
	Create event context.
void	setTimeout (Timeout &instance)
	Set timeout.
void	resetTimeout (Timeout &instance)
	Reset timeout.
Event lifecycle for derived loop managers
Called on the driving thread, in the order declared below; executeEvent() is the reference composition: allocateEventContext() reserves and selects a whiteboard slot. The driver fills the slot and records the context in it (executeEvent() reads the next input event). submitEvent() hands the event to the scheduler. drainScheduler() collects finished events; finishEvent() calls the eventFinished() hook and releases the slot.
EventContext	allocateEventContext (size_t eventNumber)
StatusCode	submitEvent (EventContext &ctx)
	Submit a recorded context; the scheduler receives its own copy.
StatusCode	finishEvent (const EventContext &ctx)
	Finish one scheduler-returned event on the driving thread.
virtual StatusCode	eventFinished (const EventContext &ctx)
	Process an event's result and decide whether the driving loop may continue.
virtual bool	clearStoreOnEndAlgorithms () const
	Batch jobs clear in the algorithm context; external drivers can retain the store until eventFinished() has consumed their result.
int	drainScheduler (int &finishedEvents)
	Drain the scheduler from all actions that may be queued.

Protected Attributes
IIncidentSvc_t	m_incidentSvc
	Reference to the incident service.
StoreGateSvc_t	m_eventStore
	Reference to StoreGateSvc;.
IEvtSelector *	m_evtSelector
	Reference to the Event Selector.
EvtContext *	m_evtContext
	Gaudi event selector Context (may be used as a cursor by the evt selector).
StringProperty	m_evtsel
IDataManagerSvc_t	m_histoDataMgrSvc
	Reference to the Histogram Data Service.
IConversionSvc_t	m_histoPersSvc
IEvtIdModifierSvc_t	m_evtIdModSvc
StringProperty	m_histPersName
number_type	m_currentRun
	current run number
bool	m_firstRun
IntegerProperty	m_failureMode
UnsignedIntegerProperty	m_eventPrintoutInterval
tool_stats	m_toolInvoke
	tool called counter
tool_stats	m_toolReject
	tool returns StatusCode::FAILURE counter
tool_stats	m_toolAccept
	tool returns StatusCode::SUCCESS counter
tool_store	m_tools
	internal tool store
bool	m_requireInputAttributeList {}
	require input attribute list
bool	m_useSecondaryEventNumber {}
	read event number from secondary input
SmartIF< IHiveWhiteBoard >	m_whiteboard
	Reference to the Whiteboard interface.
SmartIF< IAlgResourcePool >	m_algResourcePool
	Reference to the Algorithm resource pool.
SmartIF< IAlgExecStateSvc >	m_aess
	Reference to the Algorithm Execution State Svc.
SmartIF< IProperty >	m_appMgrProperty
	Property interface of ApplicationMgr.
SmartIF< IScheduler >	m_schedulerSvc
	A shortcut for the scheduler.
SmartIF< IIncidentListener >	m_abortEventListener
	Instance of the incident listener waiting for AbortEvent.
std::string	m_schedulerName
	Name of the scheduler to be used.
std::string	m_whiteboardName
	Name of the Whiteboard to be used.
bool	m_scheduledStop
	Scheduled stop of event processing.
bool	m_terminateLoop { false }
unsigned int	m_nev
	events processed
unsigned int	m_proc
bool	m_useTools
bool	m_doEvtHeartbeat
EventContext	m_lastEventContext

Private Member Functions
	AthenaHiveEventLoopMgr ()=delete
	AthenaHiveEventLoopMgr (const AthenaHiveEventLoopMgr &)=delete
AthenaHiveEventLoopMgr &	operator= (const AthenaHiveEventLoopMgr &)=delete
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
unsigned int	m_nevt
unsigned int	m_timeStamp { 0 }
UnsignedIntegerProperty	m_writeInterval
bool	m_writeHists
bool	m_firstEventAlone
unsigned int	m_flmbi
unsigned int	m_timeStampInt
ServiceHandle< Athena::IConditionsCleanerSvc >	m_conditionsCleaner
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

The default ATLAS batch event loop manager.

It loops over input events according to job configuration. Among the main user-settable properties "FailureMode" controls behaviour of event loop depending on return code of Algorithms.

0: all non-SUCCESSes terminate job.
1: (DEFAULT) RECOVERABLE skips to next event, FAILURE terminates job.
2: RECOVERABLE and FAILURE skip to next events

Definition at line 68 of file AthenaHiveEventLoopMgr.h.

Member Typedef Documentation

◆ EvtContext

typedef IEvtSelector::Context AthenaHiveEventLoopMgr::EvtContext

Definition at line 74 of file AthenaHiveEventLoopMgr.h.

◆ IConversionSvc_t

typedef ServiceHandle<IConversionSvc> AthenaHiveEventLoopMgr::IConversionSvc_t

protected

Definition at line 96 of file AthenaHiveEventLoopMgr.h.

◆ IDataManagerSvc_t

typedef ServiceHandle<IDataManagerSvc> AthenaHiveEventLoopMgr::IDataManagerSvc_t

protected

Definition at line 92 of file AthenaHiveEventLoopMgr.h.

◆ IEvtIdModifierSvc_t

typedef ServiceHandle<IEvtIdModifierSvc> AthenaHiveEventLoopMgr::IEvtIdModifierSvc_t

protected

Definition at line 100 of file AthenaHiveEventLoopMgr.h.

◆ IIncidentSvc_t

typedef ServiceHandle<IIncidentSvc> AthenaHiveEventLoopMgr::IIncidentSvc_t

protected

Definition at line 77 of file AthenaHiveEventLoopMgr.h.

◆ ListAlg

typedef std::list<SmartIF<IAlgorithm> > AthenaHiveEventLoopMgr::ListAlg

Definition at line 291 of file AthenaHiveEventLoopMgr.h.

◆ number_type

typedef EventID::number_type AthenaHiveEventLoopMgr::number_type

protected

Definition at line 107 of file AthenaHiveEventLoopMgr.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthenaHiveEventLoopMgr::StoreGateSvc_t

protected

Definition at line 81 of file AthenaHiveEventLoopMgr.h.

◆ tool_iterator

typedef tool_store::const_iterator AthenaHiveEventLoopMgr::tool_iterator

protected

Definition at line 121 of file AthenaHiveEventLoopMgr.h.

◆ tool_stats

typedef std::vector<unsigned int> AthenaHiveEventLoopMgr::tool_stats

protected

Definition at line 122 of file AthenaHiveEventLoopMgr.h.

◆ tool_stats_iterator

typedef tool_stats::const_iterator AthenaHiveEventLoopMgr::tool_stats_iterator

protected

Definition at line 123 of file AthenaHiveEventLoopMgr.h.

◆ tool_store

typedef ToolHandleArray< tool_type > AthenaHiveEventLoopMgr::tool_store

protected

Definition at line 120 of file AthenaHiveEventLoopMgr.h.

◆ tool_type

typedef IAthenaEvtLoopPreSelectTool AthenaHiveEventLoopMgr::tool_type

protected

Definition at line 119 of file AthenaHiveEventLoopMgr.h.

Constructor & Destructor Documentation

◆ AthenaHiveEventLoopMgr() [1/3]

AthenaHiveEventLoopMgr::AthenaHiveEventLoopMgr	(	const std::string &	nam,
		ISvcLocator *	svcLoc )

Standard Constructor.

Definition at line 64 of file AthenaHiveEventLoopMgr.cxx.

  : base_class(nam, svcLoc),
    AthMessaging (nam),
    m_incidentSvc ( "IncidentSvc",  nam ), 
    m_eventStore( "StoreGateSvc", nam ), 
    m_evtSelector(0), m_evtContext(0),
    m_histoDataMgrSvc( "HistogramDataSvc",         nam ), 
    m_histoPersSvc   ( "HistogramPersistencySvc",  nam ), 
    m_evtIdModSvc    ( "",         nam ),
    m_currentRun(0), m_firstRun(true), m_tools(this), m_nevt(0), m_writeHists(false),
    m_nev(0), m_proc(0), m_useTools(false),m_doEvtHeartbeat(false),
    m_conditionsCleaner( "Athena::ConditionsCleanerSvc", nam )
{
  declareProperty("EvtSel", m_evtsel, 
          "Name of Event Selector to use. If empty string (default) "
          "take value from ApplicationMgr");
  declareProperty("HistogramPersistency", m_histPersName="",
          "Histogram persistency technology to use: ROOT, HBOOK, NONE. "
          "By default (empty string) get property value from "
          "ApplicationMgr");
  declareProperty("HistWriteInterval",    m_writeInterval=0 ,
          "histogram write/update interval");
  declareProperty("FailureMode",          m_failureMode=1 , 
          "Controls behaviour of event loop depending on return code of"
          " Algorithms. 0: all non-SUCCESSes terminate job. "
          "1: RECOVERABLE skips to next event, FAILURE terminates job "
          "(DEFAULT). 2: RECOVERABLE and FAILURE skip to next events");
  declareProperty("EventPrintoutInterval", m_eventPrintoutInterval=1,
                  "Print event heartbeat printouts every m_eventPrintoutInterval events");
  declareProperty("PreSelectTools",m_tools,"AlgTools for event pre-selection")->
    declareUpdateHandler( &AthenaHiveEventLoopMgr::setupPreSelectTools, this ); ;
  
  declareProperty("SchedulerSvc", m_schedulerName="ForwardSchedulerSvc",
                  "Name of the scheduler to be used");
  
  declareProperty("WhiteboardSvc", m_whiteboardName="EventDataSvc",
          "Name of the Whiteboard to be used");
 
  declareProperty("EventStore", m_eventStore);
  declareProperty("ConditionsCleanerSvc", m_conditionsCleaner);
 
  declareProperty("EvtIdModifierSvc", m_evtIdModSvc,
                  "ServiceHandle for EvtIdModifierSvc");
 
  declareProperty("FakeLumiBlockInterval", m_flmbi = 0,
                  "Event interval at which to increment lumiBlock# when "
                  "creating events without an EventSelector. Zero means " 
                  "don't increment it");
  declareProperty("FakeTimestampInterval", m_timeStampInt = 1,
                  "timestamp interval between events when creating Events "
                  "without an EventSelector");
  declareProperty("RequireInputAttributeList", m_requireInputAttributeList = false,
                  "Require valid input attribute list to be present");
  declareProperty("UseSecondaryEventNumber", m_useSecondaryEventNumber = false,
                  "In case of DoubleEventSelector use event number from secondary input");
 
  declareProperty("FirstEventAlone", m_firstEventAlone = true,
                  "process all of first event before scheduling any more");
 
  m_scheduledStop = false;
 
}

◆ ~AthenaHiveEventLoopMgr()

AthenaHiveEventLoopMgr::~AthenaHiveEventLoopMgr ( )

virtual

Standard Destructor.

Definition at line 131 of file AthenaHiveEventLoopMgr.cxx.

132{

133}

◆ AthenaHiveEventLoopMgr() [2/3]

AthenaHiveEventLoopMgr::AthenaHiveEventLoopMgr ( )

privatedelete

◆ AthenaHiveEventLoopMgr() [3/3]

AthenaHiveEventLoopMgr::AthenaHiveEventLoopMgr ( const AthenaHiveEventLoopMgr & )

privatedelete

Member Function Documentation

◆ allocateEventContext()

EventContext AthenaHiveEventLoopMgr::allocateEventContext ( size_t eventNumber )

protected

Allocate/select a slot, with an index supplied by the driving loop.

Definition at line 1149 of file AthenaHiveEventLoopMgr.cxx.

                                                                            {
  const size_t slot = m_whiteboard->allocateStore(eventNumber);
  if (slot == std::string::npos) {
    ATH_MSG_ERROR("No free whiteboard slot");
    return EventContext{};
  }
  if (m_whiteboard->selectStore(slot).isFailure()) {
    ATH_MSG_ERROR("Could not select whiteboard slot {}", slot);
    m_whiteboard->freeStore(slot).ignore();
    return EventContext{};
  }
  EventContext ctx{eventNumber, slot};
  Atlas::setExtendedEventContext(
      ctx, Atlas::ExtendedEventContext(m_eventStore->hiveProxyDict()));
  return ctx;
}

◆ clearStoreOnEndAlgorithms()

virtual bool AthenaHiveEventLoopMgr::clearStoreOnEndAlgorithms ( ) const

inlineprotectedvirtual

Batch jobs clear in the algorithm context; external drivers can retain the store until eventFinished() has consumed their result.

Definition at line 198 of file AthenaHiveEventLoopMgr.h.

198{ return true; }

◆ clearWBSlot()

StatusCode AthenaHiveEventLoopMgr::clearWBSlot ( int evtSlot )

protected

Clear a slot in the WB.

Definition at line 1298 of file AthenaHiveEventLoopMgr.cxx.

                                                           {
  return m_whiteboard->freeStore(evtSlot);  
}

◆ createEventContext()

EventContext AthenaHiveEventLoopMgr::createEventContext ( )

overrideprotectedvirtual

Create event context.

Definition at line 1145 of file AthenaHiveEventLoopMgr.cxx.

                                                        {
  return allocateEventContext(m_nevt);
}

◆ curEvent()

int AthenaHiveEventLoopMgr::curEvent ( ) const

overridevirtual

Return the current event count.

Definition at line 796 of file AthenaHiveEventLoopMgr.cxx.

{
  return m_nevt;
}

◆ declareEventRootAddress()

int AthenaHiveEventLoopMgr::declareEventRootAddress ( EventContext & ctx )

protected

Declare the root address of the event.

FIXME ???

Definition at line 924 of file AthenaHiveEventLoopMgr.cxx.

                                                                    {
 
  // return codes:
  //   -1 : error
  //    0 : no more events in selection
  //    1 : ok
  
  StatusCode sc(StatusCode::SUCCESS);
 
  //-----------------------------------------------------------------------
  // we need an EventInfo Object to fire the incidents. 
  //-----------------------------------------------------------------------
  std::unique_ptr<const EventInfo> pEvent{};
  if ( m_evtContext ) {
    // Deal with the case when an EventSelector is provided
    //
    // FIXME: flow control if no more events in selector, etc.
    //
 
    IOpaqueAddress* addr{};
 
    sc = m_evtSelector->next(*m_evtContext);
    
    if ( !sc.isSuccess() ) {
      // This is the end of the loop. No more events in the selection
      ATH_MSG_INFO ( "No more events in event selection " );
      return 0;
    }
    
    if (m_evtSelector->createAddress(*m_evtContext, addr).isFailure()) {
      ATH_MSG_ERROR ( "Could not create an IOpaqueAddress" );
      return -1;
    }
    
      
    // Most iterators provide the IOA of an event header (EventInfo, DataHeader)
    if (0 != addr) {
      //create its proxy
      sc = m_eventStore->recordAddress(addr);
      if( !sc.isSuccess() ) {
    ATH_MSG_WARNING ( "Error declaring Event object" );
    return 0;
      }
    } if ((sc=m_eventStore->loadEventProxies()).isFailure()) {
      ATH_MSG_ERROR ( "Error loading Event proxies" );
      return -1;
    }
 
    bool consume_modifier_stream = false;
    // First try to build a legacy EventInfo object from the TAG information
    // Read the attribute list
    const AthenaAttributeList* pAttrList = m_eventStore->tryConstRetrieve<AthenaAttributeList>("Input");
    if ( pAttrList != nullptr && pAttrList->size() > 6 ) { // Try making EventID-only EventInfo object from in-file TAG
      try {
        unsigned int runNumber = (*pAttrList)["RunNumber"].data<unsigned int>();
        unsigned long long eventNumber = (*pAttrList)["EventNumber"].data<unsigned long long>();
        unsigned int eventTime = (*pAttrList)["EventTime"].data<unsigned int>();
        unsigned int eventTimeNS = (*pAttrList)["EventTimeNanoSec"].data<unsigned int>();
        unsigned int lumiBlock = (*pAttrList)["LumiBlockN"].data<unsigned int>();
        unsigned int bunchId = (*pAttrList)["BunchId"].data<unsigned int>();
 
        ATH_MSG_DEBUG ( "use TAG with runNumber={}", runNumber );
        consume_modifier_stream = true;
        // an option to override primary eventNumber with the secondary one in case of DoubleEventSelector
        if ( m_useSecondaryEventNumber ) {
            unsigned long long eventNumberSecondary{};
            if ( !(pAttrList->exists("hasSecondaryInput") && (*pAttrList)["hasSecondaryInput"].data<bool>()) ) {
                ATH_MSG_FATAL ( "Secondary EventNumber requested, but secondary input does not exist!" );
                return -1;
            }
            if ( pAttrList->exists("EventNumber_secondary") ) {
                eventNumberSecondary = (*pAttrList)["EventNumber_secondary"].data<unsigned long long>();
            }
            else {
                // try legacy EventInfo if secondary input did not have attribute list
                // primary input should not have this EventInfo type
                const EventInfo* pEventSecondary = m_eventStore->tryConstRetrieve<EventInfo>();
                if (pEventSecondary) {
                    eventNumberSecondary = pEventSecondary->event_ID()->event_number();
                }
                else {
                    ATH_MSG_FATAL ( "Secondary EventNumber requested, but it does not exist!" );
                    return -1;
                }
            }
            if (eventNumberSecondary != 0) {
                m_doEvtHeartbeat = (m_eventPrintoutInterval.value() > 0 && 
                  0 == (m_nev % m_eventPrintoutInterval.value()));
                if (m_doEvtHeartbeat) {
                    ATH_MSG_INFO ( "  ===>>>  using secondary event #{} instead of #{}  <<<===",
                                   eventNumberSecondary, eventNumber);
                }
                eventNumber = eventNumberSecondary;
            }
        }
 
        pEvent = std::make_unique<EventInfo>(
            std::make_unique<EventID>(runNumber, eventNumber, eventTime,
                                      eventTimeNS, lumiBlock, bunchId),
            nullptr);
      } catch (...) {
      }
    } else if (m_requireInputAttributeList) {
      ATH_MSG_FATAL ( "Valid input attribute list required but not present!" );
      return -1;
    }
    // In the case that there is no TAG information
    const EventInfo* pEventObserver{pEvent.get()};
    if (!pEventObserver) {
      // Secondly try to retrieve a legacy EventInfo object from the input file
      // Again, m_nevt is incremented after executeEvent in the Hive manager so we don't need a -1
      EventInfoCnvParams::eventIndex = ctx.evt();
      pEventObserver = m_eventStore->tryConstRetrieve<EventInfo>();
      if (pEventObserver) {
        consume_modifier_stream = false; // stream will already have been consumed during EventInfo TP conversion
        ATH_MSG_DEBUG ( "use EventInfo" );
      } else {
        // Finally try to retrieve an xAOD::EventInfo object from the
        // input file and build a legacy EventInfo object from that.
        const xAOD::EventInfo* pXEvent{nullptr};
        sc = m_eventStore->retrieve(pXEvent);
        if( !sc.isSuccess() ) {
          ATH_MSG_ERROR ( "Unable to retrieve Event root object" );
          return -1;
        }
        consume_modifier_stream = true;
        ATH_MSG_DEBUG ( "use xAOD::EventInfo with runNumber={}", pXEvent->runNumber() );
        // Build the old-style Event Info object for those clients that still need it
        pEvent = std::make_unique<EventInfo>(
            std::make_unique<EventID>(eventIDFromxAOD(pXEvent)),
            std::make_unique<EventType>(eventTypeFromxAOD(pXEvent)));
        pEventObserver = pEvent.get();
        sc = m_eventStore->record(std::move(pEvent), "");
        if( !sc.isSuccess() )  {
          ATH_MSG_ERROR ( "Error declaring event data object" );
          return -1;
        }
      }
    }
 
    modifyEventContext(ctx, *(pEventObserver->event_ID()),
                       consume_modifier_stream);
 
  }
  else  {
    // No EventSelector is provided, so with no iterator it's up to us
    // to create an EventInfo
    // first event # == 1
    unsigned int runNmb{1}, evtNmb{m_nevt + 1};
 
    // increment the run/lumiBlock number if desired
    if (m_flmbi != 0) {
      runNmb = m_nevt / m_flmbi + 1;
      evtNmb = m_nevt % m_flmbi + 1;
    }
    auto eid = std::make_unique<EventID> (runNmb,evtNmb, m_timeStamp);
    // Change lumiBlock# to match runNumber
    eid->set_lumi_block( runNmb );
 
    m_timeStamp += m_timeStampInt;
 
    pEvent = std::make_unique<EventInfo>(std::move(eid),
                                         std::make_unique<EventType>());
 
    bool consume_modifier_stream = true;
    // EventInfo TP Conversion not called in this case, so we would
    // want to consume the next IoV from the list in the
    // EvtIdModifierSvc.
    modifyEventContext(ctx,*(pEvent->event_ID()), consume_modifier_stream);
 
    ATH_MSG_DEBUG ( "selecting store: {}", ctx.slot() );
 
    m_whiteboard->selectStore( ctx.slot() ).ignore();
 
    // EventInfo not working with format
    ATH_MSG_DEBUG ( "recording EventInfo " << *pEvent->event_ID() << " in "
            << m_eventStore->name() );
 
    sc = m_eventStore->record(std::move(pEvent), "McEventInfo");
    if( !sc.isSuccess() )  {
      ATH_MSG_ERROR ( "Error declaring event data object" );
      return -1;
    } 
  }
  
  return 1;
}

◆ drainScheduler()

int AthenaHiveEventLoopMgr::drainScheduler ( int & finishedEvents )

protected

Drain the scheduler from all actions that may be queued.

Definition at line 1245 of file AthenaHiveEventLoopMgr.cxx.

                                                       {
 
  StatusCode sc(StatusCode::SUCCESS);
    
  // maybe we can do better
  std::vector<std::unique_ptr<EventContext>> finishedEvtContexts;
 
  EventContext* finishedEvtContext(nullptr);
 
  // Here we wait not to loose cpu resources
  ATH_MSG_DEBUG ( "drainScheduler: [{}] Waiting for a context", finishedEvts);
  sc = m_schedulerSvc->popFinishedEvent(finishedEvtContext);
 
  // We got past it: cache the pointer
  if (sc.isSuccess()){
    // EventContext not working with std::format
    ATH_MSG_DEBUG ( "drainScheduler: scheduler not empty: Context " 
            << finishedEvtContext );
    finishedEvtContexts.emplace_back(finishedEvtContext);
  } else{
    // no more events left in scheduler to be drained
    ATH_MSG_DEBUG ( "drainScheduler: scheduler empty" );
    return 0;
  }
 
  // Let's see if we can pop other event contexts
  while (m_schedulerSvc->tryPopFinishedEvent(finishedEvtContext).isSuccess()){
    finishedEvtContexts.emplace_back(finishedEvtContext);
  }
 
  // Now we flush them
  bool fail(false);
  for (auto& thisFinishedEvtContext : finishedEvtContexts){
    if (!thisFinishedEvtContext) {
      ATH_MSG_FATAL ( "Detected nullptr ctxt while clearing WB!");
      fail = true;
      continue;
    }
 
    if (finishEvent(*thisFinishedEvtContext).isFailure()) {
      fail = true;
    } else {
      ++finishedEvts;
    }
 
  }
 
  return (  fail ? -1 : 1 );
 
}

◆ eventFinished()

StatusCode AthenaHiveEventLoopMgr::eventFinished ( const EventContext & ctx )

protectedvirtual

Process an event's result and decide whether the driving loop may continue.

Reimplemented in MPIHiveEventLoopMgr.

Definition at line 1187 of file AthenaHiveEventLoopMgr.cxx.

                                                                        {
  if (m_aess->eventStatus(ctx) != EventStatus::Success) {
    // EventContext not working with std::format
    ATH_MSG_ERROR("Failed event " << ctx << " with status "
                  << m_aess->eventStatus(ctx));
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

◆ executeAlgorithms()

StatusCode AthenaHiveEventLoopMgr::executeAlgorithms ( )

protectedvirtual

Run the algorithms for the current event.

Definition at line 479 of file AthenaHiveEventLoopMgr.cxx.

                                                     {
 
  return StatusCode::SUCCESS;
}

◆ executeEvent()

StatusCode AthenaHiveEventLoopMgr::executeEvent ( EventContext && ctx )

overridevirtual

implementation of IEventProcessor::executeEvent(void* par)

Fire begin-Run incident if new run:

Definition at line 488 of file AthenaHiveEventLoopMgr.cxx.

{
 
  // An incident may schedule a stop, in which case is better to exit before the actual execution.
  if ( m_scheduledStop ) {
    ATH_MSG_ALWAYS ( "A stopRun was requested by an incidentListener. "
                     "Do not process this event." );
    m_terminateLoop = true;
    return (StatusCode::SUCCESS);
  }
 
  m_aess->reset( ctx );
 
  // Make sure context with slot is set before calling es->next().
  Gaudi::Hive::setCurrentContext ( ctx );
 
  int declEvtRootSc = declareEventRootAddress( ctx );
  if (declEvtRootSc == 0 ) { // We ran out of events!
    m_terminateLoop = true;  // we have finished!
    return StatusCode::SUCCESS;
  } else if ( declEvtRootSc == -1) {
    // No std::format for EventContext
    ATH_MSG_ERROR ( "declareEventRootAddress for context " << ctx << " failed" );
    return StatusCode::FAILURE;
  }
 
  EventID::event_number_t evtNumber = ctx.eventID().event_number();
  unsigned int conditionsRun = ctx.eventID().run_number();
  if (!m_evtIdModSvc.isSet()) {
    const AthenaAttributeList* attr = nullptr;
    if (m_eventStore->contains<AthenaAttributeList> ("Input") &&
        m_eventStore->retrieve(attr, "Input").isSuccess()) {
      if (attr->exists ("ConditionsRun")) {
        conditionsRun = (*attr)["ConditionsRun"].data<unsigned int>();
      }
    }
  }
  Atlas::getExtendedEventContext(ctx).setConditionsRun (conditionsRun);
  Gaudi::Hive::setCurrentContext ( ctx );
 
  // Record EventContext in current whiteboard
  if (m_eventStore->record(std::make_unique<EventContext> (ctx),
                           "EventContext").isFailure())
  {
    ATH_MSG_ERROR ( "Error recording event context object" );
    return (StatusCode::FAILURE);
  }
  if (m_firstRun || (m_currentRun != ctx.eventID().run_number()) ) {
    // Fire EndRun incident unless this is the first run
    if (!m_firstRun) {
      // FIXME!!!
      m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndRun));
    }
    m_firstRun=false;
    m_currentRun = ctx.eventID().run_number();
 
    ATH_MSG_INFO ( "  ===>>>  start of run {}    <<<===", m_currentRun);
 
    // FIXME!!! Fire BeginRun "Incident"
    m_incidentSvc->fireIncident(Incident(name(),IncidentType::BeginRun,ctx));
 
  }
 
  bool toolsPassed=true;
  // CGL: FIXME
  // bool eventFailed = false;
 
  // Call any attached tools to reject events early
  unsigned int toolCtr=0;
  if(m_useTools) {
    tool_store::iterator theTool = m_tools.begin();
    tool_store::iterator lastTool  = m_tools.end();
    while(toolsPassed && theTool!=lastTool ) 
      {
        toolsPassed = (*theTool)->passEvent(ctx.eventID());
    m_toolInvoke[toolCtr]++;
        {toolsPassed ? m_toolAccept[toolCtr]++ : m_toolReject[toolCtr]++;}
        ++toolCtr;
        ++theTool;
      }
  }
 
  m_doEvtHeartbeat = (m_eventPrintoutInterval.value() > 0 && 
         0 == (m_nev % m_eventPrintoutInterval.value()));
  if (m_doEvtHeartbeat)  {
    if(!m_useTools) {
      ATH_MSG_INFO ( "  ===>>>  start processing event #{}, run #{} on slot {},  {} events processed so far  <<<===",
                     evtNumber, m_currentRun, ctx.slot(), m_proc);
    }
    else {
      ATH_MSG_INFO ( "  ===>>>  start processing event #{}, run #{} on slot {},  {} events read and {} events processed so far  <<<===",
                     evtNumber, m_currentRun, ctx.slot(), m_nev, m_proc);
    }
  }
 
  if(toolsPassed) {
 
    if (submitEvent(ctx).isFailure()) {
      m_whiteboard->clearStore(ctx.slot()).ignore();
      clearWBSlot(ctx.slot()).ignore();
      Gaudi::Hive::setCurrentContext(EventContext());
      return StatusCode::FAILURE;
    }
 
  } else {
    ++m_nev;
    ++m_nevt;
  }
 
  // invalidate thread local context once outside of event execute loop
  Gaudi::Hive::setCurrentContext( EventContext() );
 
  return StatusCode::SUCCESS;
 
}

◆ executeRun()

StatusCode AthenaHiveEventLoopMgr::executeRun ( int maxevt )

overridevirtual

implementation of IEventProcessor::executeRun(int maxevt)

Definition at line 609 of file AthenaHiveEventLoopMgr.cxx.

{
 
  StatusCode  sc;
  bool eventfailed = false;
  
  // Call now the nextEvent(...)
  sc = nextEvent(maxevt);
  if (!sc.isSuccess())
    eventfailed = true;
 
  if (eventfailed)
    return StatusCode::FAILURE;
 
  m_incidentSvc->fireIncident(Incident(name(),"EndEvtLoop"));
  return StatusCode::SUCCESS;
}

◆ finalize()

StatusCode AthenaHiveEventLoopMgr::finalize ( )

overridevirtual

implementation of IAppMgrUI::finalize

Reimplemented in MPIHiveEventLoopMgr.

Definition at line 356 of file AthenaHiveEventLoopMgr.cxx.

{
 
  StatusCode sc = MinimalEventLoopMgr::finalize();
  if (sc.isFailure()) 
  {
    ATH_MSG_ERROR ( "Error in Service base class Finalize" );
  }
 
  StatusCode sc2 = writeHistograms(true);
  if (sc2.isFailure()) 
  {
    ATH_MSG_ERROR ( "Error in writing Histograms" );
  }
 
  // Release all interfaces (ignore StatusCodes)
  m_histoDataMgrSvc.release().ignore();
  m_histoPersSvc.release().ignore();
 
  m_whiteboard = 0;
  m_algResourcePool = 0;
  m_schedulerSvc = 0;
  // m_evtDataSvc = 0;
 
  m_incidentSvc.release().ignore();
 
  // Release event selector context
  if ( m_evtSelector && m_evtContext )   {
    m_evtSelector->releaseContext(m_evtContext).ignore();
    //    m_evtSelector   = releaseInterface(m_evtSelector);
    delete m_evtContext; m_evtContext = 0;
  }
 
 
  if(m_useTools) {
    tool_iterator firstTool = m_tools.begin();
    tool_iterator lastTool  = m_tools.end();
    unsigned int toolCtr = 0;
    ATH_MSG_INFO ( "Summary of AthenaEvtLoopPreSelectTool invocation: (invoked/success/failure)" );
    ATH_MSG_INFO ( "-----------------------------------------------------" );
 
    for ( ; firstTool != lastTool; ++firstTool ) {
      ATH_MSG_INFO ( "{:>2}.) {:.<48} ({:>6}/{:>6}/{:>6})",
                     toolCtr+1,
                     (*firstTool)->name(),
                     m_toolInvoke[toolCtr],
                     m_toolAccept[toolCtr],
                     m_toolReject[toolCtr]);
      toolCtr++;
    }
  }
  return ( sc.isFailure() || sc2.isFailure() ) ? StatusCode::FAILURE :
    StatusCode::SUCCESS;
 
}

◆ finishEvent()

StatusCode AthenaHiveEventLoopMgr::finishEvent ( const EventContext & ctx )

protected

Finish one scheduler-returned event on the driving thread.

Calls the result hook with its store selected, then releases the slot even if the hook reports failure. Does not wait for or delete the context.

Definition at line 1197 of file AthenaHiveEventLoopMgr.cxx.

                                                                      {
  StatusCode result = m_whiteboard->selectStore(ctx.slot());
  if (result.isSuccess()) {
    Gaudi::Hive::setCurrentContext(ctx);
    result = eventFinished(ctx);
    m_incidentSvc->fireIncident(
        Incident(name(), IncidentType::EndProcessing, ctx));
  } else {
    ATH_MSG_ERROR("Could not select completed slot {}", ctx.slot());
  }
 
  // Result handling may fail; the event has nevertheless left the scheduler
  // and must relinquish its slot. Successful batch jobs already cleared at
  // EndAlgorithms, but a failed/stalled graph may never fire that incident.
  // Clear failed events here as well so drivers which tolerate failure can
  // reuse the slot without stale EventInfo or payload objects.
  if (!clearStoreOnEndAlgorithms() ||
      m_aess->eventStatus(ctx) != EventStatus::Success) {
    result &= m_whiteboard->clearStore(ctx.slot());
  }
  result &= clearWBSlot(ctx.slot());
  if (result.isFailure()) {
    Gaudi::Hive::setCurrentContext(EventContext());
    return result;
  }
  writeHistograms().ignore();
  ++m_proc;
  if (m_doEvtHeartbeat) {
    const auto n_evt = ctx.eventID().event_number();
    const auto n_run = ctx.eventID().run_number();
    ATH_MSG_INFO("  ===>>>  done processing event #{}, run #{} on slot {}, {} events processed so far <<<===",
                 n_evt, n_run, ctx.slot(), m_proc);
    std::ofstream outfile("eventLoopHeartBeat.txt");
    if (!outfile) {
      ATH_MSG_ERROR("Unable to open eventLoopHeartBeat.txt");
      Gaudi::Hive::setCurrentContext(EventContext());
      return StatusCode::FAILURE;
    }
    std::println(outfile, "  done processing event #{}, run #{} {} events read so far <<<===",
                 n_evt, n_run, m_nev);
  }
  Gaudi::Hive::setCurrentContext(EventContext());
  return StatusCode::SUCCESS;
}

◆ getEventRoot()

StatusCode AthenaHiveEventLoopMgr::getEventRoot ( IOpaqueAddress *& refpAddr )

Create event address using event selector.

Definition at line 902 of file AthenaHiveEventLoopMgr.cxx.

                                                                          {
  refpAddr = 0;
  StatusCode sc = m_evtSelector->next(*m_evtContext);
  if ( !sc.isSuccess() )  {
    return sc;
  }
  // Create root address and assign address to data service
  sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
  if( !sc.isSuccess() )  {
    sc = m_evtSelector->next(*m_evtContext);
    if ( sc.isSuccess() )  {
      sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
      if ( !sc.isSuccess() )  {
        ATH_MSG_WARNING ( "Error creating IOpaqueAddress." );
      }
    }
  }
  return sc;
}

◆ handle()

void AthenaHiveEventLoopMgr::handle ( const Incident & inc )

overridevirtual

IIncidentListenet interfaces.

Definition at line 826 of file AthenaHiveEventLoopMgr.cxx.

{
 
  if(inc.type() == "EndAlgorithms") {
    if (!clearStoreOnEndAlgorithms()) return;
    // Clear the store at the end of the event.
    // Do it here so that it executes in an algorithm context and thus
    // multiple stores can be cleared at the same time.
    StatusCode sc = m_whiteboard->clearStore(inc.context().slot());
    if( !sc.isSuccess() )  {
      ATH_MSG_WARNING ( "Clear of Event data store failed" );
    }
    return;
  }
 
  if(inc.type()!="BeforeFork")
    return;
 
  if(!m_evtContext || !m_firstRun) {
    ATH_MSG_WARNING ( "Skipping BeforeFork handler. Either no event selector is provided or begin run has already passed" );
  }
 
  // Initialize Algorithms and Output Streams
  StatusCode sc = initializeAlgorithms();
  if(sc.isFailure()) {
    ATH_MSG_ERROR ( "Failed to initialize Algorithms" );
    return; 
  }
 
  // Construct EventInfo
  sc = m_evtSelector->next(*m_evtContext);
  if(!sc.isSuccess()) {
    ATH_MSG_INFO ( "No more events in event selection " );
    return;
  }
  IOpaqueAddress* addr{nullptr};
  sc = m_evtSelector->createAddress(*m_evtContext, addr);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "Could not create an IOpaqueAddress" );
    return;
  }
  if (0 != addr) {
    //create its proxy
    sc = m_eventStore->recordAddress(addr);
    if(!sc.isSuccess()) {
      ATH_MSG_ERROR ( "Error declaring Event object" );
      return;
    }
  }
 
  if(m_eventStore->loadEventProxies().isFailure()) {
    ATH_MSG_WARNING ( "Error loading Event proxies" );
    return;
  }
 
  // Retrieve the legacy EventInfo object
  const EventInfo* pEvent{nullptr};
  sc = m_eventStore->retrieve(pEvent);
  if(!sc.isSuccess()) {
    ATH_MSG_ERROR ( "Unable to retrieve Event root object" );
    return;
  }
 
  m_firstRun=false;
  m_currentRun = pEvent->event_ID()->run_number();
 
  // Clear Store
  sc = m_eventStore->clearStore();
  if(!sc.isSuccess()) {
    ATH_MSG_ERROR ( "Clear of Event data store failed" );
  }
}

◆ initialize()

StatusCode AthenaHiveEventLoopMgr::initialize ( )

overridevirtual

implementation of IAppMgrUI::initalize

Reimplemented in MPIHiveEventLoopMgr.

Definition at line 138 of file AthenaHiveEventLoopMgr.cxx.

{
 
  ATH_MSG_INFO ( "Initializing {}", name() );
 
 
  StatusCode sc = MinimalEventLoopMgr::initialize();
  if ( !sc.isSuccess() ) 
  {
    ATH_MSG_ERROR ( "Failed to initialize base class MinimalEventLoopMgr" );
    return sc;
  } 
 
//-------------------------------------------------------------------------
// Setup stuff for hive
//-------------------------------------------------------------------------
 
  m_whiteboard = serviceLocator()->service(m_whiteboardName);
  if( !m_whiteboard.isValid() )  {
    ATH_MSG_FATAL ( "Error retrieving {} interface IHiveWhiteBoard.", m_whiteboardName );
    return StatusCode::FAILURE;
  }
  
  m_schedulerSvc = serviceLocator()->service(m_schedulerName);
  if ( !m_schedulerSvc.isValid()){
    ATH_MSG_FATAL ( "Error retrieving SchedulerSvc interface ISchedulerSvc." );
    return StatusCode::FAILURE;    
  }
  // Setup algorithm resource pool
  m_algResourcePool = serviceLocator()->service("AlgResourcePool");
  if( !m_algResourcePool.isValid() ) {
    ATH_MSG_FATAL ( "Error retrieving AlgResourcePool" );
    return StatusCode::FAILURE;
  }
 
  m_aess = serviceLocator()->service("AlgExecStateSvc");
  if( !m_aess.isValid() ) {
    ATH_MSG_FATAL ( "Error retrieving AlgExecStateSvc" );
    return StatusCode::FAILURE;
  }
 
  sc = m_eventStore.retrieve();
  if( !sc.isSuccess() )  
  {
    ATH_MSG_FATAL ( "Error retrieving pointer to StoreGateSvc" );
    return sc;
  }
 
//--------------------------------------------------------------------------
// Get the references to the services that are needed by the ApplicationMgr 
// itself
//--------------------------------------------------------------------------
  sc = m_incidentSvc.retrieve();
  if( !sc.isSuccess() )  
  {
    ATH_MSG_FATAL ( "Error retrieving IncidentSvc." );
    return sc;
  }
 
//--------------------------------------------------------------------------
// Access Property Manager interface:
//--------------------------------------------------------------------------
  SmartIF<IProperty> prpMgr(serviceLocator());
  if ( !prpMgr.isValid() ) 
  {
    ATH_MSG_FATAL ( "IProperty interface not found in ApplicationMgr." );
    return StatusCode::FAILURE;
  }
 
 
//--------------------------------------------------------------------------
// Set up the Histogram Service
//--------------------------------------------------------------------------
  sc = m_histoDataMgrSvc.retrieve();
  if( !sc.isSuccess() )  
  {
    ATH_MSG_FATAL ( "Error retrieving HistogramDataSvc" );
    return sc;
  }
    
  const std::string& histPersName(m_histPersName.value());
  if ( histPersName.length() == 0 )    
  {
    CHECK(setProperty(prpMgr->getProperty("HistogramPersistency")));
  }
 
  if ( histPersName != "NONE" )   {
 
    m_histoPersSvc = IConversionSvc_t( "HistogramPersistencySvc", 
                       this->name() );
 
    SmartIF<IProperty> histSvc;
    if (histPersName == "ROOT") {
      histSvc = serviceLocator()->service("RootHistSvc");
    } else if ( histPersName == "HBOOK" ) {
      histSvc = serviceLocator()->service("HbookHistSvc");
    }
 
    if (!histSvc) {
      ATH_MSG_ERROR ( "could not locate actual Histogram persistency service" );
    } else {
      const Gaudi::Details::PropertyBase &prop = histSvc->getProperty("OutputFile");
      std::string val;
      try {
        const StringProperty &sprop = dynamic_cast<const StringProperty&>( prop );
        val = sprop.value();
      } catch (...) {
        ATH_MSG_VERBOSE ( "could not dcast OutputFile property to a StringProperty."
                          " Need to fix Gaudi." );
        val = prop.toString();
      }
 
      if (val != "" &&
          val != "UndefinedROOTOutputFileName" &&
          val != "UndefinedHbookOutputFileName" ) {
        m_writeHists = true;
      }
    }
  }  else {
    ATH_MSG_DEBUG ( "Histograms saving not required." );
  }
 
 
//--------------------------------------------------------------------------
// Set up the EventID modifier Service
//--------------------------------------------------------------------------
  if( m_evtIdModSvc.empty() ) {
    ATH_MSG_DEBUG ( "EventID modifier Service not set. No run number, ... overrides will be applied." );
  }
  else if ( !m_evtIdModSvc.retrieve().isSuccess() ) {
    ATH_MSG_INFO ( "Could not find EventID modifier Service. No run number, ... overrides will be applied." );
  }
 
//-------------------------------------------------------------------------
// Setup EventSelector service
//-------------------------------------------------------------------------
  const std::string& selName(m_evtsel.value());
  // the evt sel is usually specified as a property of ApplicationMgr
  if (selName.empty()) 
    sc = setProperty(prpMgr->getProperty("EvtSel"));
  if (sc.isFailure()) ATH_MSG_WARNING ( "Unable to set EvtSel property" );
 
  // We do not expect a Event Selector necessarily being declared
  if( !selName.empty() && selName != "NONE") {
    SmartIF<IEvtSelector> theEvtSel{serviceLocator()->service( selName )};
    if( theEvtSel && ( theEvtSel != m_evtSelector ) ) {
      // Event Selector changed (or setup for the first time)
      m_evtSelector = theEvtSel;
      
      // reset iterator
      if (m_evtSelector->createContext(m_evtContext).isFailure()) {
        ATH_MSG_FATAL ( "Can not create the event selector Context." );
        return StatusCode::FAILURE;
      }
      if (msgLevel(MSG::INFO)) {
        SmartIF<INamedInterface> named(theEvtSel);
        if (named) {
          ATH_MSG_INFO ( "Setup EventSelector service {}", named->name( ) );
        }
      }
    } else if (sc.isFailure()) {
      ATH_MSG_FATAL ( "No valid event selector called {}", selName );
      return StatusCode::FAILURE;
    }
  }  
 
  // Listen to the BeforeFork and EndAlgorithms incidents
  m_incidentSvc->addListener(this,"BeforeFork",0);
  m_incidentSvc->addListener(this, "EndAlgorithms",0);
 
  CHECK( m_conditionsCleaner.retrieve() );
 
  // Print if we override the event number using the one from secondary event
  if (m_useSecondaryEventNumber)
  {
    ATH_MSG_INFO ( "Using secondary event number." );
  }
 
  return sc;
}

◆ initializeAlgorithms()

StatusCode AthenaHiveEventLoopMgr::initializeAlgorithms ( )

protected

Initialize all algorithms and output streams.

Definition at line 471 of file AthenaHiveEventLoopMgr.cxx.

                                                        {
 
  return StatusCode::SUCCESS;
}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ modifyEventContext()

void AthenaHiveEventLoopMgr::modifyEventContext	(	EventContext &	ctx,
		const EventID &	eID,
		bool	consume_modifier_stream )

virtual

Definition at line 1115 of file AthenaHiveEventLoopMgr.cxx.

                                                                                                                   {
 
  if(m_evtIdModSvc.isSet()) {
    EventID new_eID(eID);
    // In Hive EventLoopMgr ctx.evt() gets set to m_nevt and *then* m_nevt is
    // incremented later so it's zero-indexed and we don't need to subtract one
    m_evtIdModSvc->modify_evtid(new_eID, ctx.evt(), consume_modifier_stream);
    if (msgLevel(MSG::DEBUG)) {
      unsigned int oldrunnr=eID.run_number();
      unsigned int oldLB=eID.lumi_block();
      unsigned int oldTS=eID.time_stamp();
      unsigned int oldTSno=eID.time_stamp_ns_offset();
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc runnr={} -> {}",
                      oldrunnr, new_eID.run_number());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc LB={} -> {}",
                      oldLB, new_eID.lumi_block());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp={} -> {}",
                      oldTS, new_eID.time_stamp());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp ns Offset={} -> {}",
                      oldTSno, new_eID.time_stamp_ns_offset());
    }
    ctx.setEventID( new_eID );
    Atlas::getExtendedEventContext(ctx).setConditionsRun( ctx.eventID().run_number() );
    return;
  }
 
  ctx.setEventID( eID );
}

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inline

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 92 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

◆ msg() [2/2]

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

inline

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 99 of file AthMessaging.h.

183{ return msg() << lvl; }

AthenaHiveEventLoopMgr::msg

MsgStream & msg() const

The standard message stream.

Definition AthMessaging.h:167

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inline

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 86 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

◆ name()

virtual const std::string & AthenaHiveEventLoopMgr::name ( ) const

inlineoverridevirtual

Definition at line 255 of file AthenaHiveEventLoopMgr.h.

255{ return Service::name(); } //FIXME

◆ nextEvent()

StatusCode AthenaHiveEventLoopMgr::nextEvent ( int maxevt )

overridevirtual

implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately

Reimplemented in MPIHiveEventLoopMgr.

Definition at line 670 of file AthenaHiveEventLoopMgr.cxx.

{
  // make nextEvent(0) a dummy call
  if (0 == maxevt) return StatusCode::SUCCESS;
 
  // Reset the application return code.
  Gaudi::setAppReturnCode(m_appMgrProperty, Gaudi::ReturnCode::Success, true).ignore();  
 
  int finishedEvts =0;
  int createdEvts =0;
  ATH_MSG_INFO ( "Starting loop on events" );
 
  // loop over events if the maxevt (received as input) is different from -1.
  // if evtmax is -1 it means infinite loop (till time limit that is)
  //  int nevt(0);
  // CGL: FIXME
  // bool noTimeLimit(false);
  bool loop_ended=false;
  StatusCode sc(StatusCode::SUCCESS);
 
  bool newEvtAllowed = ! m_firstEventAlone;
  
  // Calculate runtime
  auto start_time = tbb::tick_count::now();
  auto secsFromStart = [&start_time]()->double{
    return (tbb::tick_count::now()-start_time).seconds();
  };
 
  while ( !loop_ended and ( (maxevt < 0) or (finishedEvts < maxevt) ) ){
 
    ATH_MSG_DEBUG ( " -> createdEvts: {}", createdEvts );
    
    if ( ( !m_terminateLoop ) && // The events are not finished with an unlimited number of events
         (newEvtAllowed || createdEvts == 0) &&       // Launch first event alone
     ( (createdEvts < maxevt) or (maxevt<0) ) &&  // The events are not finished with a limited number of events
     (m_schedulerSvc->freeSlots()>0) ){ // There are still free slots in the scheduler
      
      ATH_MSG_DEBUG ( "createdEvts: {}, freeslots: {}",
                      createdEvts, m_schedulerSvc->freeSlots());
      
      auto ctx = createEventContext();
      
      if ( !ctx.valid() ) {
        sc = StatusCode::FAILURE;
      } else {
        sc = executeEvent( std::move(ctx) );
      }
 
      if (sc.isFailure()) {
    ATH_MSG_ERROR ( "Terminating event processing loop due to errors" );
    loop_ended = true;
      } else {
        ++createdEvts;
      }
 
    } // end if condition createdEvts < maxevt
 
    else { 
      // all the events were created but not all finished or the slots were 
      // all busy: the scheduler should finish its job
 
      ATH_MSG_DEBUG ( "Draining the scheduler" );
 
      // Pull out of the scheduler the finished events
      int ir = drainScheduler(finishedEvts);
      if (ir < 0) {
    // some sort of error draining scheduler;
        loop_ended = true;
    sc = StatusCode::FAILURE;
      } else if (ir == 0) {
    // no more events in scheduler. we're done
    loop_ended = true;
    sc = StatusCode::SUCCESS;
      } else {
    // keep going!
      }
      newEvtAllowed = true;
      
    }
  } // end main loop on finished events  
 
  ATH_MSG_INFO ( "---> Loop Finished (seconds): {}", secsFromStart() );
 
 
  return sc;
 
 
}

◆ operator=()

AthenaHiveEventLoopMgr & AthenaHiveEventLoopMgr::operator= ( const AthenaHiveEventLoopMgr & )

privatedelete

◆ resetTimeout()

void Athena::TimeoutMaster::resetTimeout ( Timeout & instance )

inlineprotectedinherited

Reset timeout.

Definition at line 83 of file Timeout.h.

83{ instance.reset(); }

instance

std::map< std::string, double > instance

Definition Run_To_Get_Tags.h:8

◆ seek()

StatusCode AthenaHiveEventLoopMgr::seek ( int evt )

overridevirtual

Seek to a given event.

Definition at line 764 of file AthenaHiveEventLoopMgr.cxx.

{
  IEvtSelectorSeek* is = dynamic_cast<IEvtSelectorSeek*> (m_evtSelector);
  if (is == 0) {
    ATH_MSG_ERROR ( "Seek failed; unsupported by event selector" );
    return StatusCode::FAILURE;
  }
  //cppcheck-suppress nullPointerRedundantCheck
  if (!m_evtContext) {
    if (m_evtSelector->createContext(m_evtContext).isFailure()) {
      ATH_MSG_FATAL ( "Can not create the event selector Context." );
      return StatusCode::FAILURE;
    }
  }
  //m_evtContext cannot be null if createContext succeeded
  //cppcheck-suppress nullPointerRedundantCheck
  StatusCode sc = is->seek (*m_evtContext, evt);
  if (sc.isSuccess()) {
    m_incidentSvc->fireIncident(ContextIncident<std::tuple<int, int>>(
        name(), "SkipEvents", std::tuple<int, int>(m_nevt, evt)));
    m_nevt = evt;
  }
  else {
    ATH_MSG_ERROR ( "Seek failed." );
  }
  return sc;
}

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

◆ setTimeout()

void Athena::TimeoutMaster::setTimeout ( Timeout & instance )

inlineprotectedinherited

Set timeout.

Definition at line 80 of file Timeout.h.

80{ instance.set(); }

◆ setupPreSelectTools()

void AthenaHiveEventLoopMgr::setupPreSelectTools ( Gaudi::Details::PropertyBase & )

protected

property update handler:sets up the Pre-selection tools

Definition at line 323 of file AthenaHiveEventLoopMgr.cxx.

                                                                     {
 
  m_toolInvoke.clear();
  m_toolReject.clear();
  m_toolAccept.clear();
 
  m_tools.retrieve().ignore();
  if(m_tools.size() > 0) {
    m_useTools=true;
    m_toolInvoke.resize(m_tools.size());
    m_toolReject.resize(m_tools.size());
    m_toolAccept.resize(m_tools.size());
 
    tool_iterator firstTool = m_tools.begin();
    tool_iterator lastTool  = m_tools.end();
    unsigned int toolCtr = 0;
    for ( ; firstTool != lastTool; ++firstTool )
      {
    // reset statistics
    m_toolInvoke[toolCtr] = 0;
    m_toolReject[toolCtr] = 0;
    m_toolAccept[toolCtr] = 0;
        toolCtr++;
      }
  }
 
  return;
 
}

◆ size()

int AthenaHiveEventLoopMgr::size ( )

overridevirtual

Return the size of the collection.

Definition at line 804 of file AthenaHiveEventLoopMgr.cxx.

{
  IEvtSelectorSeek* cs = dynamic_cast<IEvtSelectorSeek*> (m_evtSelector);
  if (cs == 0) {
    ATH_MSG_ERROR ( "Collection size unsupported by event selector" );
    return -1;
  }
  //cppcheck-suppress nullPointerRedundantCheck
  if (!m_evtContext) {
    if (m_evtSelector->createContext(m_evtContext).isFailure()) {
      ATH_MSG_FATAL ( "Can not create the event selector Context." );
      return -1;
    }
  }
  //m_evtContext cannot be null if createContext succeeded
  //cppcheck-suppress nullPointerRedundantCheck
  return cs->size (*m_evtContext);
}

◆ stop()

StatusCode AthenaHiveEventLoopMgr::stop ( )

overridevirtual

implementation of IService::stop

Definition at line 644 of file AthenaHiveEventLoopMgr.cxx.

{
  // To enable conditions access during stop we set an invalid EventContext
  // (no event/slot number) but with valid EventID (and extended EventContext).
  m_lastEventContext.setValid(false);
  Gaudi::Hive::setCurrentContext( m_lastEventContext );
 
  StatusCode sc = MinimalEventLoopMgr::stop();
 
  // If we exit the event loop early due to an error, some event stores
  // may not have been cleared.  This can lead to segfaults later,
  // as DetectorStore will usually get finalized before HiveSvcMgr.
  // So make sure that all stores have been cleared at this point.
  size_t nslot = m_whiteboard ? m_whiteboard->getNumberOfStores() : 0;
  for (size_t islot = 0; islot < nslot; islot++) {
    sc &= clearWBSlot (islot);
  }
 
  Gaudi::Hive::setCurrentContext( EventContext() );
  return sc;
}

◆ stopRun()

StatusCode AthenaHiveEventLoopMgr::stopRun ( )

overridevirtual

implementation of IEventProcessor::stopRun()

Definition at line 629 of file AthenaHiveEventLoopMgr.cxx.

                                           {
  // Set the application return code
  SmartIF<IProperty> appmgr(serviceLocator());
  if(Gaudi::setAppReturnCode(appmgr, Gaudi::ReturnCode::ScheduledStop, true).isFailure()) {
    ATH_MSG_ERROR ( "Could not set return code of the application ({})",
                    Gaudi::ReturnCode::ScheduledStop);
  }
  m_scheduledStop = true;
  return StatusCode::SUCCESS;
}

◆ submitEvent()

StatusCode AthenaHiveEventLoopMgr::submitEvent ( EventContext & ctx )

protected

Submit a recorded context; the scheduler receives its own copy.

On success ctx is invalidated, as the scheduler now owns the slot. On failure ctx stays valid and the caller still owns the slot; no scheduler context is leaked and BeginProcessing is balanced.

Definition at line 1166 of file AthenaHiveEventLoopMgr.cxx.

                                                                {
  CHECK(m_conditionsCleaner->event(ctx, true));
  resetTimeout(Athena::Timeout::instance(ctx));
  m_lastEventContext = ctx;
 
  auto submitted = std::make_unique<EventContext>(ctx);
  m_incidentSvc->fireIncident(
      Incident(name(), IncidentType::BeginProcessing, ctx));
  if (m_schedulerSvc->pushNewEvent(submitted.get()).isFailure()) {
    m_incidentSvc->fireIncident(
        Incident(name(), IncidentType::EndProcessing, ctx));
    ATH_MSG_ERROR("Scheduler refused event {}", ctx.evt());
    return StatusCode::FAILURE;
  }
  submitted.release(); // Ownership transferred to the scheduler.
  ++m_nev;
  ++m_nevt;
  ctx = EventContext();
  return StatusCode::SUCCESS;
}

◆ writeHistograms()

StatusCode AthenaHiveEventLoopMgr::writeHistograms ( bool force = false )

protectedvirtual

Dump out histograms as needed.

Definition at line 415 of file AthenaHiveEventLoopMgr.cxx.

                                                             {
 
  StatusCode sc (StatusCode::SUCCESS);
  
  if ( 0 != m_histoPersSvc && m_writeHists ) {
    std::vector<DataObject*> objects;
    sc = m_histoDataMgrSvc->traverseTree( [&objects]( IRegistry* reg, int ) {
        DataObject* obj = reg->object();
        if ( !obj || obj->clID() == CLID_StatisticsFile ) return false;
        objects.push_back( obj );
        return true;
      } );
 
    if ( !sc.isSuccess() ) {
      ATH_MSG_ERROR ( "Error while traversing Histogram data store" );
      return sc;
    }
 
    if ( objects.size() > 0) {
      int writeInterval(m_writeInterval.value());
 
      if ( m_nevt == 1 || force || 
           (writeInterval != 0 && m_nevt%writeInterval == 0) ) {
 
        // skip /stat entry!
        sc = std::accumulate( begin( objects ), end( objects ), sc, [&]( StatusCode isc, auto& i ) {
            IOpaqueAddress* pAddr = nullptr;
            StatusCode      iret  = m_histoPersSvc->createRep( i, pAddr );
            if ( iret.isFailure() ) return iret;
            i->registry()->setAddress( pAddr );
            return isc;
          } );
        sc = std::accumulate( begin( objects ), end( objects ), sc, [&]( StatusCode isc, auto& i ) {
            IRegistry* reg  = i->registry();
            StatusCode iret = m_histoPersSvc->fillRepRefs( reg->address(), i );
            return iret.isFailure() ? iret : isc;
          } );
        if ( ! sc.isSuccess() ) {
          ATH_MSG_ERROR ( "Error while saving Histograms." );
        }
      }
 
      if (force || (writeInterval != 0 && m_nevt%writeInterval == 0) ) {
        ATH_MSG_DEBUG ( "committing Histograms" );
        m_histoPersSvc->conversionSvc()->commitOutput("",true).ignore();
      }
    }
          
  }
  
  return sc;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

◆ m_abortEventListener

SmartIF< IIncidentListener > AthenaHiveEventLoopMgr::m_abortEventListener

protected

Instance of the incident listener waiting for AbortEvent.

Definition at line 203 of file AthenaHiveEventLoopMgr.h.

◆ m_aess

SmartIF<IAlgExecStateSvc> AthenaHiveEventLoopMgr::m_aess

protected

Reference to the Algorithm Execution State Svc.

Definition at line 160 of file AthenaHiveEventLoopMgr.h.

◆ m_algResourcePool

SmartIF<IAlgResourcePool> AthenaHiveEventLoopMgr::m_algResourcePool

protected

Reference to the Algorithm resource pool.

Definition at line 157 of file AthenaHiveEventLoopMgr.h.

◆ m_appMgrProperty

SmartIF<IProperty> AthenaHiveEventLoopMgr::m_appMgrProperty

protected

Property interface of ApplicationMgr.

Definition at line 163 of file AthenaHiveEventLoopMgr.h.

◆ m_conditionsCleaner

ServiceHandle<Athena::IConditionsCleanerSvc> AthenaHiveEventLoopMgr::m_conditionsCleaner

private

Definition at line 297 of file AthenaHiveEventLoopMgr.h.

◆ m_currentRun

number_type AthenaHiveEventLoopMgr::m_currentRun

protected

current run number

Definition at line 109 of file AthenaHiveEventLoopMgr.h.

◆ m_doEvtHeartbeat

bool AthenaHiveEventLoopMgr::m_doEvtHeartbeat

protected

Definition at line 278 of file AthenaHiveEventLoopMgr.h.

◆ m_eventPrintoutInterval

UnsignedIntegerProperty AthenaHiveEventLoopMgr::m_eventPrintoutInterval

protected

Definition at line 116 of file AthenaHiveEventLoopMgr.h.

◆ m_eventStore

StoreGateSvc_t AthenaHiveEventLoopMgr::m_eventStore

protected

Reference to StoreGateSvc;.

Property

Definition at line 83 of file AthenaHiveEventLoopMgr.h.

◆ m_evtContext

EvtContext* AthenaHiveEventLoopMgr::m_evtContext

protected

Gaudi event selector Context (may be used as a cursor by the evt selector).

Definition at line 88 of file AthenaHiveEventLoopMgr.h.

◆ m_evtIdModSvc

IEvtIdModifierSvc_t AthenaHiveEventLoopMgr::m_evtIdModSvc

protected

Definition at line 102 of file AthenaHiveEventLoopMgr.h.

◆ m_evtsel

StringProperty AthenaHiveEventLoopMgr::m_evtsel

protected

Definition at line 90 of file AthenaHiveEventLoopMgr.h.

◆ m_evtSelector

IEvtSelector* AthenaHiveEventLoopMgr::m_evtSelector

protected

Reference to the Event Selector.

Definition at line 86 of file AthenaHiveEventLoopMgr.h.

◆ m_failureMode

IntegerProperty AthenaHiveEventLoopMgr::m_failureMode

protected

Definition at line 113 of file AthenaHiveEventLoopMgr.h.

◆ m_firstEventAlone

bool AthenaHiveEventLoopMgr::m_firstEventAlone

private

Definition at line 285 of file AthenaHiveEventLoopMgr.h.

◆ m_firstRun

bool AthenaHiveEventLoopMgr::m_firstRun

protected

Definition at line 110 of file AthenaHiveEventLoopMgr.h.

◆ m_flmbi

unsigned int AthenaHiveEventLoopMgr::m_flmbi

private

Definition at line 287 of file AthenaHiveEventLoopMgr.h.

◆ m_histoDataMgrSvc

IDataManagerSvc_t AthenaHiveEventLoopMgr::m_histoDataMgrSvc

protected

Reference to the Histogram Data Service.

Definition at line 94 of file AthenaHiveEventLoopMgr.h.

◆ m_histoPersSvc

IConversionSvc_t AthenaHiveEventLoopMgr::m_histoPersSvc

protected

Definition at line 98 of file AthenaHiveEventLoopMgr.h.

◆ m_histPersName

StringProperty AthenaHiveEventLoopMgr::m_histPersName

protected

Definition at line 105 of file AthenaHiveEventLoopMgr.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_incidentSvc

IIncidentSvc_t AthenaHiveEventLoopMgr::m_incidentSvc

protected

Reference to the incident service.

Definition at line 79 of file AthenaHiveEventLoopMgr.h.

◆ m_lastEventContext

EventContext AthenaHiveEventLoopMgr::m_lastEventContext

protected

Definition at line 282 of file AthenaHiveEventLoopMgr.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

◆ m_nev

unsigned int AthenaHiveEventLoopMgr::m_nev

protected

events processed

Definition at line 275 of file AthenaHiveEventLoopMgr.h.

◆ m_nevt

unsigned int AthenaHiveEventLoopMgr::m_nevt

private

Definition at line 264 of file AthenaHiveEventLoopMgr.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_proc

unsigned int AthenaHiveEventLoopMgr::m_proc

protected

Definition at line 276 of file AthenaHiveEventLoopMgr.h.

◆ m_requireInputAttributeList

bool AthenaHiveEventLoopMgr::m_requireInputAttributeList {}

protected

require input attribute list

Definition at line 134 of file AthenaHiveEventLoopMgr.h.

134{};

◆ m_scheduledStop

bool AthenaHiveEventLoopMgr::m_scheduledStop

protected

Scheduled stop of event processing.

Definition at line 209 of file AthenaHiveEventLoopMgr.h.

◆ m_schedulerName

std::string AthenaHiveEventLoopMgr::m_schedulerName

protected

Name of the scheduler to be used.

Definition at line 205 of file AthenaHiveEventLoopMgr.h.

◆ m_schedulerSvc

SmartIF<IScheduler> AthenaHiveEventLoopMgr::m_schedulerSvc

protected

A shortcut for the scheduler.

Definition at line 166 of file AthenaHiveEventLoopMgr.h.

◆ m_terminateLoop

bool AthenaHiveEventLoopMgr::m_terminateLoop { false }

protected

Definition at line 273 of file AthenaHiveEventLoopMgr.h.

273{ false };

◆ m_timeStamp

unsigned int AthenaHiveEventLoopMgr::m_timeStamp { 0 }

private

Definition at line 265 of file AthenaHiveEventLoopMgr.h.

265{ 0 };

◆ m_timeStampInt

unsigned int AthenaHiveEventLoopMgr::m_timeStampInt

private

Definition at line 287 of file AthenaHiveEventLoopMgr.h.

◆ m_toolAccept

tool_stats AthenaHiveEventLoopMgr::m_toolAccept

protected

tool returns StatusCode::SUCCESS counter

Definition at line 127 of file AthenaHiveEventLoopMgr.h.

◆ m_toolInvoke

tool_stats AthenaHiveEventLoopMgr::m_toolInvoke

protected

tool called counter

Definition at line 125 of file AthenaHiveEventLoopMgr.h.

◆ m_toolReject

tool_stats AthenaHiveEventLoopMgr::m_toolReject

protected

tool returns StatusCode::FAILURE counter

Definition at line 126 of file AthenaHiveEventLoopMgr.h.

◆ m_tools

tool_store AthenaHiveEventLoopMgr::m_tools

protected

internal tool store

Definition at line 128 of file AthenaHiveEventLoopMgr.h.

◆ m_useSecondaryEventNumber

bool AthenaHiveEventLoopMgr::m_useSecondaryEventNumber {}

protected

read event number from secondary input

Definition at line 137 of file AthenaHiveEventLoopMgr.h.

137{};

◆ m_useTools

bool AthenaHiveEventLoopMgr::m_useTools

protected

Definition at line 277 of file AthenaHiveEventLoopMgr.h.

◆ m_whiteboard

SmartIF<IHiveWhiteBoard> AthenaHiveEventLoopMgr::m_whiteboard

protected

Reference to the Whiteboard interface.

Definition at line 154 of file AthenaHiveEventLoopMgr.h.

◆ m_whiteboardName

std::string AthenaHiveEventLoopMgr::m_whiteboardName

protected

Name of the Whiteboard to be used.

Definition at line 207 of file AthenaHiveEventLoopMgr.h.

◆ m_writeHists

bool AthenaHiveEventLoopMgr::m_writeHists

private

Definition at line 268 of file AthenaHiveEventLoopMgr.h.

◆ m_writeInterval

UnsignedIntegerProperty AthenaHiveEventLoopMgr::m_writeInterval

private

Definition at line 267 of file AthenaHiveEventLoopMgr.h.

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ EvtContext

◆ IConversionSvc_t

◆ IDataManagerSvc_t

◆ IEvtIdModifierSvc_t

◆ IIncidentSvc_t

◆ ListAlg

◆ number_type

◆ StoreGateSvc_t

◆ tool_iterator

◆ tool_stats

◆ tool_stats_iterator

◆ tool_store

◆ tool_type

Constructor & Destructor Documentation

◆ AthenaHiveEventLoopMgr() [1/3]

◆ ~AthenaHiveEventLoopMgr()

◆ AthenaHiveEventLoopMgr() [2/3]

◆ AthenaHiveEventLoopMgr() [3/3]

Member Function Documentation

◆ allocateEventContext()

◆ clearStoreOnEndAlgorithms()

◆ clearWBSlot()

◆ createEventContext()

◆ curEvent()

◆ declareEventRootAddress()

◆ drainScheduler()

◆ eventFinished()

◆ executeAlgorithms()

◆ executeEvent()

◆ executeRun()

◆ finalize()

◆ finishEvent()

◆ getEventRoot()

◆ handle()

◆ initialize()

◆ initializeAlgorithms()

◆ initMessaging()

◆ modifyEventContext()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ name()

◆ nextEvent()

◆ operator=()

◆ resetTimeout()

◆ seek()

◆ setLevel()

◆ setTimeout()

◆ setupPreSelectTools()

◆ size()

◆ stop()

◆ stopRun()

◆ submitEvent()

◆ writeHistograms()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_abortEventListener

◆ m_aess

◆ m_algResourcePool

◆ m_appMgrProperty

◆ m_conditionsCleaner

◆ m_currentRun

◆ m_doEvtHeartbeat

◆ m_eventPrintoutInterval

◆ m_eventStore

◆ m_evtContext

◆ m_evtIdModSvc

◆ m_evtsel

◆ m_evtSelector

◆ m_failureMode

◆ m_firstEventAlone