PyAthenaEventLoopMgr Class Reference

Implementation of the AthenaEventLoopMgr that allows selective and specific overrides in python. The idea is to maximize code-sharing with AthenaEventLoopMgr to reduce maintainance. 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. More...
	~PyAthenaEventLoopMgr ()
PyObject *	setManager (PyObject *)
	actual manager object More...
PyObject *	getManager ()
virtual StatusCode	initialize ()
	implementation of IAppMgrUI::initalize More...
virtual StatusCode	finalize ()
	implementation of IAppMgrUI::finalize More...
virtual StatusCode	nextEvent (int maxevt)
	implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately More...
virtual StatusCode	executeEvent (EventContext &&ctx)
	implementation of IEventProcessor::executeEvent(EventContext&& ctx) More...
virtual StatusCode	executeRun (int maxevt)
	implementation of IEventProcessor::executeRun(int maxevt) More...
virtual StatusCode	seek (int evt)
	Seek to a given event. More...
virtual int	curEvent () const
	Return the current event count. More...
virtual int	size ()
	Return the size of the collection. More...
void	handle (const Incident &inc)
	IIncidentListenet interfaces. More...
StatusCode	execAtPreFork (const EventContext &ctx) const
	Execute certain algorithms/sequences in PreFork. More...
virtual const std::string &	name () const
virtual void	modifyEventContext (EventContext &ctx, const EventID &eID, bool consume_modifier_stream)
MsgStream &	msg () const
	The standard message stream. More...
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...
MsgStream &	msg () const
	The standard message stream. More...
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...
bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...
bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

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

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. More...
	PyAthenaEventLoopMgr (const PyAthenaEventLoopMgr &)
PyAthenaEventLoopMgr &	operator= (const PyAthenaEventLoopMgr &)
virtual StatusCode	executeAlgorithms (const EventContext &)
	Run the algorithms for the current event. More...
void	setupPreSelectTools (Gaudi::Details::PropertyBase &)
	property update handler:sets up the Pre-selection tools More...
void	setClearStorePolicy (Gaudi::Details::PropertyBase &clearStorePolicy)
	property update handler:set the clear-store policy value and check its value. More...
virtual StatusCode	writeHistograms (bool force=false)
	Dump out histograms as needed. More...
StatusCode	initializeAlgorithms ()
	Initialize all algorithms and output streams. More...
void	setTimeout (Timeout &instance)
	Set timeout. More...
void	resetTimeout (Timeout &instance)
	Reset timeout. More...

Protected Attributes
IIncidentSvc_t	m_incidentSvc
	Reference to the incident service. More...
StoreGateSvc_t	m_eventStore
	Reference to StoreGateSvc;. More...
IEvtSelector *	m_evtSelector
	Reference to the Event Selector. More...
IEvtSelector::Context *	m_evtSelCtxt
	Gaudi EventSelector Context (may be used as a cursor by the evt selector) More...
StringProperty	m_evtsel
IDataManagerSvc_t	m_histoDataMgrSvc
	Reference to the Histogram Data Service. More...
IConversionSvc_t	m_histoPersSvc
IEvtIdModifierSvc_t	m_evtIdModSvc
StringArrayProperty	m_execAtPreFork
StringProperty	m_histPersName
number_type	m_currentRun
	current run number More...
bool	m_firstRun
IntegerProperty	m_failureMode
UnsignedIntegerProperty	m_eventPrintoutInterval
tool_stats	m_toolInvoke
	tool called counter More...
tool_stats	m_toolReject
	tool returns StatusCode::FAILURE counter More...
tool_stats	m_toolAccept
	tool returns StatusCode::SUCCESS counter More...
tool_store	m_tools
	internal tool store More...
bool	m_requireInputAttributeList {}
	require input attribute list More...
bool	m_useSecondaryEventNumber {}
	read event number from secondary input More...
StringProperty	m_clearStorePolicy
SmartIF< IAlgExecStateSvc >	m_aess
	Reference to the Algorithm Execution State Svc. More...

