AthenaEventLoopMgr Class Reference

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

#include <AthenaEventLoopMgr.h>

Inheritance diagram for AthenaEventLoopMgr:

Public Types
typedef IEvtSelector::Context	EvtContext

Public Member Functions
	AthenaEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
	Standard Constructor.
virtual	~AthenaEventLoopMgr ()
	Standard Destructor.
virtual StatusCode	initialize () override
	implementation of IAppMgrUI::initalize
virtual StatusCode	finalize () override
	implementation of IAppMgrUI::finalize
virtual StatusCode	nextEvent (int maxevt) override
	implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately
virtual StatusCode	executeEvent (EventContext &&ctx) override
	implementation of IEventProcessor::executeEvent(EventContext&& ctx)
virtual StatusCode	executeRun (int maxevt) override
	implementation of IEventProcessor::executeRun(int maxevt)
virtual StatusCode	seek (int evt) override
	Seek to a given event.
virtual int	curEvent () const override
	Return the current event count.
virtual void	setNextEventModifierIndex (long idx) override
	Supply absolute input event index for EvtIdModifierSvc. See IEventSeek.h.
virtual int	size () override
	Return the size of the collection.
virtual void	handle (const Incident &inc) override
	IIncidentListenet interfaces.
StatusCode	execAtPreFork (const EventContext &ctx) const
	Execute certain algorithms/sequences in PreFork.
virtual StatusCode	stopRun () override
	Called from ApplicationMgr::stopRun() to terminate the loop.
virtual const std::string &	name () const override
virtual void	modifyEventContext (EventContext &ctx, const EventID &eID, bool consume_modifier_stream)
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

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

Protected Member Functions
void	setupPreSelectTools (Gaudi::Details::PropertyBase &)
	property update handler:sets up the Pre-selection tools
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 (const EventContext &)
	Run the algorithms for the current event.
StatusCode	initializeAlgorithms ()
	Initialize all algorithms and output streams.
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.
IEvtSelector::Context *	m_evtSelCtxt
	Gaudi EventSelector 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
StringArrayProperty	m_execAtPreFork
StringProperty	m_histPersName
number_type	m_currentRun
	current run number
bool	m_firstRun
IntegerProperty	m_failureMode
UnsignedIntegerProperty	m_eventPrintoutInterval
tool_stats	m_toolInvoke
	tool called counter
tool_stats	m_toolReject
	tool returns StatusCode::FAILURE counter
tool_stats	m_toolAccept
	tool returns StatusCode::SUCCESS counter
tool_store	m_tools
	internal tool store
bool	m_requireInputAttributeList {}
	require input attribute list
bool	m_useSecondaryEventNumber {}
	read event number from secondary input
StringProperty	m_clearStorePolicy
SmartIF< IAlgExecStateSvc >	m_aess
	Reference to the Algorithm Execution State Svc.

Private Member Functions
	AthenaEventLoopMgr ()
	no implementation
	AthenaEventLoopMgr (const AthenaEventLoopMgr &)
	no implementation
AthenaEventLoopMgr &	operator= (const AthenaEventLoopMgr &)
	no implementation
StatusCode	installEventContext (EventContext &ctx)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
int	m_nevt {}
long	m_evtModIdxBase {-1}
int	m_evtModBaseNevt {0}
long	m_curEvtModIdx {-1}
IntegerProperty	m_writeInterval
bool	m_writeHists {}
unsigned int	m_nev
	events processed
unsigned int	m_proc
bool	m_useTools
unsigned int	m_lastNev {}
unsigned int	m_intervalInSeconds
time_t	m_lastTime {}
bool	m_liteLoop
bool	m_doChrono = false
ServiceHandle< IChronoStatSvc >	m_chronoStatSvc
ServiceHandle< Athena::IConditionsCleanerSvc >	m_conditionsCleaner
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

The default ATLAS batch event loop manager.

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

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

Definition at line 58 of file AthenaEventLoopMgr.h.

Member Typedef Documentation

EvtContext

typedef IEvtSelector::Context AthenaEventLoopMgr::EvtContext

Definition at line 64 of file AthenaEventLoopMgr.h.

IConversionSvc_t

typedef ServiceHandle<IConversionSvc> AthenaEventLoopMgr::IConversionSvc_t

protected

Definition at line 86 of file AthenaEventLoopMgr.h.

IDataManagerSvc_t

typedef ServiceHandle<IDataManagerSvc> AthenaEventLoopMgr::IDataManagerSvc_t

protected

Definition at line 82 of file AthenaEventLoopMgr.h.

IEvtIdModifierSvc_t

typedef ServiceHandle<IEvtIdModifierSvc> AthenaEventLoopMgr::IEvtIdModifierSvc_t

protected

Definition at line 90 of file AthenaEventLoopMgr.h.

IIncidentSvc_t

typedef ServiceHandle<IIncidentSvc> AthenaEventLoopMgr::IIncidentSvc_t

protected

Definition at line 67 of file AthenaEventLoopMgr.h.

number_type

typedef EventID::number_type AthenaEventLoopMgr::number_type

protected

Definition at line 100 of file AthenaEventLoopMgr.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthenaEventLoopMgr::StoreGateSvc_t

protected

Definition at line 71 of file AthenaEventLoopMgr.h.

tool_iterator

typedef tool_store::const_iterator AthenaEventLoopMgr::tool_iterator

protected

Definition at line 114 of file AthenaEventLoopMgr.h.

tool_stats

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

protected

Definition at line 115 of file AthenaEventLoopMgr.h.

tool_stats_iterator

typedef tool_stats::const_iterator AthenaEventLoopMgr::tool_stats_iterator

protected

