AthenaMtesEventLoopMgr Class Reference

#include <AthenaMtesEventLoopMgr.h>

Inheritance diagram for AthenaMtesEventLoopMgr:

Collaboration diagram for AthenaMtesEventLoopMgr:

Classes
struct	RangeStruct

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. More...
	AthenaMtesEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
	Standard Constructor. More...
virtual	~AthenaMtesEventLoopMgr ()
	Standard Destructor. More...
virtual StatusCode	initialize () override
	implementation of IAppMgrUI::initalize More...
virtual StatusCode	finalize () override
	implementation of IAppMgrUI::finalize More...
virtual StatusCode	nextEvent (int maxevt) override
	implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately More...
virtual EventContext	createEventContext () override
	implementation of IEventProcessor::createEventContext() More...
virtual StatusCode	executeEvent (EventContext &&ctx) override
	implementation of IEventProcessor::executeEvent(void* par) More...
virtual StatusCode	executeRun (int maxevt) override
	implementation of IEventProcessor::executeRun(int maxevt) More...
virtual StatusCode	stopRun () override
	implementation of IEventProcessor::stopRun() More...
virtual StatusCode	stop () override
	implementation of IService::stop More...
virtual StatusCode	seek (int evt) override
	Seek to a given event. More...
virtual int	curEvent () const override
	Return the current event count. More...
virtual int	size () override
	Return the size of the collection. More...
virtual void	handle (const Incident &inc) override
	IIncidentListenet interfaces. More...
virtual void	resetAppReturnCode () override
	Reset the application return code. More...
virtual void	setCurrentEventNum (int num) override
virtual bool	terminateLoop () override
virtual int	drainScheduler (int &finishedEvents, bool report) override
	Drain the scheduler from all actions that may be queued. More...
virtual const std::string &	name () const override

Public Attributes
StringArrayProperty	m_testPilotMessages
bool	m_inTestMode { false }

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 More...
void	setClearStorePolicy (Gaudi::Details::PropertyBase &clearStorePolicy)
	property update handler:set the clear-store policy value and check its value. More...
virtual StatusCode	writeHistograms (bool force=false)
	Dump out histograms as needed. More...
virtual StatusCode	executeAlgorithms ()
	Run the algorithms for the current event. More...
StatusCode	initializeAlgorithms ()
	Initialize all algorithms and output streams. More...
StatusCode	clearWBSlot (int evtSlot)
	Clear a slot in the WB. More...
int	declareEventRootAddress (EventContext &)
	Declare the root address of the event. More...
void	setTimeout (Timeout &instance)
	Set timeout. More...
void	resetTimeout (Timeout &instance)
	Reset timeout. More...

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

Private Member Functions
	AthenaMtesEventLoopMgr ()=delete
	AthenaMtesEventLoopMgr (const AthenaMtesEventLoopMgr &)=delete
AthenaMtesEventLoopMgr &	operator= (const AthenaMtesEventLoopMgr &)=delete
StoreGateSvc *	eventStore () const
void	modifyEventContext (EventContext &ctx, const EventID &eID, bool consume_modifier_stream)
std::unique_ptr< RangeStruct >	getNextRange (yampl::ISocket *socket)
void	trimRangeStrings (std::string &str)

Private Attributes
unsigned int	m_nevt
unsigned int	m_timeStamp { 0 }
UnsignedIntegerProperty	m_writeInterval
bool	m_writeHists
bool	m_terminateLoop { false }
unsigned int	m_nev
	events processed More...
unsigned int	m_proc
bool	m_useTools
bool	m_doEvtHeartbeat
unsigned int	m_flmbi
unsigned int	m_timeStampInt
ServiceHandle< Athena::IConditionsCleanerSvc >	m_conditionsCleaner
EventContext	m_lastEventContext
ServiceHandle< OutputStreamSequencerSvc >	m_outSeqSvc
Gaudi::Property< std::string >	m_eventRangeChannel
std::string	m_pfn {""}
std::unique_ptr< yampl::ISocket >	m_socket

Detailed Description

Definition at line 50 of file AthenaMtesEventLoopMgr.h.

Member Typedef Documentation

EvtContext

typedef IEvtSelector::Context AthenaMtesEventLoopMgr::EvtContext

Definition at line 58 of file AthenaMtesEventLoopMgr.h.

IConversionSvc_t

typedef ServiceHandle<IConversionSvc> AthenaMtesEventLoopMgr::IConversionSvc_t

protected

Definition at line 80 of file AthenaMtesEventLoopMgr.h.

IDataManagerSvc_t

typedef ServiceHandle<IDataManagerSvc> AthenaMtesEventLoopMgr::IDataManagerSvc_t

protected

Definition at line 76 of file AthenaMtesEventLoopMgr.h.

IEvtIdModifierSvc_t

typedef ServiceHandle<IEvtIdModifierSvc> AthenaMtesEventLoopMgr::IEvtIdModifierSvc_t

protected

Definition at line 84 of file AthenaMtesEventLoopMgr.h.

IIncidentSvc_t

typedef ServiceHandle<IIncidentSvc> AthenaMtesEventLoopMgr::IIncidentSvc_t

protected

Definition at line 61 of file AthenaMtesEventLoopMgr.h.

ListAlg

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

Definition at line 249 of file AthenaMtesEventLoopMgr.h.

number_type

typedef EventID::number_type AthenaMtesEventLoopMgr::number_type

protected

Definition at line 91 of file AthenaMtesEventLoopMgr.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthenaMtesEventLoopMgr::StoreGateSvc_t

protected

Definition at line 65 of file AthenaMtesEventLoopMgr.h.

tool_iterator

typedef tool_store::const_iterator AthenaMtesEventLoopMgr::tool_iterator

protected

Definition at line 105 of file AthenaMtesEventLoopMgr.h.

tool_stats

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

protected

Definition at line 106 of file AthenaMtesEventLoopMgr.h.

tool_stats_iterator

typedef tool_stats::const_iterator AthenaMtesEventLoopMgr::tool_stats_iterator

protected

Definition at line 107 of file AthenaMtesEventLoopMgr.h.

tool_store

typedef ToolHandleArray< tool_type > AthenaMtesEventLoopMgr::tool_store

protected

Definition at line 104 of file AthenaMtesEventLoopMgr.h.

tool_type

typedef IAthenaEvtLoopPreSelectTool AthenaMtesEventLoopMgr::tool_type

protected

Definition at line 103 of file AthenaMtesEventLoopMgr.h.

Constructor & Destructor Documentation

AthenaMtesEventLoopMgr() [1/3]

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

Standard Constructor.

