Implementation of the AthenaEventLoopMgr that allows selective and specific overrides in python. More...

#include <PyAthenaEventLoopMgr.h>

Inheritance diagram for PyAthenaEventLoopMgr:

Collaboration diagram for PyAthenaEventLoopMgr:

Public Types
typedef IEvtSelector::Context	EvtContext

Public Member Functions
	PyAthenaEventLoopMgr (const std::string &name, ISvcLocator *svcLoc)
	Standard Constructor.
	~PyAthenaEventLoopMgr ()
PyObject *	setManager (PyObject *)
	actual manager object
PyObject *	getManager ()
virtual StatusCode	initialize ()
	implementation of IAppMgrUI::initalize
virtual StatusCode	finalize ()
	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 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.

Static Public Member Functions
static PyAthenaEventLoopMgr *	pointer ()
	outside access

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
	PyAthenaEventLoopMgr ()
	Unimplemented features to keep Reflex happy.
	PyAthenaEventLoopMgr (const PyAthenaEventLoopMgr &)
PyAthenaEventLoopMgr &	operator= (const PyAthenaEventLoopMgr &)
virtual StatusCode	executeAlgorithms (const EventContext &)
	Run the algorithms for the current event.
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.
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
StatusCode	installEventContext (EventContext &ctx)
StoreGateSvc *	eventStore () const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
PyObject *	m_manager
int	m_nevt {}
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

Implementation of the AthenaEventLoopMgr that allows selective and specific overrides in python.

The idea is to maximize code-sharing with AthenaEventLoopMgr to reduce maintainance.

Definition at line 34 of file PyAthenaEventLoopMgr.h.

Member Typedef Documentation

◆ EvtContext

typedef IEvtSelector::Context AthenaEventLoopMgr::EvtContext

inherited

Definition at line 64 of file AthenaEventLoopMgr.h.

◆ IConversionSvc_t

typedef ServiceHandle<IConversionSvc> AthenaEventLoopMgr::IConversionSvc_t

protectedinherited

Definition at line 86 of file AthenaEventLoopMgr.h.

◆ IDataManagerSvc_t

typedef ServiceHandle<IDataManagerSvc> AthenaEventLoopMgr::IDataManagerSvc_t

protectedinherited

Definition at line 82 of file AthenaEventLoopMgr.h.

◆ IEvtIdModifierSvc_t

typedef ServiceHandle<IEvtIdModifierSvc> AthenaEventLoopMgr::IEvtIdModifierSvc_t

protectedinherited

Definition at line 90 of file AthenaEventLoopMgr.h.

◆ IIncidentSvc_t

typedef ServiceHandle<IIncidentSvc> AthenaEventLoopMgr::IIncidentSvc_t

protectedinherited

Definition at line 67 of file AthenaEventLoopMgr.h.

◆ number_type

typedef EventID::number_type AthenaEventLoopMgr::number_type

protectedinherited

Definition at line 100 of file AthenaEventLoopMgr.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthenaEventLoopMgr::StoreGateSvc_t

protectedinherited

Definition at line 71 of file AthenaEventLoopMgr.h.

◆ tool_iterator

typedef tool_store::const_iterator AthenaEventLoopMgr::tool_iterator

protectedinherited

Definition at line 114 of file AthenaEventLoopMgr.h.

◆ tool_stats

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

protectedinherited

Definition at line 115 of file AthenaEventLoopMgr.h.

◆ tool_stats_iterator

typedef tool_stats::const_iterator AthenaEventLoopMgr::tool_stats_iterator

protectedinherited

Definition at line 116 of file AthenaEventLoopMgr.h.

◆ tool_store

typedef ToolHandleArray< tool_type > AthenaEventLoopMgr::tool_store

protectedinherited

Definition at line 113 of file AthenaEventLoopMgr.h.

◆ tool_type

typedef IAthenaEvtLoopPreSelectTool AthenaEventLoopMgr::tool_type

protectedinherited

Definition at line 112 of file AthenaEventLoopMgr.h.

Constructor & Destructor Documentation

◆ PyAthenaEventLoopMgr() [1/3]

PyAthenaEventLoopMgr::PyAthenaEventLoopMgr	(	const std::string &	name,
		ISvcLocator *	svcLoc )

Standard Constructor.

overrides the base-class default: for interactive use, it is mandatory to leave the store untouched at the end of the event (so people can interactively browse the store). Hence, we ask for store clean-up at the beginning of the event.

