MultipleEventLoopMgr Class Reference

A specialized AthenaEventLoopMgr that allows multiple passes over an event collection. More...

#include <MultipleEventLoopMgr.h>

Inheritance diagram for MultipleEventLoopMgr:

Collaboration diagram for MultipleEventLoopMgr:

Public Types
typedef IEvtSelector::Context	EvtContext

Public Member Functions
	MultipleEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
	Standard Constructor.
virtual	~MultipleEventLoopMgr ()
	Standard Destructor.
virtual StatusCode	nextEvent (int maxevt)
	Dump out histograms as needed.
virtual StatusCode	initialize () override
	implementation of IAppMgrUI::initalize
virtual StatusCode	finalize () override
	implementation of IAppMgrUI::finalize
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.

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

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

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

Private Member Functions
	MultipleEventLoopMgr ()
	implementation of IEventProcessor::executeEvent(void* par)
	MultipleEventLoopMgr (const MultipleEventLoopMgr &)
	no implementation
StatusCode	installEventContext (EventContext &ctx)
StoreGateSvc *	eventStore () const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
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)

Properties
StringProperty	m_nextPassFilterName
	the name of the INextPassFilter object queried at end of pass
StringArrayProperty	m_toBeReInitializedNames
	a list of services to be reinit at the end of the pass
ServiceHandle< IToolSvc >	m_pToolSvc
	handle to the ToolSvc
IAlgManager *	m_pAlgMgr
unsigned int	m_passDone
	number of passes already completed
INextPassFilter *	nextPassFilter ()
	Locate filter.
bool	doNextPass ()
	called at end of pass. Calls nextPassFilter
StatusCode	reInitList ()
	called at each end of pass.
IAlgManager *	algMgr ()

Detailed Description

A specialized AthenaEventLoopMgr that allows multiple passes over an event collection.

The number of passes is controlled by a tool called at the end of each pass over the events that implements the INextPassFilter interface (specified using the NextPassFilter property). At the end of each pass the event selector is rewound and the services listed in the ToBeReinitialized property are reinitialized. Typically MultipleEventLoopMgr will be used for calibration jobs, with the INextPassFilter object looking at the status of the constants in the DetectorStore

Definition at line 40 of file MultipleEventLoopMgr.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

MultipleEventLoopMgr() [1/3]

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

Standard Constructor.

Definition at line 21 of file MultipleEventLoopMgr.cxx.

                                            :
  AthenaEventLoopMgr(nam, svcLoc),
  m_pToolSvc( "ToolSvc", nam ), 
  m_pAlgMgr(nullptr), m_passDone(0) 
{
  declareProperty("NextPassFilter", m_nextPassFilterName);
  declareProperty("ToBeReinitialized", m_toBeReInitializedNames);
}

~MultipleEventLoopMgr()

MultipleEventLoopMgr::~MultipleEventLoopMgr ( )

virtual

Standard Destructor.

Definition at line 31 of file MultipleEventLoopMgr.cxx.

                                            {
  if (m_pAlgMgr) m_pAlgMgr->release();
}

MultipleEventLoopMgr() [2/3]

MultipleEventLoopMgr::MultipleEventLoopMgr ( )

private

implementation of IEventProcessor::executeEvent(void* par)

no implementation

MultipleEventLoopMgr() [3/3]

MultipleEventLoopMgr::MultipleEventLoopMgr ( const MultipleEventLoopMgr & )

private

no implementation

Member Function Documentation

algMgr()

IAlgManager * MultipleEventLoopMgr::algMgr ( )

private

Definition at line 36 of file MultipleEventLoopMgr.cxx.

                             {
  if ( nullptr == m_pAlgMgr ) {
    SmartIF<IAlgManager> algMan(serviceLocator());
    if( algMan.isValid() ) m_pAlgMgr=&*algMan;
    else throw GaudiException("IAlgManager not found", name(), StatusCode::FAILURE);
    m_pAlgMgr->addRef();
  }
  return m_pAlgMgr;
}

curEvent()

int AthenaEventLoopMgr::curEvent ( ) const

overridevirtualinherited

Return the current event count.

Definition at line 889 of file AthenaEventLoopMgr.cxx.

{
  return m_nevt;
}

doNextPass()

bool MultipleEventLoopMgr::doNextPass ( )

private

called at end of pass. Calls nextPassFilter

if true start another pass

Definition at line 72 of file MultipleEventLoopMgr.cxx.

                                 {
  INextPassFilter* pFilter(nextPassFilter());
  //if no tool found or tool not an INextPassFilter we return false
  //and terminate the multiple pass iteration
  return ( nullptr != pFilter && pFilter->doNextPass() );
}

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 AthenaEventLoopMgr::executeAlgorithms ( const EventContext & ctx )

protectedvirtualinherited

Run the algorithms for the current event.

Reimplemented in PyAthenaEventLoopMgr.

Definition at line 526 of file AthenaEventLoopMgr.cxx.

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

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 AthenaEventLoopMgr::finalize ( )

overridevirtualinherited

implementation of IAppMgrUI::finalize

Reimplemented in PyAthenaEventLoopMgr.

Definition at line 379 of file AthenaEventLoopMgr.cxx.

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

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 AthenaEventLoopMgr::initialize ( )