Definition at line 75 of file AthenaMtesEventLoopMgr.cxx.

  : base_class(nam, svcLoc)
  , m_incidentSvc ( "IncidentSvc",  nam )
  , m_eventStore( "StoreGateSvc", nam )
  , m_evtSelector{nullptr}
  , m_evtContext{nullptr}
  , 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 )
  , m_outSeqSvc("OutputStreamSequencerSvc", 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("ClearStorePolicy",
          m_clearStorePolicy = "EndEvent",
          "Configure the policy wrt handling of when the "
          "'clear-the-event-store' event shall happen: at EndEvent "
          "(default as it is makes things easier for memory management"
          ") or at BeginEvent (easier e.g. for interactive use)");
  declareProperty("PreSelectTools",m_tools,"AlgTools for event pre-selection")->
    declareUpdateHandler( &AthenaMtesEventLoopMgr::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("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("ESTestPilotMessages", m_testPilotMessages, "List of messages from fake pilot for test mode");
 
  m_scheduledStop = false;
 
}

~AthenaMtesEventLoopMgr()

AthenaMtesEventLoopMgr::~AthenaMtesEventLoopMgr ( )

virtual

Standard Destructor.

Definition at line 151 of file AthenaMtesEventLoopMgr.cxx.

{
}

AthenaMtesEventLoopMgr() [2/3]

AthenaMtesEventLoopMgr::AthenaMtesEventLoopMgr ( )

privatedelete

AthenaMtesEventLoopMgr() [3/3]

AthenaMtesEventLoopMgr::AthenaMtesEventLoopMgr ( const AthenaMtesEventLoopMgr &  )

privatedelete

Member Function Documentation

clearWBSlot()

StatusCode AthenaMtesEventLoopMgr::clearWBSlot ( int  evtSlot )

protected

Clear a slot in the WB.

Definition at line 1388 of file AthenaMtesEventLoopMgr.cxx.

                                                           {
  StatusCode sc = m_whiteboard->clearStore(evtSlot);
  if( !sc.isSuccess() )  {
    warning() << "Clear of Event data store failed" << endmsg;    
  }
  return m_whiteboard->freeStore(evtSlot);  
}

createEventContext()

EventContext AthenaMtesEventLoopMgr::createEventContext ( )

overridevirtual

implementation of IEventProcessor::createEventContext()

Definition at line 1222 of file AthenaMtesEventLoopMgr.cxx.

                                                        {
 
  EventContext ctx{ m_nevt, m_whiteboard->allocateStore( m_nevt ) };
 
  StatusCode sc = m_whiteboard->selectStore( ctx.slot() );
  if (sc.isFailure()) {
    fatal() << "Slot " << ctx.slot()
            << " could not be selected for the WhiteBoard" << endmsg;
    return EventContext{};       // invalid EventContext
  } else {
    Atlas::setExtendedEventContext(ctx, Atlas::ExtendedEventContext( eventStore()->hiveProxyDict() ) );
 
    debug() << "created EventContext, num: " << ctx.evt()  << "  in slot: " 
        << ctx.slot() << endmsg;
  }
 
  return ctx;
}

curEvent()

int AthenaMtesEventLoopMgr::curEvent ( ) const

overridevirtual

Return the current event count.

Definition at line 879 of file AthenaMtesEventLoopMgr.cxx.

{
  return m_nevt;
}

declareEventRootAddress()

int AthenaMtesEventLoopMgr::declareEventRootAddress ( EventContext &  ctx )

protected

Declare the root address of the event.

FIXME ???

Definition at line 999 of file AthenaMtesEventLoopMgr.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 = 0;
    
    IEvtSelectorSeek* is = dynamic_cast<IEvtSelectorSeek*> (m_evtSelector);
    if (is == 0) {
      error() << "Seek failed; unsupported by event selector" << endmsg;
      return 0;
    }
 
    sc = is->seek (*m_evtContext, m_currentEvntNum-1);
    if(sc.isFailure()) {
      error() << "Seek failed to Evt=" << m_currentEvntNum-1 << endmsg;
      return 0;
    }
 
    sc = m_evtSelector->next(*m_evtContext);
    
    if ( !sc.isSuccess() ) {
      // This is the end of the loop. No more events in the selection
      info() << "No more events in event selection " << endmsg;
      return 0;
    }
    
    if (m_evtSelector->createAddress(*m_evtContext, addr).isFailure()) {
      error() << "Could not create an IOpaqueAddress" << endmsg;
      return -1;
    }
    
      
    // Most iterators provide the IOA of an event header (EventInfo, DataHeader)
    if (0 != addr) {
      //create its proxy
      sc = eventStore()->recordAddress(addr);
      if( !sc.isSuccess() ) {
    warning() << "Error declaring Event object" << endmsg;
    return 0;
      }
    } if ((sc=eventStore()->loadEventProxies()).isFailure()) {
      error() << "Error loading Event proxies" << endmsg;
      return -1;
    } 
    bool consume_modifier_stream = false;
    // Read the attribute list
    const AthenaAttributeList* pAttrList = 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>();
 
        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>()) ) {
                fatal() << "Secondary EventNumber requested, but secondary input does not exist!" << endmsg;
                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 = eventStore()->tryConstRetrieve<EventInfo>();
                if (pEventSecondary) {
          eventNumberSecondary = pEventSecondary->event_ID()->event_number();
                }
                else {
                    fatal() << "Secondary EventNumber requested, but it does not exist!" << endmsg;
                    return -1;
                }
            }
        if (eventNumberSecondary != 0) {
          if (m_doEvtHeartbeat) {
        info() << "  ===>>>  using secondary event #" << eventNumberSecondary << " instead of #" << eventNumber << "<<<===" << endmsg;
          }
          eventNumber = eventNumberSecondary;
        }
        }
 
        // never recorded in the eventStore
        pEvent = std::make_unique<EventInfo>(
            std::make_unique<EventID>(runNumber, eventNumber, eventTime,
                                      eventTimeNS, lumiBlock, bunchId),
            nullptr);
      } catch (...) {
      }
    } else if (m_requireInputAttributeList) {
      fatal() << "Valid input attribute list required but not present!";
      return -1;
    }
 
    const EventInfo* pEventObserver{pEvent.get()};
    if (!pEventObserver) {
        // Retrieve the Event object
        EventInfoCnvParams::eventIndex = ctx.evt();
        pEventObserver = eventStore()->tryConstRetrieve<EventInfo>();
        if( !pEventObserver ) {
         
          // Try to get the xAOD::EventInfo
          const xAOD::EventInfo* pXEvent{nullptr};
          sc = eventStore()->retrieve(pXEvent);
          if( !sc.isSuccess() ) {
        error() << "Unable to retrieve Event root object" << endmsg;
        return -1;
          }
          consume_modifier_stream = true;
          // 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 = eventStore()->record(std::move(pEvent), "");
          if( !sc.isSuccess() )  {
        error() << "Error declaring event data object" << endmsg;
        return -1;
          }
        } else {
          consume_modifier_stream = false;
        }
    }
 
    // the pEvent was moved to the eventStore, the object is still 'alive'.
    // so the raw pEventObserver pointer is also still valid
    // cppcheck-suppress invalidLifetime
    modifyEventContext(ctx, *(pEventObserver->event_ID()),
                       consume_modifier_stream);
 
  }  else  {
 
    // 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>());
 
    modifyEventContext(ctx,*(pEvent->event_ID()), true);
 
    debug() << "selecting store: " << ctx.slot() << endmsg;
 
    m_whiteboard->selectStore( ctx.slot() ).ignore();
 
    debug() << "recording EventInfo " << *pEvent->event_ID() << " in "
            << eventStore()->name() << endmsg;
    sc = eventStore()->record(std::move(pEvent), "McEventInfo");
    if( !sc.isSuccess() )  {
      error() << "Error declaring event data object" << endmsg;
      return -1;
    } 
  }
  return 1;
}

drainScheduler()

int AthenaMtesEventLoopMgr::drainScheduler ( int &  finishedEvents, bool  report  )