Definition at line 116 of file AthenaEventLoopMgr.h.

tool_store

typedef ToolHandleArray< tool_type > AthenaEventLoopMgr::tool_store

protected

Definition at line 113 of file AthenaEventLoopMgr.h.

tool_type

typedef IAthenaEvtLoopPreSelectTool AthenaEventLoopMgr::tool_type

protected

Definition at line 112 of file AthenaEventLoopMgr.h.

Constructor & Destructor Documentation

AthenaEventLoopMgr() [1/3]

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

Standard Constructor.

Definition at line 58 of file AthenaEventLoopMgr.cxx.

  : base_class(nam, svcLoc),
    AthMessaging (nam),
    m_incidentSvc ( "IncidentSvc",  nam ), 
    m_eventStore( "StoreGateSvc", nam ), 
    m_evtSelector(nullptr), m_evtSelCtxt(nullptr),
    m_histoDataMgrSvc( "HistogramDataSvc",         nam ), 
    m_histoPersSvc   ( "HistogramPersistencySvc",  nam ), 
    m_evtIdModSvc    ( "",         nam ),
    m_execAtPreFork(),
    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_chronoStatSvc( "ChronoStatSvc", nam ),
    m_conditionsCleaner( "Athena::ConditionsCleanerSvc", nam )
{
  declareProperty("EvtStore", m_eventStore, "The StoreGateSvc instance to interact with for event payload" );
  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("IntervalInSeconds",  m_intervalInSeconds = 0,
          "heartbeat time interval is seconds rather than events"
          "you also get a nice event rate printout then");
  declareProperty("DoLiteLoop",m_liteLoop=false,"Runs the bare minimum during executeEvent");
  declareProperty("UseDetailChronoStat",m_doChrono=false);
  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( &AthenaEventLoopMgr::setupPreSelectTools, this );
  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("EvtIdModifierSvc", m_evtIdModSvc,
                  "ServiceHandle for EvtIdModifierSvc");
  declareProperty("ExecAtPreFork", m_execAtPreFork,
                  "List of algorithms/sequences to execute during PreFork");
}

~AthenaEventLoopMgr()

AthenaEventLoopMgr::~AthenaEventLoopMgr ( )

virtual

Standard Destructor.

Definition at line 118 of file AthenaEventLoopMgr.cxx.

{
}

AthenaEventLoopMgr() [2/3]

AthenaEventLoopMgr::AthenaEventLoopMgr ( )

private

no implementation

AthenaEventLoopMgr() [3/3]

AthenaEventLoopMgr::AthenaEventLoopMgr ( const AthenaEventLoopMgr & )

private

no implementation

Member Function Documentation

curEvent()

int AthenaEventLoopMgr::curEvent ( ) const

overridevirtual

Return the current event count.

Definition at line 879 of file AthenaEventLoopMgr.cxx.

{
  return m_nevt;
}

execAtPreFork()

StatusCode AthenaEventLoopMgr::execAtPreFork

(

const EventContext &

ctx

)

const

Execute certain algorithms/sequences in PreFork.

Definition at line 997 of file AthenaEventLoopMgr.cxx.

                                                                          {
  IAlgManager* algMgr = Gaudi::svcLocator()->as<IAlgManager>();
 
  StatusCode sc;
  for (const std::string& name : m_execAtPreFork) {
    SmartIF<IAlgorithm>& alg = algMgr->algorithm(name, /*createIf*/false);
    if ( alg ) {
      ATH_MSG_INFO("Executing {}...", alg->name());
      sc &= alg->sysExecute(ctx);
    }
    else ATH_MSG_WARNING("Cannot find algorithm or sequence {}", name);
  }
  return sc;
}

executeAlgorithms()

StatusCode AthenaEventLoopMgr::executeAlgorithms ( const EventContext & ctx )

protectedvirtual

Run the algorithms for the current event.

Reimplemented in PyAthenaEventLoopMgr.

Definition at line 515 of file AthenaEventLoopMgr.cxx.

                                                                        {
 
  // Call the execute() method of all top algorithms 
  for ( ListAlg::iterator ita = m_topAlgList.begin(); 
        ita != m_topAlgList.end();
        ++ita ) 
  {
    const StatusCode& sc = (*ita)->sysExecute(ctx); 
    // this duplicates what is already done in Algorithm::sysExecute, which
    // calls Algorithm::setExecuted, but eventually we plan to remove that 
    // function
    m_aess->algExecState(*ita,ctx).setState(AlgExecState::State::Done, sc);
    if ( !sc.isSuccess() ) {
      // StatusCode doesn't work with std::format
      ATH_MSG_INFO ( "Execution of algorithm "
              << (*ita)->name() << " failed with StatusCode::" << sc );
      return sc;
    }
  }
 
  return StatusCode::SUCCESS;
}

executeEvent()

StatusCode AthenaEventLoopMgr::executeEvent ( EventContext && ctx )

overridevirtual

implementation of IEventProcessor::executeEvent(EventContext&& ctx)

Fire begin-Run incident if new run:

m_failureMode 1, RECOVERABLE: skip algorithms, but do not terminate job FAILURE: terminate job

m_failureMode 2: skip algorithms, but do not terminate job

Definition at line 542 of file AthenaEventLoopMgr.cxx.