Private Member Functions
StatusCode	installEventContext (EventContext &ctx)
StoreGateSvc *	eventStore () const
void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
PyObject *	m_manager
int	m_nevt {}
IntegerProperty	m_writeInterval
bool	m_writeHists {}
unsigned int	m_nev
	events processed More...
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. More...
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

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 36 of file PyAthenaEventLoopMgr.h.

Member Typedef Documentation

EvtContext

typedef IEvtSelector::Context AthenaEventLoopMgr::EvtContext

inherited

Definition at line 68 of file AthenaEventLoopMgr.h.

IConversionSvc_t

typedef ServiceHandle<IConversionSvc> AthenaEventLoopMgr::IConversionSvc_t

protectedinherited

Definition at line 90 of file AthenaEventLoopMgr.h.

IDataManagerSvc_t

typedef ServiceHandle<IDataManagerSvc> AthenaEventLoopMgr::IDataManagerSvc_t

protectedinherited

Definition at line 86 of file AthenaEventLoopMgr.h.

IEvtIdModifierSvc_t

typedef ServiceHandle<IEvtIdModifierSvc> AthenaEventLoopMgr::IEvtIdModifierSvc_t

protectedinherited

Definition at line 94 of file AthenaEventLoopMgr.h.

IIncidentSvc_t

typedef ServiceHandle<IIncidentSvc> AthenaEventLoopMgr::IIncidentSvc_t

protectedinherited

Definition at line 71 of file AthenaEventLoopMgr.h.

number_type

typedef EventID::number_type AthenaEventLoopMgr::number_type

protectedinherited

Definition at line 104 of file AthenaEventLoopMgr.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthenaEventLoopMgr::StoreGateSvc_t

protectedinherited

Definition at line 75 of file AthenaEventLoopMgr.h.

tool_iterator

typedef tool_store::const_iterator AthenaEventLoopMgr::tool_iterator

protectedinherited

Definition at line 118 of file AthenaEventLoopMgr.h.

tool_stats

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

protectedinherited

Definition at line 119 of file AthenaEventLoopMgr.h.

tool_stats_iterator

typedef tool_stats::const_iterator AthenaEventLoopMgr::tool_stats_iterator

protectedinherited

Definition at line 120 of file AthenaEventLoopMgr.h.

tool_store

typedef ToolHandleArray< tool_type > AthenaEventLoopMgr::tool_store

protectedinherited

Definition at line 117 of file AthenaEventLoopMgr.h.

tool_type

typedef IAthenaEvtLoopPreSelectTool AthenaEventLoopMgr::tool_type

protectedinherited

Definition at line 116 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 70 of file PyAthenaEventLoopMgr.cxx.

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

~PyAthenaEventLoopMgr()

PyAthenaEventLoopMgr::~PyAthenaEventLoopMgr ( )

inline

Definition at line 40 of file PyAthenaEventLoopMgr.h.

{}

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

virtualinherited

Return the current event count.

Definition at line 882 of file AthenaEventLoopMgr.cxx.

{
  return m_nevt;
}

eventStore()

StoreGateSvc * AthenaEventLoopMgr::eventStore ( ) const

privateinherited

Definition at line 1010 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 993 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 193 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 PY_MAJOR_VERSION < 3
      if ( PyInt_Check( result ) || PyLong_Check( result ) )
      {
     StatusCode sc = StatusCode( (int) PyInt_AS_LONG( result ) );
         Py_DECREF( result );
         return sc;
      }
#else
      if ( PyLong_Check( result ) )
      {
     StatusCode sc = StatusCode( (int) PyLong_AS_LONG( result ) );
         Py_DECREF( result );
         return sc;
      }
#endif
 
   // 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 )

virtualinherited

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

virtualinherited

implementation of IEventProcessor::executeRun(int maxevt)

Definition at line 704 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 244 of file PyAthenaEventLoopMgr.cxx.

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

getManager()

PyObject * PyAthenaEventLoopMgr::getManager

(

)

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