Definition at line 67 of file PyAthenaEventLoopMgr.cxx.

   : AthenaEventLoopMgr( name, svcLoc ), m_manager( nullptr )
{
  AthenaEventLoopMgr::m_clearStorePolicy.set( "BeginEvent" );
}

◆ ~PyAthenaEventLoopMgr()

PyAthenaEventLoopMgr::~PyAthenaEventLoopMgr ( )

inline

Definition at line 38 of file PyAthenaEventLoopMgr.h.

38{}

◆ PyAthenaEventLoopMgr() [2/3]

PyAthenaEventLoopMgr::PyAthenaEventLoopMgr ( )

protected

Unimplemented features to keep Reflex happy.

◆ PyAthenaEventLoopMgr() [3/3]

PyAthenaEventLoopMgr::PyAthenaEventLoopMgr ( const PyAthenaEventLoopMgr & )

protected

Member Function Documentation

◆ curEvent()

int AthenaEventLoopMgr::curEvent ( ) const

overridevirtualinherited

Return the current event count.

Definition at line 889 of file AthenaEventLoopMgr.cxx.

{
  return m_nevt;
}

◆ eventStore()

StoreGateSvc * AthenaEventLoopMgr::eventStore ( ) const

privateinherited

Definition at line 1017 of file AthenaEventLoopMgr.cxx.

                                     {
  return m_eventStore.get();
}

◆ execAtPreFork()

StatusCode AthenaEventLoopMgr::execAtPreFork ( const EventContext & ctx ) const

inherited

Execute certain algorithms/sequences in PreFork.

Definition at line 1000 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 PyAthenaEventLoopMgr::executeAlgorithms ( const EventContext & ctx )

protectedvirtual

Run the algorithms for the current event.

Reimplemented from AthenaEventLoopMgr.

Definition at line 186 of file PyAthenaEventLoopMgr.cxx.

{
   RootUtils::PyGILStateEnsure gil;
// forward to call to the python-side object
   if ( m_manager != nullptr )
   {
   // forward call, if python side manager available
     PyObject* pycontext = PyCapsule_New ( const_cast<EventContext*>(&ctx), nullptr, nullptr);
      PyObject* result = PyObject_CallMethod( m_manager, execalgs,
                                              (char*)"O", pycontext);
      Py_DECREF (pycontext);
 
      if ( ! result )
      {
      PyErr_Print();            // should use MessageSvc instead
      return StatusCode::FAILURE;
      }
 
      if ( PyLong_Check( result ) )
      {
     StatusCode sc = StatusCode( (int) PyLong_AS_LONG( result ) );
         Py_DECREF( result );
         return sc;
      }
 
   // FIXME: allow python result to be a statuscode
      MsgStream log( msgSvc(), name() );
      log << MSG::ERROR
      << "result from python event loop manager has unexpected type."
      << endmsg;
      Py_DECREF( result );
      return StatusCode::FAILURE;
   }
 
// otherwise, let base class handle it
   return AthenaEventLoopMgr::executeAlgorithms(ctx);
}

◆ executeEvent()

StatusCode AthenaEventLoopMgr::executeEvent ( EventContext && ctx )

overridevirtualinherited

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 552 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 #" << evtNumber << ", run #" << m_currentRun << " " << m_nev << " events processed so far  <<<===" );
        if(m_intervalInSeconds) {
            ATH_MSG_INFO(" ===>>> Event processing rate = " << double(m_nev-m_lastNev)/(time(nullptr)-m_lastTime) << " Hz <<<===");
            m_lastNev = m_nev; m_lastTime = time(nullptr);
        }
    }
 
   else ATH_MSG_INFO ( "  ===>>>  start processing event #" << evtNumber << ", run #" << m_currentRun 
    << " " << m_nev << " events read and " << m_proc 
        << " events processed so far  <<<===" );   
  }
 
  // 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." << std::endl
                << "\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." << std::endl
             << "\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 #" << evtNumber << ", run #" << m_currentRun
                                                               << " " << m_nev << " events processed so far  <<<===");
          else
              ATH_MSG_INFO("  ===>>>  done processing event #" << evtNumber << ", run #" << m_currentRun
                                                               << " " << m_nev << " events read and " << m_proc
                                                               << " events processed so far <<<===");
      }
   std::ofstream outfile( "eventLoopHeartBeat.txt");
   if ( !outfile ) {
     ATH_MSG_ERROR ( " unable to open: eventLoopHeartBeat.txt" );
   } else {
     outfile << "  done processing event #" << evtNumber << ", run #" << m_currentRun 
         << " " << m_nev << " events read so far  <<<===" << std::endl;
     outfile.close();
   }  
 
  }
 
  //------------------------------------------------------------------------
  // Check if there was an error processing current event
  //------------------------------------------------------------------------
  return eventFailed?StatusCode::FAILURE:StatusCode::SUCCESS;
  
}