{
    //This is a lightweight implementation of the executeEvent, used when e.g. processing TTrees with RootNtupleEventSelector
    if(m_liteLoop) {
        m_incidentSvc->fireIncident(Incident("BeginEvent",IncidentType::BeginEvent));
        StatusCode sc = executeAlgorithms(ctx);
        m_incidentSvc->fireIncident(Incident("EndEvent",IncidentType::EndEvent));
        ++m_proc;
        ++m_nev;
        return sc;
    }
  
  CHECK( installEventContext(ctx) );
  
  if (m_firstRun || (m_currentRun != ctx.eventID().run_number()) ) {
    // Fire EndRun incident unless this is the first run
    if (!m_firstRun) {
      m_incidentSvc->fireIncident(Incident(name(),IncidentType::EndRun));
    }
    m_firstRun=false;
    m_currentRun = ctx.eventID().run_number();
 
    ATH_MSG_INFO ( "  ===>>>  start of run {}    <<<===", m_currentRun );
 
    m_incidentSvc->fireIncident(Incident(name(),IncidentType::BeginRun,ctx));
  }
 
  bool toolsPassed=true;
  bool eventFailed = false;
  // Call any attached tools to reject events early
  unsigned int toolCtr=0;
  if(m_useTools) {
    //note: pEvent cannot be nullptr here, it has already been dereferenced
    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;
      }
  }
 
 
  uint64_t evtNumber = ctx.eventID().event_number();
  bool doEvtHeartbeat(m_eventPrintoutInterval.value() > 0 &&
                              ( (!m_intervalInSeconds && 0 == (m_nev % m_eventPrintoutInterval.value())) ||
                                (m_intervalInSeconds && (time(nullptr)-m_lastTime)>m_intervalInSeconds) ));
  if (doEvtHeartbeat)  {
    if(!m_useTools) {
        ATH_MSG_INFO ( "  ===>>>  start processing event #{}, run #{} {} events processed so far  <<<===",
                       evtNumber, m_currentRun, m_nev);
        if(m_intervalInSeconds) {
            ATH_MSG_INFO(" ===>>> Event processing rate = {} Hz <<<===",
                         double(m_nev-m_lastNev)/(time(nullptr)-m_lastTime));
            m_lastNev = m_nev; m_lastTime = time(nullptr);
        }
    }
 
   else ATH_MSG_INFO ( "  ===>>>  start processing event #{}, run #{} {} events read and {} events processed so far  <<<===",
                       evtNumber, m_currentRun, m_nev, m_proc);
  }
 
  // Reset the timeout singleton
  resetTimeout(Athena::Timeout::instance(ctx));
  if(toolsPassed) {
  // Fire BeginEvent "Incident"
  //m_incidentSvc->fireIncident(Incident(*pEvent, name(),"BeginEvent"));
 
  // An incident may schedule a stop, in which case is better to exit before the actual execution.
  if ( m_scheduledStop ) {
    ATH_MSG_ALWAYS ( "A stopRun was requested by an incidentListener. "
                     "Do not process this event." );
    return (StatusCode::SUCCESS);
  }
 
  CHECK( m_conditionsCleaner->event (ctx, false) );
 
  // Call the execute() method of all top algorithms 
  StatusCode sc = executeAlgorithms(ctx);
 
  if(!sc.isSuccess()) {
    eventFailed = true; 
    m_aess->setEventStatus( EventStatus::AlgFail, ctx );

    if (m_failureMode == 1 && sc.isRecoverable() ) {
      ATH_MSG_WARNING ( "RECOVERABLE error returned by algorithm. "
                        "Skipping remaining algorithms.\n"
                        "\tNo output will be written for this event, "
                        "but job will continue to next event" );
      eventFailed = false;
    }

    if (m_failureMode >= 2) {
      ATH_MSG_INFO ( "Skipping remaining algorithms.\n"
                     "\tNo output will be written for this event, "
                     "but job will continue to next event" );
      eventFailed = false;
    }
 
  }  else {
 
    m_aess->setEventStatus( EventStatus::Success, ctx );
 
    // Call the execute() method of all output streams 
    for (ListAlg::iterator ito = m_outStreamList.begin(); 
     ito != m_outStreamList.end(); ++ito ) {
      sc = (*ito)->sysExecute(ctx); 
      if( !sc.isSuccess() ) {
    eventFailed = true; 
      } 
    }
    
    writeHistograms().ignore();
 
  }
 
  // Fire EndEvent "Incident"
  //m_incidentSvc->fireIncident(Incident(*pEvent, name(),"EndEvent"));
  ++m_proc;
  }  // end of toolsPassed test
  ++m_nev;
  if (doEvtHeartbeat) {
      if(!m_intervalInSeconds) {
          if (!m_useTools)
              ATH_MSG_INFO("  ===>>>  done processing event #{}, run #{} {} events processed so far  <<<===",
                           evtNumber, m_currentRun, m_nev);
          else
              ATH_MSG_INFO("  ===>>>  done processing event #{}, run #{} {} events read and {} events processed so far <<<===",
                           evtNumber, m_currentRun, m_nev, m_proc);
      }
   std::ofstream outfile( "eventLoopHeartBeat.txt");
   if ( !outfile ) {
     ATH_MSG_ERROR ( " unable to open: eventLoopHeartBeat.txt" );
   } else {
     std::println (outfile, "  done processing event #{}, run #{} {} events read so far  <<<===",
                   evtNumber, m_currentRun, m_nev);
     outfile.close();
   }  
 
  }
 
  //------------------------------------------------------------------------
  // Check if there was an error processing current event
  //------------------------------------------------------------------------
  return eventFailed?StatusCode::FAILURE:StatusCode::SUCCESS;
  
}

executeRun()

StatusCode AthenaEventLoopMgr::executeRun ( int maxevt )

overridevirtual

implementation of IEventProcessor::executeRun(int maxevt)

Definition at line 701 of file AthenaEventLoopMgr.cxx.

