OfflineEventLoopMgr.cxx

Go to the documentation of this file.

#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/SmartDataPtr.h"
 
#include "EventModel/EventHeader.h"
 
#include "OfflineEventLoopMgr.h"
 
extern const CLID& CLID_Event;
DECLARE_COMPONENT( OfflineEventLoopMgr )
 
//--------------------------------------------------------------------------------------------
// Standard Constructor
//--------------------------------------------------------------------------------------------
OfflineEventLoopMgr::OfflineEventLoopMgr( const std::string& name, ISvcLocator* svcLoc )
    : MinimalEventLoopMgr( name, svcLoc ) {
  // Reset the pointers
  m_histoDataMgrSvc = nullptr;
  m_histoPersSvc    = nullptr;
  m_incidentSvc     = nullptr;
  m_evtDataMgrSvc   = nullptr;
  m_evtDataSvc      = nullptr;
  m_evtSelector     = nullptr;
 
  m_evtContext = nullptr;
  m_runNo      = 0;
  m_runNoSet   = false;
}
 
//--------------------------------------------------------------------------------------------
// Standard Destructor
//--------------------------------------------------------------------------------------------
OfflineEventLoopMgr::~OfflineEventLoopMgr() {
  if ( m_evtContext ) delete m_evtContext;
}
 