overridevirtual

Drain the scheduler from all actions that may be queued.

Definition at line 1256 of file AthenaMtesEventLoopMgr.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
  debug() << "drainScheduler: [" << finishedEvts << "] Waiting for a context" << endmsg;
  sc = m_schedulerSvc->popFinishedEvent(finishedEvtContext);
 
  // We got past it: cache the pointer
  if (sc.isSuccess()){
    debug() << "drainScheduler: scheduler not empty: Context " 
        << finishedEvtContext << endmsg;
    finishedEvtContexts.emplace_back(finishedEvtContext);
  } else{
    // no more events left in scheduler to be drained
    debug() << "drainScheduler: scheduler empty" << endmsg;
    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) {
      fatal() << "Detected nullptr ctxt while clearing WB!"<< endmsg;
      fail = true;
      continue;
    }
 
    if (m_aess->eventStatus(*thisFinishedEvtContext) != EventStatus::Success) {
      fatal() << "Failed event detected on " << thisFinishedEvtContext
              << " w/ fail mode: "
              << m_aess->eventStatus(*thisFinishedEvtContext) << endmsg;
      fail = true;
      continue;
    }
    
    EventID::number_type n_run(0);
    EventID::event_number_t n_evt(0);
 
    if (m_whiteboard->selectStore(thisFinishedEvtContext->slot()).isSuccess()) {
      n_run = thisFinishedEvtContext->eventID().run_number();
      n_evt = thisFinishedEvtContext->eventID().event_number();
    } else {
      error() << "DrainSched: unable to select store "
              << thisFinishedEvtContext->slot() << endmsg;
      fail = true;
      continue;
    }
 
    // m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndEvent,
    //                   *thisFinishedEvtContext ));
    
    // Some code still needs global context in addition to that passed in the incident
    Gaudi::Hive::setCurrentContext( *thisFinishedEvtContext );
    info() << "Firing EndProcessing" << endmsg;
    m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndProcessing, *thisFinishedEvtContext ));
 
    if(report) {
      // If we completed an event range, then report it to the pilot
      OutputStreamSequencerSvc::RangeReport_ptr rangeReport = m_outSeqSvc->getRangeReport();
      if(rangeReport) {
    std::string outputFileReport = rangeReport->second + std::string(",ID:")
      + rangeReport->first + std::string(",CPU:N/A,WALL:N/A");
    if( not m_inTestMode ) {
      // In standalone test mode there is no pilot to talk to
      void* message2pilot = malloc(outputFileReport.size());
      memcpy(message2pilot,outputFileReport.data(),outputFileReport.size());
      m_socket->send(message2pilot,outputFileReport.size());
    }
    info() << "Reported the output " << outputFileReport << endmsg;
      }
    }
 
    debug() << "Clearing slot " << thisFinishedEvtContext->slot() 
            << " (event " << thisFinishedEvtContext->evt()
            << ") of the whiteboard" << endmsg;
    
    StatusCode sc = clearWBSlot(thisFinishedEvtContext->slot());
    if (!sc.isSuccess()) {
      error() << "Whiteboard slot " << thisFinishedEvtContext->slot() 
          << " could not be properly cleared";
      fail = true;
      continue;
    }
    
    finishedEvts++;
 
    writeHistograms().ignore();
    ++m_proc;
 
    if (m_doEvtHeartbeat) {
      if(!m_useTools) 
        info() << "  ===>>>  done processing event #" << n_evt << ", run #" << n_run 
               << " on slot " << thisFinishedEvtContext->slot() << ",  "
               << m_proc << " events processed so far  <<<===" << endmsg;
      else 
    info() << "  ===>>>  done processing event #" << n_evt << ", run #" << n_run 
           << " on slot " << thisFinishedEvtContext->slot() << ",  "          
           << m_nev << " events read and " << m_proc 
           << " events processed so far <<<===" << endmsg;
      std::ofstream outfile( "eventLoopHeartBeat.txt");
      if ( !outfile ) {
    error() << " unable to open: eventLoopHeartBeat.txt" << endmsg;
    fail = true;
    continue;
      } else {
    outfile << "  done processing event #" << n_evt << ", run #" << n_run 
        << " " << m_nev << " events read so far  <<<===" << std::endl;
    outfile.close();
      }  
    }
 
    debug() << "drainScheduler thisFinishedEvtContext: " << thisFinishedEvtContext
        << endmsg;
  }
 
  return (  fail ? -1 : 1 );
 
}

eventStore()

StoreGateSvc * AthenaMtesEventLoopMgr::eventStore ( ) const

inlineprivate

Definition at line 334 of file AthenaMtesEventLoopMgr.cxx.

                                         {
  return m_eventStore.get();
}

executeAlgorithms()

StatusCode AthenaMtesEventLoopMgr::executeAlgorithms ( )

protectedvirtual

Run the algorithms for the current event.

Definition at line 529 of file AthenaMtesEventLoopMgr.cxx.

                                                     {
 
  return StatusCode::SUCCESS;
}

executeEvent()

StatusCode AthenaMtesEventLoopMgr::executeEvent ( EventContext &&  ctx )

overridevirtual

implementation of IEventProcessor::executeEvent(void* par)

Fire begin-Run incident if new run:

Definition at line 538 of file AthenaMtesEventLoopMgr.cxx.