{
  if (!(this->nextEvent(maxevt)).isSuccess()) return StatusCode::FAILURE;
  m_incidentSvc->fireIncident(Incident(name(),"EndEvtLoop"));
  m_incidentSvc->fireIncident(Incident(name(),IncidentType::EndRun));
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode AthenaEventLoopMgr::finalize ( )

overridevirtual

implementation of IAppMgrUI::finalize

Reimplemented in PyAthenaEventLoopMgr.

Definition at line 379 of file AthenaEventLoopMgr.cxx.

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

handle()

void AthenaEventLoopMgr::handle ( const Incident & inc )

overridevirtual

IIncidentListenet interfaces.

Definition at line 916 of file AthenaEventLoopMgr.cxx.

{
  if(inc.type()!="BeforeFork")
    return;
 
  if(!m_firstRun) {
    ATH_MSG_WARNING ( "Skipping BeforeFork handler. Begin run has already passed" );
    return;
  }
 
  // Initialize Algorithms and Output Streams
  StatusCode sc = initializeAlgorithms();
  if(sc.isFailure()) {
    ATH_MSG_ERROR ( "Failed to initialize Algorithms" );
    return; 
  }
 
  if(!m_evtSelCtxt) {
    ATH_MSG_WARNING ( "Skipping BeforeFork handler. No event selector is provided" );
    return;
  }
 
  // Construct EventInfo
  IOpaqueAddress* addr = nullptr;
  sc = m_evtSelector->next(*m_evtSelCtxt);
  if(!sc.isSuccess()) {
    ATH_MSG_INFO ( "No more events in event selection " );
    return;
  }
  sc = m_evtSelector->createAddress(*m_evtSelCtxt, addr);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "Could not create an IOpaqueAddress" );
    return; 
  }
  if (nullptr != addr) {
    //create its proxy
    sc = m_eventStore->recordAddress(addr);
    if(!sc.isSuccess()) {
      ATH_MSG_ERROR ( "Error declaring Event object" );
      return;
    }
  } 
  
  if(m_eventStore->loadEventProxies().isFailure()) {
    ATH_MSG_WARNING ( "Error loading Event proxies" );
    return;
  }
 
  // Need to make sure we have a valid EventContext in place before
  // doing anything that could fire incidents.
  EventContext ctx;
  // In the case of the BeginRun incident, we just want to take the
  // next IoV from the list in the EvtIdModifierSvc, but leave it to
  // be used for the next executeEvent call. TODO CHECK
  if( installEventContext(ctx).isFailure() ) {
    throw std::runtime_error( "Error installing event context object" );
  }
 
  m_incidentSvc->fireIncident(Incident(name(),IncidentType::BeginRun,ctx));
  m_firstRun=false;
  m_currentRun = ctx.eventID().run_number();
 
  // Execute requested algorithms/sequences
  if ( execAtPreFork(ctx).isFailure() ) {
    ATH_MSG_ERROR ( "Unable to execute requested algorithms/sequences during PreFork!" );
    return;
  }
 
  // Clear Store
  const ClearStorePolicy::Type s_clearStore = clearStorePolicy( m_clearStorePolicy.value(), msgStream() );
  if(s_clearStore==ClearStorePolicy::EndEvent) {
    sc = m_eventStore->clearStore();
    if(!sc.isSuccess()) {
      ATH_MSG_ERROR ( "Clear of Event data store failed" );
    }
  }
}

initialize()

StatusCode AthenaEventLoopMgr::initialize ( )

overridevirtual

implementation of IAppMgrUI::initalize

Reimplemented in PyAthenaEventLoopMgr.

Definition at line 125 of file AthenaEventLoopMgr.cxx.

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

initializeAlgorithms()

StatusCode AthenaEventLoopMgr::initializeAlgorithms ( )

protected

Initialize all algorithms and output streams.

Definition at line 482 of file AthenaEventLoopMgr.cxx.

                                                    {
 
  // Initialize the list of Algorithms. Note that existing Algorithms
  // are protected against multiple initialization attempts.
  ListAlg::iterator ita;
  for ( ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ++ita )
    {
      StatusCode sc = (*ita)->sysInitialize();
      if( sc.isFailure() )
    {
      ATH_MSG_ERROR( "Unable to initialize Algorithm: {}", (*ita)->name()) ;
      return sc;
    }
    }
 
  // Initialize the list of Output Streams. Note that existing Output Streams
  // are protected against multiple initialization attempts.
  for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ++ita )
    {
      StatusCode sc = (*ita)->sysInitialize();
      if( sc.isFailure() ) {
    ATH_MSG_ERROR ( "Unable to initialize Output Stream: {}", (*ita)->name() );
    return sc;
      }
 
    }
 
  return StatusCode::SUCCESS;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

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

installEventContext()

StatusCode AthenaEventLoopMgr::installEventContext ( EventContext & ctx )

private