◆ executeRun()

StatusCode AthenaEventLoopMgr::executeRun ( int maxevt )

overridevirtualinherited

implementation of IEventProcessor::executeRun(int maxevt)

Definition at line 711 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 PyAthenaEventLoopMgr::finalize ( )

virtual

implementation of IAppMgrUI::finalize

Reimplemented from AthenaEventLoopMgr.

Definition at line 228 of file PyAthenaEventLoopMgr.cxx.

{
   RootUtils::PyGILStateEnsure gil;
   Py_XDECREF( m_manager );
 
   return this->AthenaEventLoopMgr::finalize();
}

◆ getManager()

PyObject * PyAthenaEventLoopMgr::getManager ( )

Definition at line 124 of file PyAthenaEventLoopMgr.cxx.

{
   RootUtils::PyGILStateEnsure gil;
   if ( ! m_manager )
   {
      Py_INCREF( Py_None );
      return Py_None;
   }
      
   Py_INCREF( m_manager );
   return m_manager;
}

◆ handle()

void AthenaEventLoopMgr::handle ( const Incident & inc )

overridevirtualinherited

IIncidentListenet interfaces.

Definition at line 919 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 = eventStore()->recordAddress(addr);
    if(!sc.isSuccess()) {
      ATH_MSG_ERROR ( "Error declaring Event object" );
      return;
    }
  } 
  
  if(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 = eventStore()->clearStore();
    if(!sc.isSuccess()) {
      ATH_MSG_ERROR ( "Clear of Event data store failed" );
    }
  }
}

◆ initialize()

StatusCode PyAthenaEventLoopMgr::initialize ( )

virtual

implementation of IAppMgrUI::initalize

Reimplemented from AthenaEventLoopMgr.

Definition at line 141 of file PyAthenaEventLoopMgr.cxx.

{
   RootUtils::PyGILStateEnsure gil;
// get the PyAthenaEventLoopMgr python-side class
   PyObject* modpyelm = PyImport_ImportModule( const_cast< char* >( "AthenaServices.PyAthenaEventLoopMgr" ) );
   if ( modpyelm ) {
 
      PyObject* pyelm = PyObject_GetAttrString( modpyelm, const_cast< char* >( "PyAthenaEventLoopMgr" ) );
      Py_DECREF( modpyelm );
 
      if ( pyelm ) {
         PyObject* args = PyTuple_New( 0 );
         PyObject* self = PyObject_Call( pyelm, args, nullptr );
         Py_DECREF( args );
         Py_DECREF( pyelm );
 
         if ( self ) {
         // initialize base class, which then allows queryInterface as appropriate
            StatusCode sc = this->AthenaEventLoopMgr::initialize();
 
         // set the interfaces on the python-side manager
            PyObject* result = setManager( self );
            Py_DECREF( self );
 
            if ( ! result ) {
               PyErr_Print();
               sc.ignore();
               return StatusCode::FAILURE;
            }
 
            return sc;
         }
 
      }
 
   }
 
   PyErr_Print();
   return StatusCode::FAILURE;
}

◆ initializeAlgorithms()

StatusCode AthenaEventLoopMgr::initializeAlgorithms ( )

protectedinherited

Initialize all algorithms and output streams.

Definition at line 491 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 )

privateinherited

Definition at line 1025 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
  
  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 =
        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 = 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 #"
                           << eventNumberSecondary << " instead of #"
                           << 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
      // m_nevt - 1 because it's incremented early
      EventInfoCnvParams::eventIndex = m_nevt - 1;
      const EventInfo* pei = 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 = 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 = 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 = 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( eventStore()->hiveProxyDict(),
                                                              conditionsRun) );
  modifyEventContext(ctx, eventID, consume_modifier_stream);
  Gaudi::Hive::setCurrentContext( ctx );
 
  m_aess->reset( ctx );
  if (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 )

virtualinherited