{
 
  // An incident may schedule a stop, in which case is better to exit before the actual execution.
  if ( m_scheduledStop ) {
    always() << "A stopRun was requested by an incidentListener. "
             << "Do not process this event." 
             << endmsg;
    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) {
    error() << "declareEventRootAddress for context " << ctx << " failed"
        << endmsg;
    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 (eventStore()->contains<AthenaAttributeList>("Input") &&
        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 (eventStore()->record(std::make_unique<EventContext> (ctx),
                           "EventContext").isFailure())
  {
    error() << "Error recording event context object" << endmsg;
    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();
 
    info() << "  ===>>>  start of run " << m_currentRun << "    <<<==="
           << endmsg;
 
    // 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) 
     info() << "  ===>>>  start processing event #" << evtNumber << ", run #" << m_currentRun 
            << " on slot " << ctx.slot() << ",  " << m_proc 
            << " events processed so far  <<<===" << endmsg;
   else 
     info() << "  ===>>>  start processing event #" << evtNumber << ", run #" << m_currentRun 
            << " on slot " << ctx.slot() << ",  " 
            << m_nev << " events read and " << m_proc 
            << " events processed so far  <<<===" << endmsg;   
  }
 
  // Reset the timeout singleton
  resetTimeout(Athena::Timeout::instance(ctx));
  if(toolsPassed) {
 
    CHECK( m_conditionsCleaner->event (ctx, true) );
 
    // Remember the last event context for after event processing finishes.
    m_lastEventContext = ctx;
    
    // Now add event to the scheduler 
    debug() << "Adding event " << ctx.evt() 
            << ", slot " << ctx.slot()
            << " to the scheduler" << endmsg;
    
    m_incidentSvc->fireIncident(Incident(name(), IncidentType::BeginProcessing, 
                     ctx));
    StatusCode addEventStatus = m_schedulerSvc->pushNewEvent( new EventContext{ std::move(ctx) } );
    
    // If this fails, we need to wait for something to complete
    if (!addEventStatus.isSuccess()){
      fatal() << "An event processing slot should be now free in the scheduler, but it appears not to be the case." << endmsg;
    }
    
  }  // end of toolsPassed test
 
  ++m_nev;
 
  ++m_nevt;
 
  // invalidate thread local context once outside of event execute loop
  Gaudi::Hive::setCurrentContext( EventContext() );
 
  return StatusCode::SUCCESS;
 
}

executeRun()

StatusCode AthenaMtesEventLoopMgr::executeRun ( int  maxevt )

overridevirtual

implementation of IEventProcessor::executeRun(int maxevt)

Definition at line 677 of file AthenaMtesEventLoopMgr.cxx.

{
  StatusCode sc = nextEvent(maxevt);
  if (sc.isSuccess()) {
    m_incidentSvc->fireIncident(Incident(name(),"EndEvtLoop"));
  }
  return sc;
}

finalize()

StatusCode AthenaMtesEventLoopMgr::finalize ( )

overridevirtual

implementation of IAppMgrUI::finalize

Definition at line 394 of file AthenaMtesEventLoopMgr.cxx.

{
 
  StatusCode sc = MinimalEventLoopMgr::finalize();
  if (sc.isFailure()) 
  {
    error() << "Error in Service base class Finalize" 
            << endmsg;
  }
 
  StatusCode sc2 = writeHistograms(true);
  if (sc2.isFailure()) 
  {
    error() << "Error in writing Histograms"
        << endmsg;
  }
 
  // 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;
    info() << "Summary of AthenaEvtLoopPreSelectTool invocation: (invoked/success/failure)" << endmsg;
    info() << "-----------------------------------------------------" << endmsg;
 
    for ( ; firstTool != lastTool; ++firstTool ) {
      info() << std::setw(2)     << std::setiosflags(std::ios_base::right)
             << toolCtr+1 << ".) " << std::resetiosflags(std::ios_base::right)
             << std::setw(48) << std::setfill('.')
             << std::setiosflags(std::ios_base::left)
             << (*firstTool)->name() << std::resetiosflags(std::ios_base::left)
             << std::setfill(' ')
             << " ("
             << std::setw(6) << std::setiosflags(std::ios_base::right)
             << m_toolInvoke[toolCtr]
             << "/"
             << m_toolAccept[toolCtr]
             << "/"
             << m_toolReject[toolCtr]
             << ")"
             << endmsg;
      toolCtr++;
    }
  }
 
  return ( sc.isFailure() || sc2.isFailure() ) ? StatusCode::FAILURE :
    StatusCode::SUCCESS;
 
}

getEventRoot()

StatusCode AthenaMtesEventLoopMgr::getEventRoot

(

IOpaqueAddress *&

refpAddr

)

Create event address using event selector.

Definition at line 977 of file AthenaMtesEventLoopMgr.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() )  {
        warning() << "Error creating IOpaqueAddress." << endmsg;
      }
    }
  }
  return sc;
}

getNextRange()

std::unique_ptr< AthenaMtesEventLoopMgr::RangeStruct > AthenaMtesEventLoopMgr::getNextRange ( yampl::ISocket *  socket )

private

Definition at line 1397 of file AthenaMtesEventLoopMgr.cxx.

{
  static const std::string strReady("Ready for events");
  static const std::string strStopProcessing("No more events");
 
  std::string range;
  if( m_inTestMode ) {
     static std::atomic<size_t> line_n = 0;
     info() <<"in TEST MODE, Range #" << line_n+1 << endmsg;
     range = (line_n < m_testPilotMessages.value().size()) ? m_testPilotMessages.value()[line_n++] : strStopProcessing;
  } else {
     // Signal the Pilot that we are ready for event processing
     void* ready_message = malloc(strReady.size());
     memcpy(ready_message,strReady.data(),strReady.size());
     socket->send(ready_message,strReady.size());
     void* eventRangeMessage;
     std::string strPeerId;
     ssize_t eventRangeSize = socket->recv(eventRangeMessage,strPeerId);
     range = std::string((const char*)eventRangeMessage,eventRangeSize);
     leftString(range, '\n');
  }
 
  std::unique_ptr<RangeStruct> result = std::make_unique<RangeStruct>();
  if(range.compare(strStopProcessing)==0) {
     info() << "No more events from the server" << endmsg;
     return result;
  }
  info() << "Got Event Range from the pilot: " << range << endmsg;
 
  // _____________________ Decode range string _____________________________
  // Expected the following format: [{KEY:VALUE[,KEY:VALUE]}]
  // First get rid of the leading '[{' and the trailing '}]'
  if(range.starts_with( "[{")) range=range.substr(2);
  if(range.ends_with( "}]")){
    const int truncate = range.size()-2;
    leftString(range, truncate);
  }
 
  std::map<std::string,std::string> eventRangeMap;
  size_t startpos(0);
  size_t endpos = range.find(',');
  while(endpos!=std::string::npos) {
    // Get the Key-Value pair
    std::string keyValue(range.substr(startpos,endpos-startpos));
    size_t colonPos = keyValue.find(':');
    std::string strKey = keyValue.substr(0,colonPos);
    std::string strVal = keyValue.substr(colonPos+1);
    trimRangeStrings(strKey);       
    trimRangeStrings(strVal);
    eventRangeMap[strKey]=strVal;
    
    // Next iteration
    startpos = endpos+1;
    endpos = range.find(',',startpos);     
  }
  
  // Get the final Key-Value pair
  std::string keyValue(range.substr(startpos));
  size_t colonPos = keyValue.find(':');
  std::string strKey = keyValue.substr(0,colonPos);
  std::string strVal = keyValue.substr(colonPos+1);
  trimRangeStrings(strKey);
  trimRangeStrings(strVal);
  eventRangeMap[strKey]=strVal;
 
  // _____________________ Consistency check for range string _____________________________
  // Three checks are performed:
  //   1. The existence of all required fields
  //   2. The consistency of field values
  //   3. Protection against having event ranges from different input files
  //      NB. The last check is hopefully a temporary limitation of MTES
  std::string errorStr{""};
 
  if(eventRangeMap.find("eventRangeID")==eventRangeMap.end()
     || eventRangeMap.find("startEvent")==eventRangeMap.end()
     || eventRangeMap.find("lastEvent")==eventRangeMap.end()
     || eventRangeMap.find("PFN")==eventRangeMap.end()) {
    // Wrong format
    errorStr = "ERR_ATHENAMP_PARSE \"" + range + "\": Wrong format";
  }
 
  if(errorStr.empty()) {
    result->startEvent = std::atoi(eventRangeMap["startEvent"].c_str());
    result->lastEvent = std::atoi(eventRangeMap["lastEvent"].c_str());
    
    if(eventRangeMap["eventRangeID"].empty()
       || eventRangeMap["PFN"].empty()
       || result->lastEvent < result->startEvent) {
      // Wrong values of range fields
      errorStr = "ERR_ATHENAMP_PARSE \"" + range + "\": Wrong values of range fields";
    }
    else {
      // Update m_pfn if necessary
      if(m_pfn != eventRangeMap["PFN"]) {
    IProperty* propertyServer = dynamic_cast<IProperty*>(m_evtSelector);
    if(!propertyServer) {
      errorStr = "ERR_ATHENAMP_PARSE \"" + range + "\": Unable to dyn-cast the event selector to IProperty";
    }
    else {
      std::string strInpuCol("InputCollections");
      std::vector<std::string> vectInpCol{eventRangeMap["PFN"],};
      StringArrayProperty inputFileList(strInpuCol, vectInpCol);
      if(propertyServer->setProperty(inputFileList).isFailure()) {
        errorStr = "ERR_ATHENAMP_PARSE \"" + range + "\": Unable to set input file name property to the Event Selector";
      }
      else {
        m_pfn = eventRangeMap["PFN"];
      }
    }
      }
    }
  }
 
  if(errorStr.empty()) {
    // Event range parsing was successful
    debug() << "*** Decoded Event Range ***" << endmsg;
    for (const auto& fieldvalue : eventRangeMap) {
      debug() << fieldvalue.first << ":" << fieldvalue.second << endmsg;
    }
 
    result->eventRangeID = eventRangeMap["eventRangeID"];
    result->pfn = eventRangeMap["PFN"];
  }
  else {
    // We got here because there was an error
    // Report the error to the pilot and reset the result, so that the next range can be tried
    warning() << errorStr << endmsg;
    info() << "Ignoring this event range" << endmsg;
    if( not m_inTestMode ) {
       void* errorMessage = malloc(errorStr.size());
       memcpy(errorMessage,errorStr.data(),errorStr.size());
       socket->send(errorMessage,errorStr.size());
    }
    result.reset();
  }
 
  return result;
}