Definition at line 1015 of file AthenaEventLoopMgr.cxx.

                                                                    {
  // first get EventInfo and conditionsRun
  std::unique_ptr<EventInfo> eventInfo;
  EventID eventID;
  unsigned int conditionsRun = EventIDBase::UNDEFNUM;
  bool consume_modifier_stream = false;  // FIXME/CHECK: was true inside TP converter and checks for active storegate
 
  // Event index for run-dependent EventID modification: m_nevt-1 in serial,
  // or the absolute index supplied by the AthenaMP consumer (chunk base +
  // in-chunk offset derived from m_nevt without mutating state).
  m_curEvtModIdx = (m_evtModIdxBase < 0)
                     ? static_cast<long>(m_nevt - 1)
                     : (m_evtModIdxBase + (m_nevt - m_evtModBaseNevt - 1));
 
  if (m_evtSelCtxt) {  // Deal with the case when an EventSelector is provided
    // First try to build a legacy EventInfo object from the TAG information
    // Read the attribute list
    const AthenaAttributeList* pAttrList =
        m_eventStore->tryConstRetrieve<AthenaAttributeList>("Input");
    if (pAttrList != nullptr && pAttrList->size() > 6) {  
      // Try making EventID-only EventInfo object from in-file TAG
      try {
        unsigned int runNumber = (*pAttrList)["RunNumber"].data<unsigned int>();
        unsigned long long eventNumber = (*pAttrList)["EventNumber"].data<unsigned long long>();
        unsigned int eventTime = (*pAttrList)["EventTime"].data<unsigned int>();
        unsigned int eventTimeNS = (*pAttrList)["EventTimeNanoSec"].data<unsigned int>();
        unsigned int lumiBlock = (*pAttrList)["LumiBlockN"].data<unsigned int>();
        unsigned int bunchId = (*pAttrList)["BunchId"].data<unsigned int>();
 
        ATH_MSG_DEBUG("use TAG with runNumber={}", runNumber);
        consume_modifier_stream = true;
        // an option to override primary eventNumber with the secondary one in
        // case of DoubleEventSelector
        if (m_useSecondaryEventNumber) {
          unsigned long long eventNumberSecondary{};
          if (!(pAttrList->exists("hasSecondaryInput") &&
                (*pAttrList)["hasSecondaryInput"].data<bool>())) {
            ATH_MSG_FATAL("Secondary EventNumber requested, but secondary input does not exist!");
            return StatusCode::FAILURE;
          }
          if (pAttrList->exists("EventNumber_secondary")) {
            eventNumberSecondary = (*pAttrList)["EventNumber_secondary"].data<unsigned long long>();
          } else {
            // try legacy EventInfo if secondary input did not have attribute
            // list primary input should not have this EventInfo type
            const EventInfo* pEventSecondary = m_eventStore->tryConstRetrieve<EventInfo>();
            if (pEventSecondary) {
              eventNumberSecondary = pEventSecondary->event_ID()->event_number();
            } else {
              ATH_MSG_FATAL("Secondary EventNumber requested, but it does not exist!");
              return StatusCode::FAILURE;
            }
          }
          if (eventNumberSecondary != 0) {
            bool doEvtHeartbeat(m_eventPrintoutInterval.value() > 0 &&
                                0 == (m_nev % m_eventPrintoutInterval.value()));
            if (doEvtHeartbeat) {
              ATH_MSG_INFO("  ===>>>  using secondary event #{} instead of #{}  <<<===",
                           eventNumberSecondary, eventNumber);
            }
            eventNumber = eventNumberSecondary;
          }
        }
 
        eventInfo = std::make_unique<EventInfo>(
            std::make_unique<EventID>(runNumber, eventNumber, eventTime,
                                      eventTimeNS, lumiBlock, bunchId),
            nullptr);
        eventID = *(eventInfo->event_ID());
 
        if (!m_evtIdModSvc.isSet() && pAttrList->exists("ConditionsRun")) {
          conditionsRun = (*pAttrList)["ConditionsRun"].data<unsigned int>();
        } else {
          conditionsRun = runNumber;
        }
 
      } catch (...) {
      }
      /* FIXME: PvG, not currently written
      if( pEvent != 0 && pAttrList->size() > 7 ) {
        // Try adding EventType information
        try { 
           float eventWeight = (*pAttrList)["EventWeight"].data<float>(); 
           const EventType* pType = new EventType(); pEvent->setEventType(pType);
           pEvent->event_type()->set_mc_event_weight(eventWeight);
        } catch (...) {
           pEvent->setEventType(0);
        }
      }
      */
    } else if (m_requireInputAttributeList) {
      ATH_MSG_FATAL("Valid input attribute list required but not present!");
      return StatusCode::FAILURE;
    }
    // In the case that there is no TAG information
    if( !eventInfo ) {
      // Secondly try to retrieve a legacy EventInfo object from the input file
      EventInfoCnvParams::eventIndex = m_curEvtModIdx;
      const EventInfo* pei = m_eventStore->tryConstRetrieve<EventInfo>();
      if( pei ) {
        eventID = *(pei->event_ID());
      } else {
        // Finally try to retrieve an xAOD::EventInfo object from the
        // input file and build a legacy EventInfo object from that.
        const xAOD::EventInfo* xAODEvent = m_eventStore->tryConstRetrieve<xAOD::EventInfo>();
        if (xAODEvent == nullptr) {
          ATH_MSG_ERROR("Failed to get EventID from input. Tried old-style and xAOD::EventInfo");
          return StatusCode::FAILURE;
        }
        ATH_MSG_DEBUG("use xAOD::EventInfo with runNumber={}", xAODEvent->runNumber());
        // Record the old-style object for those clients that still need it
        eventInfo = std::make_unique<EventInfo>(
            std::make_unique<EventID>(eventIDFromxAOD(xAODEvent)),
            std::make_unique<EventType>(eventTypeFromxAOD(xAODEvent)));
        eventID = *(eventInfo->event_ID());
        StatusCode sc = m_eventStore->record(std::move(eventInfo), "");
        if (!sc.isSuccess()) {
          ATH_MSG_ERROR("Error declaring event data object");
          return StatusCode::FAILURE;
        }
      }
    }
  } else {
    // No EventSelector is provided, so with no iterator it's up to us
    // to create an EventInfo
    eventInfo = std::make_unique<EventInfo>(
        std::make_unique<EventID>(1, m_nevt, 0), std::make_unique<EventType>());
    eventInfo->event_ID()->set_lumi_block(m_nevt);
    eventID = *(eventInfo->event_ID());
    StatusCode sc = m_eventStore->record(std::move(eventInfo), "");
    if (!sc.isSuccess()) {
      ATH_MSG_ERROR("Error declaring event data object");
      return (StatusCode::FAILURE);
    }
  }
 
  ctx.setEventID( eventID );
  ctx.set(m_nev,0);
  Atlas::setExtendedEventContext(ctx,
                                 Atlas::ExtendedEventContext( m_eventStore->hiveProxyDict(),
                                                              conditionsRun) );
  modifyEventContext(ctx, eventID, consume_modifier_stream);
  Gaudi::Hive::setCurrentContext( ctx );
 
  m_aess->reset( ctx );
  if (m_eventStore->record(std::make_unique<EventContext> ( ctx ),
                           "EventContext").isFailure())
  {
    ATH_MSG_ERROR ( "Error recording event context object" );
    return (StatusCode::FAILURE);
  }
 
  return StatusCode::SUCCESS;
}