Definition at line 1177 of file AthenaEventLoopMgr.cxx.

                                                                                                               {
  if (m_evtIdModSvc.isSet()) {
    EventID new_eID(eID);
    // m_nevt - 1 because it's incremented early
    m_evtIdModSvc->modify_evtid(new_eID, m_nevt - 1, 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

inlineinherited

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

inlineinherited

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.

179{ return msg() << lvl; }

AthenaEventLoopMgr::msg

MsgStream & msg() const

The standard message stream.

Definition AthMessaging.h:163

◆ msgLvl()

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

inlineinherited

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 (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

◆ name()

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

inlineoverridevirtualinherited

Definition at line 186 of file AthenaEventLoopMgr.h.

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

◆ nextEvent()

StatusCode AthenaEventLoopMgr::nextEvent ( int maxevt )

overridevirtualinherited

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

Reimplemented in MultipleEventLoopMgr.

Definition at line 723 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 = 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 = eventStore()->recordAddress(addr);
    if( !sc.isSuccess() ) {
      ATH_MSG_WARNING ( "Error declaring Event object" );
      continue;
    }
      } 
      if ((sc=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 = 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=()

PyAthenaEventLoopMgr & PyAthenaEventLoopMgr::operator= ( const PyAthenaEventLoopMgr & )

protected

◆ pointer()

PyAthenaEventLoopMgr * PyAthenaEventLoopMgr::pointer ( )

static

outside access

Definition at line 52 of file PyAthenaEventLoopMgr.cxx.

                                                    {
 
   SmartIF<IEventProcessor> ep{Gaudi::svcLocator()->service( "PyAthenaEventLoopMgr", /*createIf*/false )};
   if ( ep ) {
      ep->addRef();
      return dynamic_cast< PyAthenaEventLoopMgr* >( ep.get() );
   }
 
   return nullptr;
}

◆ resetTimeout()

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

inlineprotectedinherited

Reset timeout.

Definition at line 83 of file Timeout.h.

83{ instance.reset(); }

instance

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

Definition Run_To_Get_Tags.h:8

◆ seek()

StatusCode AthenaEventLoopMgr::seek ( int evt )

overridevirtualinherited

Seek to a given event.

Definition at line 859 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 )

protectedinherited

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

Definition at line 313 of file AthenaEventLoopMgr.cxx.

                                                                 {
  const std::string& policyName = m_clearStorePolicy.value();
 
  if ( policyName != "BeginEvent" &&
       policyName != "EndEvent" ) {
 
    ATH_MSG_FATAL ( "Unknown policy [" << policyName 
            << "] for the 'ClearStore-policy !"
            << endmsg
            << "Valid values are: BeginEvent, EndEvent"
            );
    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;
}

◆ setManager()

PyObject * PyAthenaEventLoopMgr::setManager ( PyObject * mgr )

actual manager object

Definition at line 82 of file PyAthenaEventLoopMgr.cxx.

{
   RootUtils::PyGILStateEnsure gil;
   if ( ! PyObject_HasAttrString( mgr, execalgs ) )
   {
      PyErr_SetString( PyExc_TypeError, "given object is not a manager" );
      return nullptr;
   }
 
// set on ourselves
   PyObject* old = m_manager;
   Py_INCREF( mgr );
   m_manager = mgr;
 
// set onto the module as a module global (this may replace the old one, so
// users are best served to only access this through the module)
   PyObject* pyelm = PyImport_AddModule( const_cast< char* >( "AthenaServices.PyAthenaEventLoopMgr" ) );
   if ( pyelm ) {
      Py_INCREF( mgr );
      if (PyModule_AddObject( pyelm, const_cast< char* >( "EventLoopMgr" ), mgr ) < 0) {
        Py_DECREF( mgr );
      }
   }
 
// hand the python side its interfaces
   PyObject* pyself = PyCapsule_New( (void*)static_cast< IEventSeek* >( this ), nullptr, nullptr );
   PyObject* method = PyUnicode_FromString( "_installServices" );
   PyObject* result = PyObject_CallMethodObjArgs( mgr, method, pyself, 0 );
   Py_DECREF( method );
   Py_DECREF( pyself );
 
   if ( ! result )
      return nullptr;
 
// return old value (with its refcount), if set previously; or None
   if ( old != nullptr )
      return old;
 
   Py_INCREF( Py_None );
   return Py_None;
}

◆ setTimeout()

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

inlineprotectedinherited

Set timeout.

Definition at line 80 of file Timeout.h.

80{ instance.set(); }

◆ setupPreSelectTools()

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

protectedinherited

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 ( )

overridevirtualinherited

Return the size of the collection.

Definition at line 897 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 ( )

overridevirtualinherited

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 )

protectedvirtualinherited

Dump out histograms as needed.

Definition at line 435 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

protectedinherited

Reference to the Algorithm Execution State Svc.

Definition at line 152 of file AthenaEventLoopMgr.h.

◆ m_chronoStatSvc

ServiceHandle<IChronoStatSvc> AthenaEventLoopMgr::m_chronoStatSvc

privateinherited

Definition at line 216 of file AthenaEventLoopMgr.h.

◆ m_clearStorePolicy

StringProperty AthenaEventLoopMgr::m_clearStorePolicy

protectedinherited

Definition at line 135 of file AthenaEventLoopMgr.h.

◆ m_conditionsCleaner

ServiceHandle<Athena::IConditionsCleanerSvc> AthenaEventLoopMgr::m_conditionsCleaner

privateinherited

Definition at line 217 of file AthenaEventLoopMgr.h.

◆ m_currentRun

number_type AthenaEventLoopMgr::m_currentRun

protectedinherited

current run number

Definition at line 102 of file AthenaEventLoopMgr.h.

◆ m_doChrono

bool AthenaEventLoopMgr::m_doChrono = false

privateinherited

Definition at line 215 of file AthenaEventLoopMgr.h.

◆ m_eventPrintoutInterval

UnsignedIntegerProperty AthenaEventLoopMgr::m_eventPrintoutInterval

protectedinherited

Definition at line 109 of file AthenaEventLoopMgr.h.

◆ m_eventStore

StoreGateSvc_t AthenaEventLoopMgr::m_eventStore

protectedinherited

Reference to StoreGateSvc;.

Property

Definition at line 73 of file AthenaEventLoopMgr.h.

◆ m_evtIdModSvc

IEvtIdModifierSvc_t AthenaEventLoopMgr::m_evtIdModSvc

protectedinherited

Definition at line 92 of file AthenaEventLoopMgr.h.

◆ m_evtsel

StringProperty AthenaEventLoopMgr::m_evtsel

protectedinherited

Definition at line 80 of file AthenaEventLoopMgr.h.

◆ m_evtSelCtxt

IEvtSelector::Context* AthenaEventLoopMgr::m_evtSelCtxt

protectedinherited

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

protectedinherited

Reference to the Event Selector.

Definition at line 76 of file AthenaEventLoopMgr.h.

◆ m_execAtPreFork

StringArrayProperty AthenaEventLoopMgr::m_execAtPreFork

protectedinherited

Definition at line 95 of file AthenaEventLoopMgr.h.

◆ m_failureMode

IntegerProperty AthenaEventLoopMgr::m_failureMode

protectedinherited

Definition at line 106 of file AthenaEventLoopMgr.h.

◆ m_firstRun

bool AthenaEventLoopMgr::m_firstRun

protectedinherited

Definition at line 103 of file AthenaEventLoopMgr.h.

◆ m_histoDataMgrSvc

IDataManagerSvc_t AthenaEventLoopMgr::m_histoDataMgrSvc

protectedinherited

Reference to the Histogram Data Service.

Definition at line 84 of file AthenaEventLoopMgr.h.

◆ m_histoPersSvc

IConversionSvc_t AthenaEventLoopMgr::m_histoPersSvc

protectedinherited

Definition at line 88 of file AthenaEventLoopMgr.h.

◆ m_histPersName

StringProperty AthenaEventLoopMgr::m_histPersName

protectedinherited

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.

135{ nullptr };

◆ m_incidentSvc

IIncidentSvc_t AthenaEventLoopMgr::m_incidentSvc

protectedinherited

Reference to the incident service.

Definition at line 69 of file AthenaEventLoopMgr.h.

◆ m_intervalInSeconds

unsigned int AthenaEventLoopMgr::m_intervalInSeconds

privateinherited

Definition at line 208 of file AthenaEventLoopMgr.h.

◆ m_lastNev

unsigned int AthenaEventLoopMgr::m_lastNev {}

privateinherited

Definition at line 207 of file AthenaEventLoopMgr.h.

207{};

◆ m_lastTime

time_t AthenaEventLoopMgr::m_lastTime {}

privateinherited

Definition at line 209 of file AthenaEventLoopMgr.h.

209{};

◆ m_liteLoop

bool AthenaEventLoopMgr::m_liteLoop

privateinherited

Definition at line 211 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.

138{ MSG::NIL };

◆ m_manager

PyObject* PyAthenaEventLoopMgr::m_manager

private

Definition at line 60 of file PyAthenaEventLoopMgr.h.

◆ 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

privateinherited

events processed

Definition at line 203 of file AthenaEventLoopMgr.h.

◆ m_nevt

int AthenaEventLoopMgr::m_nevt {}

privateinherited

Definition at line 197 of file AthenaEventLoopMgr.h.

197{};

◆ 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

privateinherited

Definition at line 204 of file AthenaEventLoopMgr.h.

◆ m_requireInputAttributeList

bool AthenaEventLoopMgr::m_requireInputAttributeList {}

protectedinherited

require input attribute list

Definition at line 124 of file AthenaEventLoopMgr.h.

124{};

◆ m_toolAccept

tool_stats AthenaEventLoopMgr::m_toolAccept

protectedinherited

tool returns StatusCode::SUCCESS counter

Definition at line 120 of file AthenaEventLoopMgr.h.

◆ m_toolInvoke

tool_stats AthenaEventLoopMgr::m_toolInvoke

protectedinherited

tool called counter

Definition at line 118 of file AthenaEventLoopMgr.h.

◆ m_toolReject

tool_stats AthenaEventLoopMgr::m_toolReject

protectedinherited

tool returns StatusCode::FAILURE counter

Definition at line 119 of file AthenaEventLoopMgr.h.

◆ m_tools

tool_store AthenaEventLoopMgr::m_tools

protectedinherited

internal tool store

Definition at line 121 of file AthenaEventLoopMgr.h.

◆ m_useSecondaryEventNumber

bool AthenaEventLoopMgr::m_useSecondaryEventNumber {}

protectedinherited

read event number from secondary input

Definition at line 127 of file AthenaEventLoopMgr.h.

127{};

◆ m_useTools

bool AthenaEventLoopMgr::m_useTools

privateinherited

Definition at line 205 of file AthenaEventLoopMgr.h.

◆ m_writeHists

bool AthenaEventLoopMgr::m_writeHists {}

privateinherited

Definition at line 200 of file AthenaEventLoopMgr.h.

200{};

◆ m_writeInterval

IntegerProperty AthenaEventLoopMgr::m_writeInterval

privateinherited

Definition at line 199 of file AthenaEventLoopMgr.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ EvtContext

◆ IConversionSvc_t

◆ IDataManagerSvc_t

◆ IEvtIdModifierSvc_t

◆ IIncidentSvc_t

◆ number_type

◆ StoreGateSvc_t

◆ tool_iterator

◆ tool_stats

◆ tool_stats_iterator

◆ tool_store

◆ tool_type

Constructor & Destructor Documentation

◆ PyAthenaEventLoopMgr() [1/3]

◆ ~PyAthenaEventLoopMgr()

◆ PyAthenaEventLoopMgr() [2/3]

◆ PyAthenaEventLoopMgr() [3/3]

Member Function Documentation

◆ curEvent()

◆ eventStore()

◆ execAtPreFork()

◆ executeAlgorithms()

◆ executeEvent()

◆ executeRun()

◆ finalize()

◆ getManager()

◆ handle()

◆ initialize()

◆ initializeAlgorithms()

◆ initMessaging()

◆ installEventContext()

◆ modifyEventContext()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ name()

◆ nextEvent()

◆ operator=()

◆ pointer()

◆ resetTimeout()

◆ seek()

◆ setClearStorePolicy()

◆ setLevel()

◆ setManager()

◆ setTimeout()

◆ setupPreSelectTools()

◆ size()

◆ stopRun()

◆ writeHistograms()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_aess

◆ m_chronoStatSvc

◆ m_clearStorePolicy

◆ m_conditionsCleaner

◆ m_currentRun

◆ m_doChrono

◆ m_eventPrintoutInterval

◆ m_eventStore

◆ m_evtIdModSvc

◆ m_evtsel

◆ m_evtSelCtxt

◆ m_evtSelector

◆ m_execAtPreFork

◆ m_failureMode

◆ m_firstRun

◆ m_histoDataMgrSvc

◆ m_histoPersSvc

◆ m_histPersName

◆ m_imsg