overridevirtualinherited

implementation of IAppMgrUI::initalize

Reimplemented in PyAthenaEventLoopMgr.

Definition at line 124 of file AthenaEventLoopMgr.cxx.

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

initializeAlgorithms()

StatusCode AthenaEventLoopMgr::initializeAlgorithms ( )

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.

{ return msg() << lvl; }

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.

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

nextEvent()

StatusCode MultipleEventLoopMgr::nextEvent ( int maxevt )

virtual

Dump out histograms as needed.

Run the algorithms for the current event implementation of IAppMgrUI::initalize implementation of IAppMgrUI::finalize implementation of IAppMgrUI::nextEvent

Reimplemented from AthenaEventLoopMgr.

Definition at line 90 of file MultipleEventLoopMgr.cxx.

                                          {
  StatusCode sc;
  do {
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "nextEvent: starting pass #" << m_passDone << endmsg;
    // Reset run number to assure BeginRun each rewind
    m_currentRun = 0;
    sc = AthenaEventLoopMgr::nextEvent(maxevt);
    log << MSG::INFO << "nextEvent: finished pass #" << m_passDone << endmsg;
    m_passDone++;
  } while ( sc.isSuccess() &&                    //pass ok
        doNextPass() &&                      //another one?
        (sc = reInitList()).isSuccess() &&   //then reinit svcs
        (sc = seek(0)).isSuccess() );        //and rewind selector
  return sc;
}

nextPassFilter()

INextPassFilter * MultipleEventLoopMgr::nextPassFilter ( )

private

Locate filter.

Parses m_nextPassFilterName allowing for interactive changes.

Definition at line 47 of file MultipleEventLoopMgr.cxx.

                                     {
  INextPassFilter* pFilter(nullptr); 
  const string& filterName(m_nextPassFilterName.value());
  if (!(filterName.empty())) {
    Gaudi::Utils::TypeNameString theFilter(filterName);
    IAlgTool* pHoldTool(nullptr);
    if ( (m_pToolSvc->retrieveTool(theFilter.type(), theFilter.name(), 
                   pHoldTool)).isSuccess() ) { 
      pFilter=dynamic_cast<INextPassFilter*>(pHoldTool);
    }
 
    SmartIF<IAlgorithm>& pHoldAlg = algMgr()->algorithm(theFilter, /*createIf*/false);
    if (nullptr == pFilter && pHoldAlg) {
      pFilter=dynamic_cast<INextPassFilter*>(pHoldAlg.get());
    }
  }
  if (nullptr == pFilter) {
    Gaudi::Utils::TypeNameString theFilter(filterName);
    MsgStream log(msgSvc(), name());
    log << MSG::WARNING << "Could not locate filter " 
    << theFilter.type() << '/' << theFilter.name() << endmsg;
  }
  return pFilter;
}

reInitList()

StatusCode MultipleEventLoopMgr::reInitList ( )

private

called at each end of pass.

Parses m_toBeReInitializedNames allowing for interactive changes

Definition at line 79 of file MultipleEventLoopMgr.cxx.

                                 {
  StatusCode sc;
  for (const std::string& name : m_toBeReInitializedNames.value()) {
    SmartIF<IService>& svc = serviceLocator()->service(name, /*createIf*/false);
    if (svc) sc = svc->reinitialize();
    if (!sc.isSuccess()) return sc;
  }
  return sc;
}

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 )

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;
}

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 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.

{ 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.

{};

m_lastTime

time_t AthenaEventLoopMgr::m_lastTime {}

privateinherited

Definition at line 209 of file AthenaEventLoopMgr.h.

{};

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.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

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

Definition at line 132 of file AthMessaging.h.

m_nev

unsigned int AthenaEventLoopMgr::m_nev

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.

{};

m_nextPassFilterName

StringProperty MultipleEventLoopMgr::m_nextPassFilterName

private

the name of the INextPassFilter object queried at end of pass

Definition at line 76 of file MultipleEventLoopMgr.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_pAlgMgr

IAlgManager* MultipleEventLoopMgr::m_pAlgMgr

private

Definition at line 97 of file MultipleEventLoopMgr.h.

m_passDone

unsigned int MultipleEventLoopMgr::m_passDone

private

number of passes already completed

Definition at line 99 of file MultipleEventLoopMgr.h.

m_proc

unsigned int AthenaEventLoopMgr::m_proc

privateinherited

Definition at line 204 of file AthenaEventLoopMgr.h.

m_pToolSvc

ServiceHandle<IToolSvc> MultipleEventLoopMgr::m_pToolSvc

private

handle to the ToolSvc

Definition at line 94 of file MultipleEventLoopMgr.h.

m_requireInputAttributeList

bool AthenaEventLoopMgr::m_requireInputAttributeList {}

protectedinherited

require input attribute list

Definition at line 124 of file AthenaEventLoopMgr.h.

{};

m_toBeReInitializedNames

StringArrayProperty MultipleEventLoopMgr::m_toBeReInitializedNames

private

a list of services to be reinit at the end of the pass

Definition at line 79 of file MultipleEventLoopMgr.h.

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.

{};

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.

{};

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:

• MultipleEventLoopMgr.h
• MultipleEventLoopMgr.cxx