modifyEventContext()

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

virtual

Definition at line 1172 of file AthenaEventLoopMgr.cxx.

                                                                                                               {
  if (m_evtIdModSvc.isSet()) {
    EventID new_eID(eID);
    m_evtIdModSvc->modify_evtid(new_eID, m_curEvtModIdx, consume_modifier_stream);
    if (msgLevel(MSG::DEBUG)) {
      unsigned int oldrunnr=eID.run_number();
      unsigned int oldLB=eID.lumi_block();
      unsigned int oldTS=eID.time_stamp();
      unsigned int oldTSno=eID.time_stamp_ns_offset();
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc runnr={} -> {}",
                      oldrunnr, new_eID.run_number());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc LB={} -> {}",
                      oldLB, new_eID.lumi_block());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp={} -> {}",
                      oldTS, new_eID.time_stamp());
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp ns Offset={} -> {}",
                      oldTSno, new_eID.time_stamp_ns_offset());
    }
    ctx.setEventID( new_eID );
    Atlas::getExtendedEventContext(ctx).setConditionsRun( ctx.eventID().run_number() );
    return;
  }
 
  ctx.setEventID( eID );
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inline

The standard message stream.

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

Definition at line 92 of file AthMessaging.h.

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

msg() [2/2]

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

inline

The standard message stream.

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

Definition at line 99 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

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

inline

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 86 of file AthMessaging.h.

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

name()

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

inlineoverridevirtual

Definition at line 188 of file AthenaEventLoopMgr.h.

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

nextEvent()

StatusCode AthenaEventLoopMgr::nextEvent ( int maxevt )

overridevirtual

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

Reimplemented in MultipleEventLoopMgr.

Definition at line 713 of file AthenaEventLoopMgr.cxx.

{
  // make nextEvent(0) a dummy call
  if (0 == maxevt) return StatusCode::SUCCESS;
 
  static std::atomic<int> total_nevt = 0;
 
  // the current 'clear-store' policy
  static const ClearStorePolicy::Type s_clearStore = 
    clearStorePolicy( m_clearStorePolicy.value(), msgStream() );
 
 
  // These following two initialization loops are performed here in case new
  // Top level Algorithms or Output Streams have been created interactively
  // at run-time instead of configuration time. Note also that it is possible
  // that some newly created Algorithms are still not initialized as a result
  // of these loops (e.g. where the membership of an existing Sequencer is 
  // changed at run-time. In this case, the Algorithm::sysExecute() function 
  // will ensure that the Algorithm is correctly initialized. This mechanism 
  // actually makes loops redundant, but they do  provide a well defined 
  // location for the initialization to take place in the non-interactive case.
 
  StatusCode sc = initializeAlgorithms();
  if(sc.isFailure())
    return sc;
 
  // loop over events if the maxevt (received as input) is different from -1.
  // if evtmax is -1 it means infinite loop
 
  while(maxevt == -1 || m_nevt < maxevt) {
 
   if(m_doChrono && total_nevt>0) m_chronoStatSvc->chronoStart("EventLoopMgr"); //start after first event
   if(m_doChrono && total_nevt>0) m_chronoStatSvc->chronoStart("EventLoopMgr_preexec");
 
    // Check if there is a scheduled stop issued by some algorithm/sevice
    if ( m_scheduledStop ) {
      m_scheduledStop = false;
      ATH_MSG_ALWAYS ( "A stopRun was requested. Terminating event loop." );
      break;
    }
 
   
 
    ++m_nevt; ++total_nevt; 
    //-----------------------------------------------------------------------
    // Clear the event store, if used in the event loop
    //-----------------------------------------------------------------------
    if( s_clearStore == ClearStorePolicy::BeginEvent &&
    0 != total_nevt ) {
      sc = m_eventStore->clearStore();
      if( !sc.isSuccess() ) {
    ATH_MSG_ERROR (  "Clear of Event data store failed" );
        m_incidentSvc->fireIncident(Incident(name(),"EndEvtLoop"));
    return sc;
      }
    }
 
 
 
    //-----------------------------------------------------------------------
    // we need an EventInfo Object to fire the incidents. 
    //-----------------------------------------------------------------------
    if ( m_evtSelCtxt )
    {   // Deal with the case when an EventSelector is provided
 
      IOpaqueAddress* addr = nullptr;
 
      sc = m_evtSelector->next(*m_evtSelCtxt);
 
      if ( !sc.isSuccess() )
      {
        // This is the end of the loop. No more events in the selection
        ATH_MSG_INFO ( "No more events in event selection " );
    sc = StatusCode::SUCCESS;
        break;
      }
 
      if (m_evtSelector->createAddress(*m_evtSelCtxt, addr).isFailure()) {
        ATH_MSG_ERROR ( "Could not create an IOpaqueAddress" );
        break;
      }
      
 
      // Most iterators provide the IOA of an event header (EventInfo, DataHeader)
      if (nullptr != addr) {
    //create its proxy
    sc = m_eventStore->recordAddress(addr);
    if( !sc.isSuccess() ) {
      ATH_MSG_WARNING ( "Error declaring Event object" );
      continue;
    }
      } 
      if ((sc=m_eventStore->loadEventProxies()).isFailure()) {
    ATH_MSG_ERROR ( "Error loading Event proxies" );
    continue;
      } 
    }
    if(m_doChrono && total_nevt>1) m_chronoStatSvc->chronoStop("EventLoopMgr_preexec");
    if(m_doChrono && total_nevt>1) m_chronoStatSvc->chronoStart("EventLoopMgr_execute");
    // create an empty EventContext that will get set inside executeEvent
    EventContext ctx;
    // Execute event for all required algorithms
    sc = executeEvent( std::move( ctx ) );
    if(m_doChrono && total_nevt>1) m_chronoStatSvc->chronoStop("EventLoopMgr_execute");
    if(m_doChrono && total_nevt>1) m_chronoStatSvc->chronoStart("EventLoopMgr_postexec");
    if( !sc.isSuccess() )
    {
      ATH_MSG_ERROR ( "Terminating event processing loop due to errors" );
      break;
    }
 
    //-----------------------------------------------------------------------
    // Clear the event store, if used in the event loop
    //-----------------------------------------------------------------------
    if ( s_clearStore == ClearStorePolicy::EndEvent ) {
      sc = m_eventStore->clearStore();
      if( !sc.isSuccess() ) {
        ATH_MSG_ERROR ( "Clear of Event data store failed" );
    break;
      }
    }
    if(m_doChrono && total_nevt>1) m_chronoStatSvc->chronoStop("EventLoopMgr_postexec");
    if(m_doChrono && total_nevt>1) m_chronoStatSvc->chronoStop("EventLoopMgr");
  } //event loop
 
   
 
  return sc;
 
}