handle()

void AthenaMtesEventLoopMgr::handle ( const Incident &  inc )

overridevirtual

IIncidentListenet interfaces.

Definition at line 910 of file AthenaMtesEventLoopMgr.cxx.

{
 
  if(inc.type()!="BeforeFork")
    return;
 
  if(!m_evtContext || !m_firstRun) {
    warning() << "Skipping BeforeFork handler. Either no event selector is provided or begin run has already passed" << endmsg;
  }
 
  // Initialize Algorithms and Output Streams
  StatusCode sc = initializeAlgorithms();
  if(sc.isFailure()) {
    error() << "Failed to initialize Algorithms" << endmsg;
    return; 
  }
 
  // Construct EventInfo
  const EventInfo* pEvent(0);
  IOpaqueAddress* addr = 0;
  sc = m_evtSelector->next(*m_evtContext);
  if(!sc.isSuccess()) {
    info() << "No more events in event selection " << endmsg;
    return;
  }
  sc = m_evtSelector->createAddress(*m_evtContext, addr);
  if (sc.isFailure()) {
    error() << "Could not create an IOpaqueAddress" << endmsg;
    return; 
  }
  if (0 != addr) {
    //create its proxy
    sc = eventStore()->recordAddress(addr);
    if(!sc.isSuccess()) {
      error() << "Error declaring Event object" << endmsg;
      return;
    }
  } 
  
  if(eventStore()->loadEventProxies().isFailure()) {
    warning() << "Error loading Event proxies" << endmsg;
    return;
  }
 
  // Retrieve the Event object
  sc = eventStore()->retrieve(pEvent);
  if(!sc.isSuccess()) {
    error() << "Unable to retrieve Event root object" << endmsg;
    return;
  }
 
  m_firstRun=false;
  m_currentRun = pEvent->event_ID()->run_number();
 
  // Clear Store
  const ClearStorePolicy::Type s_clearStore = clearStorePolicy( m_clearStorePolicy.value(), msgStream() );
  if(s_clearStore==ClearStorePolicy::EndEvent) {
    sc = eventStore()->clearStore();
    if(!sc.isSuccess()) {
      error() << "Clear of Event data store failed" << endmsg;
    }
  }
}

initialize()

StatusCode AthenaMtesEventLoopMgr::initialize ( )

overridevirtual

implementation of IAppMgrUI::initalize

Definition at line 155 of file AthenaMtesEventLoopMgr.cxx.

{
  info() << "Initializing " << name() << endmsg;
 
  StatusCode sc = MinimalEventLoopMgr::initialize();
  if(!sc.isSuccess()) {
    error() << "Failed to initialize base class MinimalEventLoopMgr" << endmsg;
    return sc;
  }
 
//-------------------------------------------------------------------------
// Setup stuff for hive
//-------------------------------------------------------------------------
 
  m_whiteboard = serviceLocator()->service(m_whiteboardName);
  if(!m_whiteboard.isValid()) {
    fatal() << "Error retrieving " << m_whiteboardName << " interface IHiveWhiteBoard." << endmsg;
    return StatusCode::FAILURE;
  }
  
  m_schedulerSvc = serviceLocator()->service(m_schedulerName);
  if(!m_schedulerSvc.isValid()) {
    fatal() << "Error retrieving SchedulerSvc interface ISchedulerSvc." << endmsg;
    return StatusCode::FAILURE;    
  }
 
  m_algResourcePool = serviceLocator()->service("AlgResourcePool");
  if(!m_algResourcePool.isValid()) {
    fatal() << "Error retrieving AlgResourcePool" << endmsg;
    return StatusCode::FAILURE;
  }
 
  m_aess = serviceLocator()->service("AlgExecStateSvc");
  if(!m_aess.isValid()) {
    fatal() << "Error retrieving AlgExecStateSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_eventStore.retrieve());
  ATH_CHECK(m_incidentSvc.retrieve());
 
//--------------------------------------------------------------------------
// Access Property Manager interface:
//--------------------------------------------------------------------------
  SmartIF<IProperty> prpMgr(serviceLocator());
  if(!prpMgr.isValid()) {
    fatal() << "IProperty interface not found in ApplicationMgr." << endmsg;
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_histoDataMgrSvc.retrieve());
    
  const std::string& histPersName(m_histPersName.value());
  if(histPersName.empty()) {
    ATH_CHECK(setProperty(prpMgr->getProperty("HistogramPersistency")));
  }
 
  if(histPersName != "NONE") {
 
    m_histoPersSvc = IConversionSvc_t( "HistogramPersistencySvc", 
                       this->name() );
 
    SmartIF<IProperty> histSvc{serviceLocator()->service("RootHistSvc")};
 
    if (!histSvc) {
      error() << "could not locate actual Histogram persistency service" << endmsg;
    }
    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 (...) {
        verbose() << "could not dcast OutputFile property to a StringProperty."
                  << " Need to fix Gaudi."
                  << endmsg;
 
        val = prop.toString();
      }
 
      if (val != ""
          && val != "UndefinedROOTOutputFileName") {
        m_writeHists = true;
      }
    }
  }
  else {
    if (msgLevel(MSG::DEBUG)) {
      debug() << "Histograms saving not required." << endmsg;
    }
  }
 
  //--------------------------------------------------------------------------
  // Set up the EventID modifier Service
  //--------------------------------------------------------------------------
  if (m_evtIdModSvc.empty()) {
    debug() << "EventID modifier Service not set. No run number, ... overrides "
               "will "
               "be applied."
            << endmsg;
  } else if (!m_evtIdModSvc.retrieve().isSuccess()) {
    debug() << "Could not find EventID modifier Service. No run number, ... "
               "overrides "
               "will be applied."
            << endmsg;
  }
 
  //-------------------------------------------------------------------------
  // 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()) {
    warning() << "Unable to set EvtSel property" << endmsg;
  }
 
  // 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()) {
        fatal() << "Can not create the event selector Context." << endmsg;
        return StatusCode::FAILURE;
      }
      if (msgLevel(MSG::INFO)) {
        SmartIF<INamedInterface> named{theEvtSel};
        if (named) {
          info() << "Setup EventSelector service " << named->name( ) << endmsg;
        }
      }
    }
    else if (sc.isFailure()) {
      fatal() << "No valid event selector called " << selName << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
//-------------------------------------------------------------------------
// Setup 'Clear-Store' policy
//-------------------------------------------------------------------------
  try {
    setClearStorePolicy( m_clearStorePolicy );
  } catch(...) {
    return StatusCode::FAILURE;
  }
 
  // Listen to the BeforeFork incident
  m_incidentSvc->addListener(this,"BeforeFork",0);
 
  CHECK( m_conditionsCleaner.retrieve() );
  CHECK( m_outSeqSvc.retrieve() );
 
  // Print if we override the event number using the one from secondary event
  if(m_useSecondaryEventNumber) {
    info() << "Using secondary event number." << endmsg;
  }
 
  if( m_testPilotMessages.value().size() > 0 ) {
     info() << "runnung in standalone TEST MODE" << endmsg;
     info() << "  test contains " << m_testPilotMessages.value().size() << " event ranges" << endmsg;
     for( const std::string& range: m_testPilotMessages.value() ) {
        debug() << "    " << range << endmsg;
     }
     m_inTestMode = true;
  }
  return sc;
}

