---

EventLoopMgr.cpp

Go to the documentation of this file.

//===================================================================
//      EventLoopMgr.cpp
//--------------------------------------------------------------------
//
//      Package    : EventLoopMgr ( The LHCb Offline System)
//
//  Description: implementation of the Application's batch mode handler
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/98| Initial version                              | MF
// +---------+----------------------------------------------+---------
//
//====================================================================
#define  GAUDISVC_EVENTLOOPMGR_CPP

#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/IEvtSelector.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"

#include "EventLoopMgr.h"

// Instantiation of a static factory class used by clients to create instances of this service
static SvcFactory<EventLoopMgr> s_EventLoopMgrFactory;
const ISvcFactory& EventLoopMgrFactory = s_EventLoopMgrFactory;

// Standard Constructor
EventLoopMgr::EventLoopMgr(const std::string& nam, ISvcLocator* svcLoc)
: MinimalEventLoopMgr(nam, svcLoc)
{
  declareProperty( "EvtSel", m_evtsel );
}

// Standard Destructor
EventLoopMgr::~EventLoopMgr()   {
}

// implementation of IAppMgrUI::initalize
StatusCode EventLoopMgr::initialize()    {
  StatusCode sc = MinimalEventLoopMgr::initialize();
  if ( sc.isSuccess() )   {
    MsgStream log(msgSvc(), name());
    //--------------------------------------------------------------------------------------------
    // Setup access to event data services
    //--------------------------------------------------------------------------------------------
    sc = serviceLocator()->service("EventDataSvc", m_evtDataMgrSvc);
    if( !sc.isSuccess() )  {
      log << MSG::FATAL << "Error retrieving EventDataSvc interface IDataManagerSvc." << endreq;
      return sc;
    }
    sc = serviceLocator()->service("EventDataSvc", m_evtDataSvc);
    if( !sc.isSuccess() )  {
      log << MSG::FATAL << "Error retrieving EventDataSvc interface IDataProviderSvc." << endreq;
      return sc;
    }
    //--------------------------------------------------------------------------------------------
    // Get the references to the services that are needed by the ApplicationMgr itself
    //--------------------------------------------------------------------------------------------
    sc = serviceLocator()->service("IncidentSvc", m_incidentSvc);
    if( !sc.isSuccess() )  {
      log << MSG::FATAL << "Error retrieving IncidentSvc." << endreq;
      return sc;
    }
    //--------------------------------------------------------------------------------------------
    // Setup Event Setector
    //--------------------------------------------------------------------------------------------
    // We do not expect a Event Selector necessarily being declared
    SmartIF<IProperty> prpMgr(IID_IProperty, serviceLocator());
    if ( prpMgr.isValid() )   {
      setProperty(prpMgr->getProperty("EvtSel"));
    }
    else {
      log << MSG::FATAL << "IProperty interface not found in ApplicationMgr." << endreq;
      return StatusCode::FAILURE;
    }
    if( m_evtsel != "NONE" || m_evtsel.length() == 0) {
      sc = serviceLocator()->service( "EventSelector", m_evtSelector, true );
      if( sc.isSuccess() )     {
        // Setup Event Selector
        m_evtIterator = m_evtSelector->begin();
      }
      else {
        log << MSG::FATAL << "EventSelector not found." << endreq;
        return StatusCode::FAILURE;
      }
    }
    else {
      m_evtSelector = 0;
      m_evtIterator = 0;
      log << MSG::WARNING << "Unable to locate service \"EventSelector\" " << endreq;    
      log << MSG::WARNING << "No events will be processed from external input." << endreq;    
    }
  }
  else    {
    MsgStream log(msgSvc(), name());
    log << MSG::FATAL << "Error Initializing base class MinimalEventLoopMgr." << endreq;
  }
  return sc;
}

// implementation of IAppMgrUI::finalize
StatusCode EventLoopMgr::finalize()    {
  m_evtSelector   = releaseInterface(m_evtSelector);
  m_incidentSvc   = releaseInterface(m_incidentSvc);
  m_evtDataSvc    = releaseInterface(m_evtDataSvc);
  m_evtDataMgrSvc = releaseInterface(m_evtDataMgrSvc);
  return MinimalEventLoopMgr::finalize();
}