operator=()

AthenaEventLoopMgr & AthenaEventLoopMgr::operator= ( const AthenaEventLoopMgr & )

private

no implementation

resetTimeout()

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

inlineprotectedinherited

Reset timeout.

Definition at line 83 of file Timeout.h.

{ instance.reset(); }

seek()

StatusCode AthenaEventLoopMgr::seek ( int evt )

overridevirtual

Seek to a given event.

Definition at line 849 of file AthenaEventLoopMgr.cxx.

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

setClearStorePolicy()

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

protected

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

Definition at line 314 of file AthenaEventLoopMgr.cxx.

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

setLevel()

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

inherited

Change the current logging level.

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

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setNextEventModifierIndex()

void AthenaEventLoopMgr::setNextEventModifierIndex ( long idx )

overridevirtual

Supply absolute input event index for EvtIdModifierSvc. See IEventSeek.h.

Definition at line 885 of file AthenaEventLoopMgr.cxx.

{
  m_evtModIdxBase  = idx;
  m_evtModBaseNevt = m_nevt;
}

setTimeout()

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

inlineprotectedinherited

Set timeout.

Definition at line 80 of file Timeout.h.

{ instance.set(); }

setupPreSelectTools()

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

protected

property update handler:sets up the Pre-selection tools

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

overridevirtual

Return the size of the collection.

Definition at line 894 of file AthenaEventLoopMgr.cxx.

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

stopRun()

StatusCode AthenaEventLoopMgr::stopRun ( )

overridevirtual

Called from ApplicationMgr::stopRun() to terminate the loop.

Definition at line 366 of file AthenaEventLoopMgr.cxx.

{
  ATH_MSG_DEBUG("In stopRun()");
  CHECK( MinimalEventLoopMgr::stopRun() );
  // change the appMgr return code to ScheduledStop so no errors are reported
  auto appProp = m_appMgrUI.as<IProperty>();
  CHECK( Gaudi::setAppReturnCode( appProp, Gaudi::ReturnCode::ScheduledStop, true ) );
  return StatusCode::SUCCESS;
}

writeHistograms()

StatusCode AthenaEventLoopMgr::writeHistograms ( bool force = false )

protectedvirtual

Dump out histograms as needed.

Definition at line 426 of file AthenaEventLoopMgr.cxx.

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

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_aess

SmartIF<IAlgExecStateSvc> AthenaEventLoopMgr::m_aess

protected

Reference to the Algorithm Execution State Svc.

Definition at line 152 of file AthenaEventLoopMgr.h.

m_chronoStatSvc

ServiceHandle<IChronoStatSvc> AthenaEventLoopMgr::m_chronoStatSvc

private

Definition at line 222 of file AthenaEventLoopMgr.h.

m_clearStorePolicy

StringProperty AthenaEventLoopMgr::m_clearStorePolicy

protected

Definition at line 135 of file AthenaEventLoopMgr.h.

m_conditionsCleaner

ServiceHandle<Athena::IConditionsCleanerSvc> AthenaEventLoopMgr::m_conditionsCleaner

private

Definition at line 223 of file AthenaEventLoopMgr.h.

m_curEvtModIdx

long AthenaEventLoopMgr::m_curEvtModIdx {-1}

private

Definition at line 206 of file AthenaEventLoopMgr.h.

{-1};

m_currentRun

number_type AthenaEventLoopMgr::m_currentRun

protected

current run number

Definition at line 102 of file AthenaEventLoopMgr.h.

m_doChrono

bool AthenaEventLoopMgr::m_doChrono = false

private