initializeAlgorithms()

StatusCode AthenaMtesEventLoopMgr::initializeAlgorithms ( )

protected

Initialize all algorithms and output streams.

Definition at line 521 of file AthenaMtesEventLoopMgr.cxx.

                                                        {
 
  return StatusCode::SUCCESS;
}

modifyEventContext()

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

private

Definition at line 1189 of file AthenaMtesEventLoopMgr.cxx.

                                                                              {
 
  if (m_evtIdModSvc.isSet()) {
    EventID new_eID(eID);
    // In Mtes 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();
      debug() << "modifyEventContext: use evtIdModSvc runnr=" << oldrunnr
              << " -> " << new_eID.run_number() << endmsg;
      debug() << "modifyEventContext: use evtIdModSvc LB=" << oldLB << " -> "
              << new_eID.lumi_block() << endmsg;
      debug() << "modifyEventContext: use evtIdModSvc TimeStamp=" << oldTS
              << " -> " << new_eID.time_stamp() << endmsg;
      debug() << "modifyEventContext: use evtIdModSvc TimeStamp ns Offset="
              << oldTSno << " -> " << new_eID.time_stamp_ns_offset() << endmsg;
    }
    ctx.setEventID(new_eID);
    Atlas::getExtendedEventContext(ctx).setConditionsRun(
        ctx.eventID().run_number());
    return;
  }
 
  ctx.setEventID(eID);
}

name()

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

inlineoverridevirtual

Definition at line 224 of file AthenaMtesEventLoopMgr.h.

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

nextEvent()

StatusCode AthenaMtesEventLoopMgr::nextEvent ( int  maxevt )

overridevirtual

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

Definition at line 727 of file AthenaMtesEventLoopMgr.cxx.

{
  if(maxevt==0) return StatusCode::SUCCESS;
 
  // Create a socket to communicate with the Pilot
  m_socket =
      std::unique_ptr<yampl::ISocket>{yampl::SocketFactory().createClientSocket(
          yampl::Channel{m_eventRangeChannel.value(), yampl::LOCAL},
          yampl::MOVE_DATA)};
 
  // Reset the application return code.
  resetAppReturnCode();
 
  int finishedEvts =0;
  int createdEvts =0;
  info() << "Starting loop on events" << endmsg;
 
  StatusCode sc(StatusCode::SUCCESS);
 
  // Calculate runtime
  auto start_time = tbb::tick_count::now();
  auto secsFromStart = [&start_time]()->double{
    return (tbb::tick_count::now()-start_time).seconds();
  };
 
  std::unique_ptr<RangeStruct> range;
  while(!range) {
    range = getNextRange(m_socket.get());
    usleep(1000);
  }
 
  bool loop_ended = range->eventRangeID.empty();
  if(!loop_ended) {
    m_currentEvntNum = range->startEvent;
    // Fire NextRange incident
    m_incidentSvc->fireIncident(FileIncident(name(), "NextEventRange",range->eventRangeID));
  }
 
  bool no_more_events = false;
 
  while(!loop_ended) {
 
    debug() << " -> createdEvts: " << createdEvts << endmsg;
    
    if(!m_terminateLoop                       // No scheduled loop termination
       && !no_more_events                     // We are not yet done getting events
       && m_schedulerSvc->freeSlots()>0) {    // There are still free slots in the scheduler
      
      debug() << "createdEvts: " << createdEvts << ", freeslots: " << m_schedulerSvc->freeSlots() << endmsg;
      
      auto ctx = createEventContext();
 
      if ( !ctx.valid() ) {
    sc = StatusCode::FAILURE;
      } 
      else {
    sc = executeEvent( std::move(ctx) );
      }
      
      if (sc.isFailure()) {
    error() << "Terminating event processing loop due to errors" << endmsg;
    loop_ended = true;
      } 
      else {
    ++createdEvts;
    if(++m_currentEvntNum > range->lastEvent) {
      // Fetch next event range
      range.reset();
      while(!range) {
        range = getNextRange(m_socket.get());
        usleep(1000);
      }
      if(range->eventRangeID.empty()) {
        no_more_events = true;
      }
      else {
        m_currentEvntNum = range->startEvent;
        // Fire NextRange incident
        m_incidentSvc->fireIncident(FileIncident(name(), "NextEventRange",range->eventRangeID));
      }
    }
      }
    }
    else { 
      // all the events were created but not all finished or the slots were 
      // all busy: the scheduler should finish its job
    
      debug() << "Draining the scheduler" << endmsg;
 
      // Pull out of the scheduler the finished events
      int ir = drainScheduler(finishedEvts,true);
      if(ir < 0) {
    // some sort of error draining scheduler;
    loop_ended = true;
    sc = StatusCode::FAILURE;
      } 
      else if(ir == 0) {
    // no more events in scheduler
    if(no_more_events) {
      // We are done
      loop_ended = true;
      sc = StatusCode::SUCCESS;
    }
      } 
      else {
    // keep going!
      }
    }
  } // end main loop on finished events  
 
  info() << "---> Loop Finished (seconds): " << secsFromStart() <<endmsg;
 
  return sc;
}

operator=()

AthenaMtesEventLoopMgr& AthenaMtesEventLoopMgr::operator= ( const AthenaMtesEventLoopMgr &  )

privatedelete

resetAppReturnCode()

void AthenaMtesEventLoopMgr::resetAppReturnCode ( )

overridevirtual

Reset the application return code.

Definition at line 1241 of file AthenaMtesEventLoopMgr.cxx.

{
  Gaudi::setAppReturnCode(m_appMgrProperty, Gaudi::ReturnCode::Success, true).ignore();
}

resetTimeout()

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

inlineprotectedinherited

Reset timeout.

Definition at line 83 of file Timeout.h.

{ instance.reset(); }

seek()

StatusCode AthenaMtesEventLoopMgr::seek ( int  evt )

overridevirtual

Seek to a given event.

Definition at line 847 of file AthenaMtesEventLoopMgr.cxx.

