AthenaMtesEventLoopMgr Class Reference

#include <AthenaMtesEventLoopMgr.h>

Inheritance 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.
	AthenaMtesEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
	Standard Constructor.
virtual	~AthenaMtesEventLoopMgr ()
	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 EventContext	createEventContext () override
	implementation of IEventProcessor::createEventContext()
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 void	resetAppReturnCode () override
	Reset the application return code.
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.
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
void	setClearStorePolicy (Gaudi::Details::PropertyBase &clearStorePolicy)
	property update handler:set the clear-store policy value and check its value.
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.
void	setTimeout (Timeout &instance)
	Set timeout.
void	resetTimeout (Timeout &instance)
	Reset timeout.

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
StringProperty	m_clearStorePolicy
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.
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
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 = CxxUtils::xmalloc(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());
     if (!ready_message) std::abort();
     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]=std::move(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]=std::move(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(std::move(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 = CxxUtils::xmalloc(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, true).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 1537 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.

{-1};

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.

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

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.

{ false };

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.

{ false };

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.

{ 0 };

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