Definition at line 221 of file AthenaEventLoopMgr.h.

m_eventPrintoutInterval

UnsignedIntegerProperty AthenaEventLoopMgr::m_eventPrintoutInterval

protected

Definition at line 109 of file AthenaEventLoopMgr.h.

m_eventStore

StoreGateSvc_t AthenaEventLoopMgr::m_eventStore

protected

Reference to StoreGateSvc;.

Property

Definition at line 73 of file AthenaEventLoopMgr.h.

m_evtIdModSvc

IEvtIdModifierSvc_t AthenaEventLoopMgr::m_evtIdModSvc

protected

Definition at line 92 of file AthenaEventLoopMgr.h.

m_evtModBaseNevt

int AthenaEventLoopMgr::m_evtModBaseNevt {0}

private

Definition at line 205 of file AthenaEventLoopMgr.h.

{0};

m_evtModIdxBase

long AthenaEventLoopMgr::m_evtModIdxBase {-1}

private

Definition at line 204 of file AthenaEventLoopMgr.h.

{-1};

m_evtsel

StringProperty AthenaEventLoopMgr::m_evtsel

protected

Definition at line 80 of file AthenaEventLoopMgr.h.

m_evtSelCtxt

IEvtSelector::Context* AthenaEventLoopMgr::m_evtSelCtxt

protected

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

Definition at line 78 of file AthenaEventLoopMgr.h.

m_evtSelector

IEvtSelector* AthenaEventLoopMgr::m_evtSelector

protected

Reference to the Event Selector.

Definition at line 76 of file AthenaEventLoopMgr.h.

m_execAtPreFork

StringArrayProperty AthenaEventLoopMgr::m_execAtPreFork

protected

Definition at line 95 of file AthenaEventLoopMgr.h.

m_failureMode

IntegerProperty AthenaEventLoopMgr::m_failureMode

protected

Definition at line 106 of file AthenaEventLoopMgr.h.

m_firstRun

bool AthenaEventLoopMgr::m_firstRun

protected

Definition at line 103 of file AthenaEventLoopMgr.h.

m_histoDataMgrSvc

IDataManagerSvc_t AthenaEventLoopMgr::m_histoDataMgrSvc

protected

Reference to the Histogram Data Service.

Definition at line 84 of file AthenaEventLoopMgr.h.

m_histoPersSvc

IConversionSvc_t AthenaEventLoopMgr::m_histoPersSvc

protected

Definition at line 88 of file AthenaEventLoopMgr.h.

m_histPersName

StringProperty AthenaEventLoopMgr::m_histPersName

protected

Definition at line 98 of file AthenaEventLoopMgr.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_incidentSvc

IIncidentSvc_t AthenaEventLoopMgr::m_incidentSvc

protected

Reference to the incident service.

Definition at line 69 of file AthenaEventLoopMgr.h.

m_intervalInSeconds

unsigned int AthenaEventLoopMgr::m_intervalInSeconds

private

Definition at line 217 of file AthenaEventLoopMgr.h.

m_lastNev

unsigned int AthenaEventLoopMgr::m_lastNev {}

private

Definition at line 216 of file AthenaEventLoopMgr.h.

{};

m_lastTime

time_t AthenaEventLoopMgr::m_lastTime {}

private

Definition at line 218 of file AthenaEventLoopMgr.h.

{};

m_liteLoop

bool AthenaEventLoopMgr::m_liteLoop

private

Definition at line 220 of file AthenaEventLoopMgr.h.

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

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

Definition at line 132 of file AthMessaging.h.

m_nev

unsigned int AthenaEventLoopMgr::m_nev

private

events processed

Definition at line 212 of file AthenaEventLoopMgr.h.

m_nevt

int AthenaEventLoopMgr::m_nevt {}

private

Definition at line 199 of file AthenaEventLoopMgr.h.

{};

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_proc

unsigned int AthenaEventLoopMgr::m_proc

private

Definition at line 213 of file AthenaEventLoopMgr.h.

m_requireInputAttributeList

bool AthenaEventLoopMgr::m_requireInputAttributeList {}

protected

require input attribute list

Definition at line 124 of file AthenaEventLoopMgr.h.

{};

m_toolAccept

tool_stats AthenaEventLoopMgr::m_toolAccept

protected

tool returns StatusCode::SUCCESS counter

Definition at line 120 of file AthenaEventLoopMgr.h.

m_toolInvoke

tool_stats AthenaEventLoopMgr::m_toolInvoke

protected

tool called counter

Definition at line 118 of file AthenaEventLoopMgr.h.

m_toolReject

tool_stats AthenaEventLoopMgr::m_toolReject

protected

tool returns StatusCode::FAILURE counter

Definition at line 119 of file AthenaEventLoopMgr.h.

m_tools

tool_store AthenaEventLoopMgr::m_tools

protected

internal tool store

Definition at line 121 of file AthenaEventLoopMgr.h.

m_useSecondaryEventNumber

bool AthenaEventLoopMgr::m_useSecondaryEventNumber {}

protected

read event number from secondary input

Definition at line 127 of file AthenaEventLoopMgr.h.

{};

m_useTools

bool AthenaEventLoopMgr::m_useTools

private

Definition at line 214 of file AthenaEventLoopMgr.h.

m_writeHists

bool AthenaEventLoopMgr::m_writeHists {}

private

Definition at line 209 of file AthenaEventLoopMgr.h.

{};

m_writeInterval

IntegerProperty AthenaEventLoopMgr::m_writeInterval

private

Definition at line 208 of file AthenaEventLoopMgr.h.

---

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

• AthenaEventLoopMgr.h
• AthenaEventLoopMgr.cxx