{
  IEvtSelectorSeek* is = dynamic_cast<IEvtSelectorSeek*> (m_evtSelector);
  if (is == 0) {
    error() << "Seek failed; unsupported by event selector"
            << endmsg;
    return StatusCode::FAILURE;
  }
  //cppcheck-suppress nullPointerRedundantCheck
  if (!m_evtContext) {
    if (m_evtSelector->createContext(m_evtContext).isFailure()) {
      fatal() << "Can not create the event selector Context."
              << endmsg;
      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_nevt = evt;
  }
  else {
    error() << "Seek failed." << endmsg;
  }
  return sc;
}

setClearStorePolicy()

void AthenaMtesEventLoopMgr::setClearStorePolicy ( Gaudi::Details::PropertyBase &  clearStorePolicy )

protected

property update handler:set the clear-store policy value and check its value.

Definition at line 342 of file AthenaMtesEventLoopMgr.cxx.

                                                                     {
  const std::string& policyName = m_clearStorePolicy.value();
 
  if ( policyName != "BeginEvent" &&
       policyName != "EndEvent" ) {
 
    fatal() << "Unknown policy [" << policyName 
            << "] for the 'ClearStore-policy !\n"
            << "           Valid values are: BeginEvent, EndEvent"
            << endmsg;
    throw GaudiException("Can not setup 'ClearStore'-policy",
             name(),
             StatusCode::FAILURE);
  }
 
  return;
}

setCurrentEventNum()

void AthenaMtesEventLoopMgr::setCurrentEventNum ( int  num )

overridevirtual

Definition at line 1246 of file AthenaMtesEventLoopMgr.cxx.

                                                       {
  m_currentEvntNum = num;
}

setTimeout()

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

inlineprotectedinherited

Set timeout.

Definition at line 80 of file Timeout.h.

{ instance.set(); }

setupPreSelectTools()

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

protected

property update handler:sets up the Pre-selection tools

Definition at line 361 of file AthenaMtesEventLoopMgr.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 AthenaMtesEventLoopMgr::size ( )

overridevirtual

Return the size of the collection.

Definition at line 887 of file AthenaMtesEventLoopMgr.cxx.

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

stop()

StatusCode AthenaMtesEventLoopMgr::stop ( )

overridevirtual

implementation of IService::stop

Definition at line 704 of file AthenaMtesEventLoopMgr.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->getNumberOfStores();
  for (size_t islot = 0; islot < nslot; islot++) {
    sc &= clearWBSlot (islot);
  }
 
  Gaudi::Hive::setCurrentContext( EventContext() );
  return sc;
}

stopRun()

StatusCode AthenaMtesEventLoopMgr::stopRun ( )

overridevirtual

implementation of IEventProcessor::stopRun()

Definition at line 689 of file AthenaMtesEventLoopMgr.cxx.

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

terminateLoop()

bool AthenaMtesEventLoopMgr::terminateLoop ( )

overridevirtual

Definition at line 1250 of file AthenaMtesEventLoopMgr.cxx.

                                           {
  return m_terminateLoop;
}

trimRangeStrings()

void AthenaMtesEventLoopMgr::trimRangeStrings ( std::string &  str )

private

Definition at line 1536 of file AthenaMtesEventLoopMgr.cxx.

{
  size_t i(0);
  // get rid of leading spaces
  while(i<str.size() && str[i]==' ') i++;
  if(i) str = str.substr(i);
 
  if(str.empty()) return;  // Corner case: string consists only of spaces
 
  // get rid of trailing spaces
  i=str.size()-1;
  while(str[i]==' ') i--;
  if(i) str.resize(i+1);
 
  // the string might be enclosed by either
  // "u\'" and "\'"
  // or
  // "\"" and "\""
  // Get rid of them!
  if(str.starts_with( "u\'")) {
    str = str.substr(2);
    if(str.rfind('\'')==str.size()-1) {
      str.pop_back();
    }
  }
  else if(str.starts_with("\"")) {
    str = str.substr(1);
    if(str.rfind('\"')==str.size()-1) {
      str.pop_back();
    }
  } 
}

writeHistograms()

StatusCode AthenaMtesEventLoopMgr::writeHistograms ( bool  force = false )

protectedvirtual

Dump out histograms as needed.

Definition at line 465 of file AthenaMtesEventLoopMgr.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() ) {
      error() << "Error while traversing Histogram data store" << endmsg;
      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() ) {
          error() << "Error while saving Histograms." << endmsg;
        }
      }
 
      if (force || (writeInterval != 0 && m_nevt%writeInterval == 0) ) {
        if (msgLevel(MSG::DEBUG)) { debug() << "committing Histograms" << endmsg; }
        m_histoPersSvc->conversionSvc()->commitOutput("",true).ignore();
      }
    }
          
  }
  
  return sc;
}

Member Data Documentation

m_abortEventListener

SmartIF< IIncidentListener > AthenaMtesEventLoopMgr::m_abortEventListener

protected

Instance of the incident listener waiting for AbortEvent.

Definition at line 164 of file AthenaMtesEventLoopMgr.h.

m_aess

SmartIF<IAlgExecStateSvc> AthenaMtesEventLoopMgr::m_aess

protected

Reference to the Algorithm Execution State Svc.

Definition at line 152 of file AthenaMtesEventLoopMgr.h.

m_algResourcePool

SmartIF<IAlgResourcePool> AthenaMtesEventLoopMgr::m_algResourcePool

protected

Reference to the Algorithm resource pool.

Definition at line 149 of file AthenaMtesEventLoopMgr.h.

m_appMgrProperty

SmartIF<IProperty> AthenaMtesEventLoopMgr::m_appMgrProperty

protected

Property interface of ApplicationMgr.

Definition at line 155 of file AthenaMtesEventLoopMgr.h.

m_clearStorePolicy

StringProperty AthenaMtesEventLoopMgr::m_clearStorePolicy

protected

Definition at line 120 of file AthenaMtesEventLoopMgr.h.

m_conditionsCleaner

ServiceHandle<Athena::IConditionsCleanerSvc> AthenaMtesEventLoopMgr::m_conditionsCleaner

private

Definition at line 261 of file AthenaMtesEventLoopMgr.h.

m_currentEvntNum

int AthenaMtesEventLoopMgr::m_currentEvntNum {-1}

protected

Definition at line 172 of file AthenaMtesEventLoopMgr.h.

m_currentRun

number_type AthenaMtesEventLoopMgr::m_currentRun

protected

current run number

Definition at line 93 of file AthenaMtesEventLoopMgr.h.

m_doEvtHeartbeat

bool AthenaMtesEventLoopMgr::m_doEvtHeartbeat

private

Definition at line 243 of file AthenaMtesEventLoopMgr.h.

m_eventPrintoutInterval

UnsignedIntegerProperty AthenaMtesEventLoopMgr::m_eventPrintoutInterval

protected

Definition at line 100 of file AthenaMtesEventLoopMgr.h.

m_eventRangeChannel

Gaudi::Property<std::string> AthenaMtesEventLoopMgr::m_eventRangeChannel

private

Initial value:

{this
      , "EventRangeChannel"
      , "EventService_EventRanges"
      , "The name of the Yampl channel between AthenaMT and the Pilot"
      }

Definition at line 286 of file AthenaMtesEventLoopMgr.h.