// executeEvent(void* par)
StatusCode EventLoopMgr::executeEvent(void* par)    {
  // Fire BeginEvent "Incident"
  m_incidentSvc->fireIncident(Incident(name(),"BeginEvent"));
  // Execute Algorithms
  StatusCode sc = MinimalEventLoopMgr::executeEvent(par);
  // Fire EndEvent "Incident"
  m_incidentSvc->fireIncident(Incident(name(),"EndEvent"));
  //--------------------------------------------------------------------------------------------
  // Check if there was an error processing current event
  //--------------------------------------------------------------------------------------------
  if( !sc.isSuccess() ){
    MsgStream log( msgSvc(), name() );
    log << MSG::ERROR << "Terminating event processing loop due to errors" << endreq;
  }
  return sc;
}

// implementation of IAppMgrUI::nextEvent
StatusCode EventLoopMgr::nextEvent(int maxevt)   {
  static int        total_nevt = 0;
  DataObject*       pObject = 0;
  StatusCode        sc;
  MsgStream log( msgSvc(), name() );

  // Check to see whether a new Event Selector has been specified
  SmartIF<IProperty> prpMgr(IID_IProperty, serviceLocator());
  if ( prpMgr.isValid() )   {
    setProperty(prpMgr->getProperty("EvtSel"));
    if( m_evtsel != "NONE" || m_evtsel.length() == 0) {
      IEvtSelector* theEvtSel;
      sc = serviceLocator()->service( "EventSelector", theEvtSel );
      if( sc.isSuccess() && ( theEvtSel != m_evtSelector ) ) {
        // Setup Event Selector
        m_evtSelector = theEvtSel;
        m_evtIterator = m_evtSelector->begin();
        Service* theSvc = dynamic_cast< Service* >( theEvtSel );
        log << MSG::INFO << "EventSelector service changed to " << theSvc->name( ) << endreq;
      }
    }
  }


  // loop over events if the maxevt (received as input) is different from -1. 
  // if evtmax is -1 it means infinite loop
  for( int nevt = 0; (maxevt == -1 ? true : nevt < maxevt);  nevt++, total_nevt++) {
    //--------------------------------------------------------------------------------------------
    // Clear the event store, if used in the event loop
    //--------------------------------------------------------------------------------------------
    if( 0 != total_nevt ) {
      sc = m_evtDataMgrSvc->clearStore();
      if( !sc.isSuccess() )  {
        MsgStream log( msgSvc(), name() );
        log << MSG::DEBUG << "Clear of Event data store failed" << endreq;
      }
    }
    //--------------------------------------------------------------------------------------------
    // Setup event in the event store
    //--------------------------------------------------------------------------------------------
    if( m_evtIterator ) {
      // Only if there is a EventSelector
      if( *(m_evtIterator) == *(m_evtSelector->end()) ) {
        // This is the end of the loop. No more events in the selection
        MsgStream log( msgSvc(), name() );
        log << MSG::INFO << "No more events in event selection " << endreq;
        break;
      }
      // Create root address and assign address to data service
      IOpaqueAddress* addr = **m_evtIterator;
      // Set root clears the event data store first
      sc = m_evtDataMgrSvc->setRoot ("/Event", addr);
      if( !sc.isSuccess() )  {
        MsgStream log( msgSvc(), name() );
        log << MSG::WARNING << "Error declaring event root address." << endreq;
        continue;
      }
      sc = m_evtDataSvc->retrieveObject("/Event", pObject);
      if( !sc.isSuccess() ) {
        MsgStream log( msgSvc(), name() );
        log << MSG::WARNING << "Unable to retrieve Event root object" << endreq;
        break;
      }
    }
    else {
      sc = m_evtDataMgrSvc->setRoot ("/Event", new DataObject());
      if( !sc.isSuccess() )  {
        MsgStream log( msgSvc(), name() );
        log << MSG::WARNING << "Error declaring event root DataObject" << endreq;
      } 
    }
    // Execute event for all required algorithms
    sc = executeEvent(NULL);
    if( !sc.isSuccess() ){
      MsgStream log( msgSvc(), name() );
      log << MSG::ERROR << "Terminating event processing loop due to errors" << endreq;
      break;
    }
    //--------------------------------------------------------------------------------------------
    // increment event iterator
    //--------------------------------------------------------------------------------------------
    if (m_evtIterator)  (*m_evtIterator)++;
  }
  return StatusCode::SUCCESS;
}

---