inherited

IIncidentListenet interfaces.

Definition at line 912 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 148 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 484 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();
  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 1018 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 1170 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/4]

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 164 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/4]

MsgStream & AthMessaging::msg

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() [3/4]

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 179 of file AthMessaging.h.

{ return msg() << lvl; }

msg() [4/4]

MsgStream & AthMessaging::msg

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.

{ return msg() << lvl; }

msgLvl() [1/2]

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 151 of file AthMessaging.h.

{
  if (!m_initialized.test_and_set()) initMessaging();
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

msgLvl() [2/2]

bool AthMessaging::msgLvl

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

name()

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

inlinevirtualinherited

Definition at line 188 of file AthenaEventLoopMgr.h.

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

nextEvent()

StatusCode AthenaEventLoopMgr::nextEvent ( int  maxevt )

virtualinherited

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

Reimplemented in MultipleEventLoopMgr.

Definition at line 716 of file AthenaEventLoopMgr.cxx.

{
  // make nextEvent(0) a dummy call
  if (0 == maxevt) return StatusCode::SUCCESS;
 
  static 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 55 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.

{ instance.reset(); }

seek()

StatusCode AthenaEventLoopMgr::seek ( int  evt )

virtualinherited

Seek to a given event.

Definition at line 852 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 319 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 85 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 );
#if PY_MAJOR_VERSION < 3
   PyObject* method = PyString_FromString( "_installServices" );
#else
   PyObject* method = PyUnicode_FromString( "_installServices" );
#endif
   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.

{ instance.set(); }

setupPreSelectTools()

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

protectedinherited

property update handler:sets up the Pre-selection tools

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

virtualinherited

Return the size of the collection.

Definition at line 890 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);
}

writeHistograms()

StatusCode AthenaEventLoopMgr::writeHistograms ( bool  force = false )

protectedvirtualinherited

Dump out histograms as needed.

Definition at line 428 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 156 of file AthenaEventLoopMgr.h.

m_chronoStatSvc

ServiceHandle<IChronoStatSvc> AthenaEventLoopMgr::m_chronoStatSvc

privateinherited

Definition at line 218 of file AthenaEventLoopMgr.h.

m_clearStorePolicy

StringProperty AthenaEventLoopMgr::m_clearStorePolicy

protectedinherited

Definition at line 139 of file AthenaEventLoopMgr.h.

m_conditionsCleaner

ServiceHandle<Athena::IConditionsCleanerSvc> AthenaEventLoopMgr::m_conditionsCleaner

privateinherited

Definition at line 219 of file AthenaEventLoopMgr.h.

m_currentRun

number_type AthenaEventLoopMgr::m_currentRun

protectedinherited

current run number

Definition at line 106 of file AthenaEventLoopMgr.h.

m_doChrono

bool AthenaEventLoopMgr::m_doChrono = false

privateinherited

Definition at line 217 of file AthenaEventLoopMgr.h.

m_eventPrintoutInterval

UnsignedIntegerProperty AthenaEventLoopMgr::m_eventPrintoutInterval

protectedinherited

Definition at line 113 of file AthenaEventLoopMgr.h.

m_eventStore

StoreGateSvc_t AthenaEventLoopMgr::m_eventStore

protectedinherited

Reference to StoreGateSvc;.

Property

Definition at line 77 of file AthenaEventLoopMgr.h.

m_evtIdModSvc

IEvtIdModifierSvc_t AthenaEventLoopMgr::m_evtIdModSvc

protectedinherited

Definition at line 96 of file AthenaEventLoopMgr.h.

m_evtsel

StringProperty AthenaEventLoopMgr::m_evtsel

protectedinherited

Definition at line 84 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 82 of file AthenaEventLoopMgr.h.

m_evtSelector

IEvtSelector* AthenaEventLoopMgr::m_evtSelector

protectedinherited

Reference to the Event Selector.

Definition at line 80 of file AthenaEventLoopMgr.h.

m_execAtPreFork