m_eventStore

StoreGateSvc_t AthenaMtesEventLoopMgr::m_eventStore

protected

Reference to StoreGateSvc;.

Property

Definition at line 67 of file AthenaMtesEventLoopMgr.h.

m_evtContext

EvtContext* AthenaMtesEventLoopMgr::m_evtContext

protected

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

Definition at line 72 of file AthenaMtesEventLoopMgr.h.

m_evtIdModSvc

IEvtIdModifierSvc_t AthenaMtesEventLoopMgr::m_evtIdModSvc

protected

Definition at line 86 of file AthenaMtesEventLoopMgr.h.

m_evtsel

StringProperty AthenaMtesEventLoopMgr::m_evtsel

protected

Definition at line 74 of file AthenaMtesEventLoopMgr.h.

m_evtSelector

IEvtSelector* AthenaMtesEventLoopMgr::m_evtSelector

protected

Reference to the Event Selector.

Definition at line 70 of file AthenaMtesEventLoopMgr.h.

m_failureMode

IntegerProperty AthenaMtesEventLoopMgr::m_failureMode

protected

Definition at line 97 of file AthenaMtesEventLoopMgr.h.

m_firstRun

bool AthenaMtesEventLoopMgr::m_firstRun

protected

Definition at line 94 of file AthenaMtesEventLoopMgr.h.

m_flmbi

unsigned int AthenaMtesEventLoopMgr::m_flmbi

private

Definition at line 245 of file AthenaMtesEventLoopMgr.h.

m_histoDataMgrSvc

IDataManagerSvc_t AthenaMtesEventLoopMgr::m_histoDataMgrSvc

protected

Reference to the Histogram Data Service.

Definition at line 78 of file AthenaMtesEventLoopMgr.h.

m_histoPersSvc

IConversionSvc_t AthenaMtesEventLoopMgr::m_histoPersSvc

protected

Definition at line 82 of file AthenaMtesEventLoopMgr.h.

m_histPersName

StringProperty AthenaMtesEventLoopMgr::m_histPersName

protected

Definition at line 89 of file AthenaMtesEventLoopMgr.h.

m_incidentSvc

IIncidentSvc_t AthenaMtesEventLoopMgr::m_incidentSvc

protected

Reference to the incident service.

Definition at line 63 of file AthenaMtesEventLoopMgr.h.

m_inTestMode

bool AthenaMtesEventLoopMgr::m_inTestMode { false }

Definition at line 254 of file AthenaMtesEventLoopMgr.h.

m_lastEventContext

EventContext AthenaMtesEventLoopMgr::m_lastEventContext

private

Definition at line 265 of file AthenaMtesEventLoopMgr.h.

m_nev

unsigned int AthenaMtesEventLoopMgr::m_nev

private

events processed

Definition at line 240 of file AthenaMtesEventLoopMgr.h.

m_nevt

unsigned int AthenaMtesEventLoopMgr::m_nevt

private

Definition at line 231 of file AthenaMtesEventLoopMgr.h.

m_outSeqSvc

ServiceHandle<OutputStreamSequencerSvc> AthenaMtesEventLoopMgr::m_outSeqSvc

private

Definition at line 284 of file AthenaMtesEventLoopMgr.h.

m_pfn

std::string AthenaMtesEventLoopMgr::m_pfn {""}

private

Definition at line 294 of file AthenaMtesEventLoopMgr.h.

m_proc

unsigned int AthenaMtesEventLoopMgr::m_proc

private

Definition at line 241 of file AthenaMtesEventLoopMgr.h.

m_requireInputAttributeList

bool AthenaMtesEventLoopMgr::m_requireInputAttributeList {}

protected

require input attribute list

Definition at line 123 of file AthenaMtesEventLoopMgr.h.

m_scheduledStop

bool AthenaMtesEventLoopMgr::m_scheduledStop

protected

Scheduled stop of event processing.

Definition at line 170 of file AthenaMtesEventLoopMgr.h.

m_schedulerName

std::string AthenaMtesEventLoopMgr::m_schedulerName

protected

Name of the scheduler to be used.

Definition at line 166 of file AthenaMtesEventLoopMgr.h.

m_schedulerSvc

SmartIF<IScheduler> AthenaMtesEventLoopMgr::m_schedulerSvc

protected

A shortcut for the scheduler.

Definition at line 158 of file AthenaMtesEventLoopMgr.h.

m_socket

std::unique_ptr<yampl::ISocket> AthenaMtesEventLoopMgr::m_socket

private

Definition at line 297 of file AthenaMtesEventLoopMgr.h.

m_terminateLoop

bool AthenaMtesEventLoopMgr::m_terminateLoop { false }

private

Definition at line 237 of file AthenaMtesEventLoopMgr.h.

m_testPilotMessages

StringArrayProperty AthenaMtesEventLoopMgr::m_testPilotMessages

Definition at line 253 of file AthenaMtesEventLoopMgr.h.

m_timeStamp

unsigned int AthenaMtesEventLoopMgr::m_timeStamp { 0 }

private

Definition at line 232 of file AthenaMtesEventLoopMgr.h.

m_timeStampInt

unsigned int AthenaMtesEventLoopMgr::m_timeStampInt

private

Definition at line 245 of file AthenaMtesEventLoopMgr.h.

m_toolAccept

tool_stats AthenaMtesEventLoopMgr::m_toolAccept

protected

tool returns StatusCode::SUCCESS counter

Definition at line 111 of file AthenaMtesEventLoopMgr.h.

m_toolInvoke

tool_stats AthenaMtesEventLoopMgr::m_toolInvoke

protected

tool called counter

Definition at line 109 of file AthenaMtesEventLoopMgr.h.

m_toolReject

tool_stats AthenaMtesEventLoopMgr::m_toolReject

protected

tool returns StatusCode::FAILURE counter

Definition at line 110 of file AthenaMtesEventLoopMgr.h.

m_tools

tool_store AthenaMtesEventLoopMgr::m_tools

protected

internal tool store

Definition at line 112 of file AthenaMtesEventLoopMgr.h.

m_useSecondaryEventNumber

bool AthenaMtesEventLoopMgr::m_useSecondaryEventNumber {}

protected

read event number from secondary input

Definition at line 125 of file AthenaMtesEventLoopMgr.h.

m_useTools

bool AthenaMtesEventLoopMgr::m_useTools

private

Definition at line 242 of file AthenaMtesEventLoopMgr.h.

m_whiteboard

SmartIF<IHiveWhiteBoard> AthenaMtesEventLoopMgr::m_whiteboard

protected

Reference to the Whiteboard interface.

Definition at line 146 of file AthenaMtesEventLoopMgr.h.

m_whiteboardName

std::string AthenaMtesEventLoopMgr::m_whiteboardName

protected

Name of the Whiteboard to be used.

Definition at line 168 of file AthenaMtesEventLoopMgr.h.

m_writeHists

bool AthenaMtesEventLoopMgr::m_writeHists

private

Definition at line 235 of file AthenaMtesEventLoopMgr.h.

m_writeInterval

UnsignedIntegerProperty AthenaMtesEventLoopMgr::m_writeInterval

private

Definition at line 234 of file AthenaMtesEventLoopMgr.h.

---

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

• AthenaMtesEventLoopMgr.h
• AthenaMtesEventLoopMgr.cxx