//--------------------------------------------------------------------------------------------
// implementation of IAppMgrUI::initalize
//--------------------------------------------------------------------------------------------
StatusCode OfflineEventLoopMgr::initialize() {
  info() << "In initialize()" << endmsg;
 
  // Initialize the base class
  StatusCode sc = MinimalEventLoopMgr::initialize();
  if ( !sc.isSuccess() )
  {
    fatal() << "Failed to initialize the MinimalEventLoopMgr" << endmsg;
    return sc;
  }
 
  // Setup access to event data services
  m_evtDataMgrSvc = service( "EventDataSvc", true );
  if ( !m_evtDataMgrSvc )
  {
    fatal() << "Failed to get the EventDataSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  m_evtDataSvc = service( "EventDataSvc", true );
  if ( !m_evtDataSvc )
  {
    fatal() << "Failed to get the EventDataSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Get the references to the services that are needed by the ApplicationMgr itself
  m_incidentSvc = service( "IncidentSvc", true );
  if ( !m_incidentSvc )
  {
    fatal() << "Failed to get the IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Obtain the IProperty of the ApplicationMgr
  m_appMgrProperty = serviceLocator();
  if ( !m_appMgrProperty )
  {
    fatal() << "Failed to get the IProperty of the ApplicationMgr" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // We do not expect an EventSelector necessarily being declared
  if ( m_evtsel == "NONE" )
  {
    m_evtSelector = nullptr;
    m_evtContext  = nullptr;
    warning() << "Unable to locate service \"EventSelector\" " << endmsg;
    warning() << "No events will be processed from external input." << endmsg;
  }
  else
  {
    // an EventSelector is declared
    m_evtSelector = service( "EventSelector", true );
    if ( !m_evtSelector )
    {
      fatal() << "EventSelector not found." << endmsg;
      return StatusCode::FAILURE;
    }
    debug() << "Found EventSelector" << endmsg;
 
    // Setup Event selector
    sc = m_evtSelector->createContext( m_evtContext );
    if ( !sc.isSuccess() )
    {
      fatal() << "Can not create the context" << endmsg;
      return StatusCode::FAILURE;
    }
 
    debug() << "Context created." << endmsg;
  }
 
  // Setup access to histogramming services
  m_histoDataMgrSvc = service( "HistogramDataSvc", true );
  if ( !m_histoDataMgrSvc )
  {
    fatal() << "Failed to get the HistogramDataSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Setup histogram persistency
  m_histoPersSvc = service( "HistogramPersistencySvc", true );
  if ( !m_histoPersSvc )
  {
    warning() << "Histograms cannot not be saved - though required." << endmsg;
    return StatusCode::FAILURE;
  }
 
  // setup progress showing
  if ( m_showProgressInterval )
  {
    switch ( m_progressLevelSetting )
    {
    case 1: m_progressLevel = MSG::VERBOSE; break;
    case 2: m_progressLevel = MSG::DEBUG; break;
    case 3: m_progressLevel = MSG::INFO; break;
    case 4: m_progressLevel = MSG::WARNING; break;
    case 5: m_progressLevel = MSG::ERROR; break;
    case 6: m_progressLevel = MSG::FATAL; break;
    case 7: m_progressLevel = MSG::ALWAYS; break;
    default:
      error() << "Unknown progress level setting: " << m_progressLevelSetting << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  if ( m_startEvtNo > 0 || m_startRunNo != 0 ) { m_skipEvt = true; }
  else { m_skipEvt = false; }
 
  return StatusCode::SUCCESS;
}
 
//--------------------------------------------------------------------------------------------
// implementation of IService::reinitialize
//--------------------------------------------------------------------------------------------
StatusCode OfflineEventLoopMgr::reinitialize() {
 
  info() << "In reinitialize()" << endmsg;
 
  // Initialize the base class
  StatusCode sc = MinimalEventLoopMgr::reinitialize();
  if ( !sc.isSuccess() )
  {
    error() << "Error Initializing base class MinimalEventLoopMgr." << endmsg;
    return sc;
  }
 
  // Check to see whether a new Event Selector has been specified
  if ( sc = setProperty( m_appMgrProperty->getProperty( "EvtSel" ) ); !sc ) return sc;
  if ( m_evtsel != "NONE" || m_evtsel.length() == 0 )
  {
    auto theSvc    = serviceLocator()->service<IService>( "EventSelector" );
    auto theEvtSel = theSvc.as<IEvtSelector>();
    if ( theEvtSel && ( theEvtSel.get() != m_evtSelector.get() ) )
    {
      // Setup Event Selector
      if ( m_evtSelector.get() && m_evtContext )
      {
        // Need to release context before switching to new event selector
        if ( sc = m_evtSelector->releaseContext( m_evtContext ); !sc ) return sc;
        m_evtContext = nullptr;
      }
      m_evtSelector = theEvtSel;
      if ( theSvc->FSMState() == Gaudi::StateMachine::INITIALIZED )
      {
        sc = theSvc->reinitialize();
        if ( !sc.isSuccess() )
        {
          error() << "Failure Reinitializing EventSelector " << theSvc->name() << endmsg;
          return sc;
        }
      }
      else
      {
        sc = theSvc->sysInitialize();
        if ( !sc.isSuccess() )
        {
          error() << "Failure Initializing EventSelector " << theSvc->name() << endmsg;
          return sc;
        }
      }
      sc = m_evtSelector->createContext( m_evtContext );
      if ( !sc.isSuccess() )
      {
        error() << "Can not create Context " << theSvc->name() << endmsg;
        return sc;
      }
      info() << "EventSelector service changed to " << theSvc->name() << endmsg;
    }
    else if ( m_evtSelector )
    {
      if ( m_evtContext )
      {
        if ( sc = m_evtSelector->releaseContext( m_evtContext ); !sc ) return sc;
        m_evtContext = nullptr;
      }
      sc = m_evtSelector->createContext( m_evtContext );
      if ( !sc.isSuccess() )
      {
        error() << "Can not create Context " << theSvc->name() << endmsg;
        return sc;
      }
    }
  }
  else if ( m_evtSelector && m_evtContext )
  {
    sc            = m_evtSelector->releaseContext( m_evtContext );
    m_evtSelector = nullptr;
    m_evtContext  = nullptr;
  }
  return sc;
}
 
//--------------------------------------------------------------------------------------------
// implementation of IAppMgrUI::finalize
//--------------------------------------------------------------------------------------------
StatusCode OfflineEventLoopMgr::finalize() {
  info() << "In finalize()" << endmsg;
 
  // Finalize base class
  StatusCode sc = MinimalEventLoopMgr::finalize();
  if ( !sc.isSuccess() )
  {
    error() << "Error finalizing base class" << endmsg;
    return sc;
  }
 
  // Save Histograms Now
  if ( m_histoPersSvc )
  {
    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() )
    {
      // 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() )
      { info() << "Histograms converted successfully according to request." << endmsg; }
      else { error() << "Error while saving Histograms." << endmsg; }
    }
    else { error() << "Error while traversing Histogram data store" << endmsg; }
  }
 
  // Release event selector context
  if ( m_evtSelector && m_evtContext )
  {
    m_evtSelector->releaseContext( m_evtContext ).ignore();
    m_evtContext = nullptr;
  }
 
  // Release all interfaces...
  m_histoDataMgrSvc = nullptr;
  m_histoPersSvc    = nullptr;
 
  m_evtSelector   = nullptr;
  m_evtDataSvc    = nullptr;
  m_evtDataMgrSvc = nullptr;
 
  return StatusCode::SUCCESS;
}
 
//--------------------------------------------------------------------------------------------
// executeEvent( EventContext&& ctx)
//--------------------------------------------------------------------------------------------
StatusCode OfflineEventLoopMgr::executeEvent( EventContext&& ctx ) {
 
  m_incidentSvc->fireIncident( Incident( name(), IncidentType::BeginEvent ) );
 
  // An incident may schedule a stop, in which case is better to exit before the actual
  // execution.
  if ( m_scheduledStop )
  {
    always()
        << "Terminating event processing loop due to a stop scheduled by an incident listener"
        << endmsg;
    return StatusCode::SUCCESS;
  }
 
  SmartDataPtr<Event::EventHeader> evt( m_evtDataSvc, "/Event/EventHeader" );
  if ( !evt )
  {
    error() << "Error accessing Event" << endmsg;
    return StatusCode::FAILURE;
  }
 
  int runNo = evt->runNumber();
  int evtNo = evt->eventNumber();
 
  // Skip events if requested
  if ( m_skipEvt )
  {
    bool match_evt_no = m_startEvtNo == 0; // startEvtNo==0 means skip no event
    bool match_run_no = m_startRunNo == 0; // startRunNo==0 means skip no event
 
    if ( m_startEvtNo > 0 && evtNo == m_startEvtNo ) match_evt_no = true;
    if ( m_startRunNo != 0 && abs( runNo ) == abs( m_startRunNo ) ) match_run_no = true;
 
    if ( match_evt_no && match_run_no )
    {
      info() << "Reached the requested event " << evtNo << " in run " << runNo
             << ", will start processing from next event." << endmsg;
      m_skipEvt = false;
    }
    else
    {
      debug() << "Skipping event " << evtNo << " in run " << runNo << endmsg;
      return StatusCode::SUCCESS;
    }
  }
 
  info() << "The runNo of current event is " << runNo << endmsg;
 
  // If (!m_runNoSet), always fire an incident of begin run
  // otherwise, only fire the incident when the runNo is changed
  if ( !m_runNoSet || runNo != m_runNo )
  {
    info() << "Fire an incident of begin run" << endmsg;
    m_incidentSvc->fireIncident( Incident( name(), "NewRun" ) );
 
    m_runNoSet = true;
    m_runNo    = runNo;
  }
 
  // Execute Algorithms
  m_incidentSvc->fireIncident( Incident( name(), IncidentType::BeginProcessing ) );
  StatusCode sc = MinimalEventLoopMgr::executeEvent( std::move( ctx ) );
  m_incidentSvc->fireIncident( Incident( name(), IncidentType::EndProcessing ) );
 
  if ( !sc.isSuccess() )
    error() << "Terminating event processing loop due to errors" << endmsg;
 
  m_incidentSvc->fireIncident( Incident( name(), IncidentType::EndEvent ) );
 
  return sc;
}
 
//--------------------------------------------------------------------------------------------
// implementation of IAppMgrUI::nextEvent
//--------------------------------------------------------------------------------------------
StatusCode OfflineEventLoopMgr::nextEvent( int maxevt ) {
  static int  total_nevt = 0;
  DataObject* pObject    = 0;
  StatusCode  sc;
 
  for ( int nevt = 0; maxevt == -1 || nevt < maxevt; ++nevt )
  {
 
    if ( m_showProgressInterval > 0 && nevt % m_showProgressInterval == 0 )
    { msgStream( m_progressLevel ) << "Processing event " << nevt << endmsg; }
 
    auto ctx = createEventContext();
 
    // Check if there is a scheduled stop issued by some algorithm/service
    if ( m_scheduledStop )
    {
      m_scheduledStop = false;
      always() << "Terminating event processing loop due to scheduled stop" << endmsg;
      break;
    }
 
    // Clear event store, if used in event loop
    if ( ctx.evt() != 0 )
    {
      sc = m_evtDataMgrSvc->clearStore();
      if ( sc.isSuccess() ) debug() << "Event data storecleared" << endmsg;
      else debug() << "Failed to clear the store" << endmsg;
    }
 
    // Setup event in the event store
    if ( m_evtContext )
    {
      IOpaqueAddress* addr = nullptr;
 
      // Only if there is an EventSelector
      sc = getEventRoot( addr );
      if ( !sc.isSuccess() )
      {
        info() << "No more events in event selection" << endmsg;
        break;
      }
 
      // Set root clearstheevent data store first
      sc = m_evtDataMgrSvc->setRoot( "/Event", addr );
      if ( !sc.isSuccess() )
      {
        warning() << "Error declaring event root address." << endmsg;
        continue;
      }
 
      // register event header for mc
      SmartDataPtr<Event::EventHeader> evt( m_evtDataSvc, "/Event/EventHeader" );
      if ( !evt )
      {
        sc = m_evtDataMgrSvc->registerAddress( "/Event/EventHeader", addr );
        if ( !sc.isSuccess() ) warning() << "Error register EventHeader address." << endmsg;
      }
 
      sc = m_evtDataSvc->retrieveObject( "/Event", pObject );
      if ( !sc.isSuccess() )
      {
        warning() << "Unable to retrieve Event root object" << endmsg;
        break;
      }
    }
    else
    {
      sc = m_evtDataMgrSvc->setRoot( "/Event", new DataObject() );
      if ( !sc.isSuccess() ) warning() << "Error declaring event root DataObject" << endmsg;
    }
 
    // Execute event for all required algorithms
    sc = executeEvent( std::move( ctx ) );
    if ( !sc.isSuccess() )
    {
      error() << "Terminating event processing loop due to errors" << endmsg;
      break;
    }
  }
 
  return StatusCode::SUCCESS;
}
 
//--------------------------------------------------------------------------------------------
// implementation of getEventROOT
//--------------------------------------------------------------------------------------------
/// Create event address using event selector
StatusCode OfflineEventLoopMgr::getEventRoot( IOpaqueAddress*& refpAddr ) {
  refpAddr      = 0;
  StatusCode sc = m_evtSelector->next( *m_evtContext );
  if ( !sc.isSuccess() )
  {
    debug() << "Failed to get next eventContext [1]" << endmsg;
    return sc;
  }
 
  sc = m_evtSelector->createAddress( *m_evtContext, refpAddr );
  if ( sc.isSuccess() )
  {
    debug() << "Event address created successfully." << endmsg;
    return sc;
  }
 
  sc = m_evtSelector->next( *m_evtContext );
  if ( sc.isFailure() )
  {
    debug() << "Failed to get next eventContext [2]" << endmsg;
    return sc;
  }
 
  sc = m_evtSelector->createAddress( *m_evtContext, refpAddr );
  if ( sc.isFailure() ) { warning() << "Error creating IOpaqueAddress." << endmsg; }
  else debug() << "Event address created successfully finally." << endmsg;
 
  return sc;
}