StringArrayProperty AthenaEventLoopMgr::m_execAtPreFork

protectedinherited

Definition at line 99 of file AthenaEventLoopMgr.h.

m_failureMode

IntegerProperty AthenaEventLoopMgr::m_failureMode

protectedinherited

Definition at line 110 of file AthenaEventLoopMgr.h.

m_firstRun

bool AthenaEventLoopMgr::m_firstRun

protectedinherited

Definition at line 107 of file AthenaEventLoopMgr.h.

m_histoDataMgrSvc

IDataManagerSvc_t AthenaEventLoopMgr::m_histoDataMgrSvc

protectedinherited

Reference to the Histogram Data Service.

Definition at line 88 of file AthenaEventLoopMgr.h.

m_histoPersSvc

IConversionSvc_t AthenaEventLoopMgr::m_histoPersSvc

protectedinherited

Definition at line 92 of file AthenaEventLoopMgr.h.

m_histPersName

StringProperty AthenaEventLoopMgr::m_histPersName

protectedinherited

Definition at line 102 of file AthenaEventLoopMgr.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_incidentSvc

IIncidentSvc_t AthenaEventLoopMgr::m_incidentSvc

protectedinherited

Reference to the incident service.

Definition at line 73 of file AthenaEventLoopMgr.h.

m_intervalInSeconds

unsigned int AthenaEventLoopMgr::m_intervalInSeconds

privateinherited

Definition at line 210 of file AthenaEventLoopMgr.h.

m_lastNev

unsigned int AthenaEventLoopMgr::m_lastNev {}

privateinherited

Definition at line 209 of file AthenaEventLoopMgr.h.

m_lastTime

time_t AthenaEventLoopMgr::m_lastTime {}

privateinherited

Definition at line 211 of file AthenaEventLoopMgr.h.

m_liteLoop

bool AthenaEventLoopMgr::m_liteLoop

privateinherited

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

m_manager

PyObject* PyAthenaEventLoopMgr::m_manager

private

Definition at line 62 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 205 of file AthenaEventLoopMgr.h.

m_nevt

int AthenaEventLoopMgr::m_nevt {}

privateinherited

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

privateinherited

Definition at line 206 of file AthenaEventLoopMgr.h.

m_requireInputAttributeList

bool AthenaEventLoopMgr::m_requireInputAttributeList {}

protectedinherited

require input attribute list

Definition at line 128 of file AthenaEventLoopMgr.h.

m_toolAccept

tool_stats AthenaEventLoopMgr::m_toolAccept

protectedinherited

tool returns StatusCode::SUCCESS counter

Definition at line 124 of file AthenaEventLoopMgr.h.

m_toolInvoke

tool_stats AthenaEventLoopMgr::m_toolInvoke

protectedinherited

tool called counter

Definition at line 122 of file AthenaEventLoopMgr.h.

m_toolReject

tool_stats AthenaEventLoopMgr::m_toolReject

protectedinherited

tool returns StatusCode::FAILURE counter

Definition at line 123 of file AthenaEventLoopMgr.h.

m_tools

tool_store AthenaEventLoopMgr::m_tools

protectedinherited

internal tool store

Definition at line 125 of file AthenaEventLoopMgr.h.

m_useSecondaryEventNumber

bool AthenaEventLoopMgr::m_useSecondaryEventNumber {}

protectedinherited

read event number from secondary input

Definition at line 131 of file AthenaEventLoopMgr.h.

m_useTools

bool AthenaEventLoopMgr::m_useTools

privateinherited

Definition at line 207 of file AthenaEventLoopMgr.h.

m_writeHists

bool AthenaEventLoopMgr::m_writeHists {}

privateinherited

Definition at line 202 of file AthenaEventLoopMgr.h.

m_writeInterval

IntegerProperty AthenaEventLoopMgr::m_writeInterval

privateinherited

Definition at line 201 of file AthenaEventLoopMgr.h.

---

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

• PyAthenaEventLoopMgr.h
• PyAthenaEventLoopMgr.cxx