DybEventLoopMgr.cpp

Go to the documentation of this file.

#define  DYBSVC_DYBEVENTLOOPMGR_CPP

#include "DybEventLoopMgr.h"

#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IConversionSvc.h"

DybEventLoopMgr::DybEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc)
    : MinimalEventLoopMgr(nam, svcLoc)
    , m_evtDataMgrSvc(0)
    , m_evtDataSvc(0)
    , m_evtSelector(0)
    , m_evtContext(0)
{
    declareProperty("EvtSel", m_evtSelName="NONE",
                    "Name of Event Selector to use (def: NONE)");
    declareProperty("EventStore", m_evtStoreName="EventDataSvc",
                    "Name of the Event Store provider (def: EventDataSvc)");

}

DybEventLoopMgr::~DybEventLoopMgr()   
{
}

StatusCode DybEventLoopMgr::initialize()    {
    // initilaize the base class
    MsgStream log(msgSvc(), name());

    StatusCode sc = MinimalEventLoopMgr::initialize();

    if (sc.isFailure()) {
        log << MSG::WARNING << "Error Initializing base class MinimalEventLoopMgr." << endreq;
        return sc;
    }

    log << MSG::DEBUG
        << "Getting event store service"
        << endreq;
   // Setup access to event data services
    sc = serviceLocator()->service(m_evtStoreName, m_evtDataMgrSvc, true);
    if (sc.isFailure()) {
        log << MSG::FATAL << "Error retrieving EventDataSvc interface IDataManagerSvc." << endreq;
        return sc;
    }
    sc = serviceLocator()->service(m_evtStoreName, m_evtDataSvc, true);
    if (sc.isFailure()) {
        log << MSG::FATAL << "Error retrieving EventDataSvc interface IDataProviderSvc." << endreq;
        return sc;
    }


    log << MSG::DEBUG
        << "Event selector name: \"" << m_evtSelName << "\""
        << endreq;

    if (!m_evtSelName.size() || "NONE" == m_evtSelName) {
        log << MSG::INFO << "No event selector to be used" << endreq;
        return StatusCode::SUCCESS;
    }
     
    sc = serviceLocator()->service(m_evtSelName, m_evtSelector, true);
    if (sc.isFailure()) {
        log << MSG::FATAL << "Failed to create event selector "
            << "\"" << m_evtSelName << "\"" << endreq;
        return sc;
    }

    sc = m_evtSelector->createContext(m_evtContext);
    if (sc.isFailure())   {
        log << MSG::FATAL << "Can not create the event selector Context." << endreq;
        return sc;
    }

    log << MSG::INFO << "initialized with EvtSel = " << m_evtSelName
        << ", Event Store = " << m_evtStoreName << endreq;

    return StatusCode::SUCCESS;
}

StatusCode DybEventLoopMgr::reinitialize() {
    // reinitilaize the base class
    StatusCode sc = MinimalEventLoopMgr::reinitialize();
    if (sc.isFailure()) return sc;

    MsgStream log(msgSvc(), name());
    log << MSG::DEBUG << "I'm being reinitialized.  Why?" << endreq;

    return StatusCode::SUCCESS;
}

StatusCode DybEventLoopMgr::finalize()
{
    MsgStream log(msgSvc(), name());

    // Release evemt selector context
    if (m_evtSelector && m_evtContext) {
        m_evtSelector->releaseContext(m_evtContext).ignore();
        m_evtContext = 0;
    }

    // Release all interfaces...
    m_evtSelector     = releaseInterface(m_evtSelector);
    m_evtDataSvc      = releaseInterface(m_evtDataSvc);
    m_evtDataMgrSvc   = releaseInterface(m_evtDataMgrSvc);

    return MinimalEventLoopMgr::finalize();
}

// WTF doesn't MinimalEventLoopMgr handle this?
StatusCode DybEventLoopMgr::executeEvent(void* par)    
{
    MsgStream log(msgSvc(), name());

    if (m_scheduledStop) {
        log << MSG::ALWAYS 
            << "Terminating event processing loop due to a stop scheduled by an incident listener"
            << endreq;
        return StatusCode::SUCCESS;
    }

    // Execute Algorithms
    StatusCode sc = MinimalEventLoopMgr::executeEvent(par);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Terminating event processing loop due to errors" << endreq;
    }

    return sc;
}

StatusCode DybEventLoopMgr::nextEvent(int maxevt)   
{
    StatusCode        sc = StatusCode::SUCCESS;
    MsgStream         log( msgSvc(), name() );

    // loop over events if the maxevt (received as input) if different from -1. 
    // if evtmax is -1 it means infinite loop
    for (int nevt = 0; (maxevt == -1 ? true : nevt < maxevt);  ++nevt) {

        log << MSG::DEBUG
            << "Executing event loop #" << nevt << endreq;

        // Check if there is a scheduled stop issued by some algorithm/sevice
        if (m_scheduledStop) {
            m_scheduledStop = false;
            log << MSG::ALWAYS
                << "Terminating event processing loop due to scheduled stop" << endreq;
            return StatusCode::SUCCESS;
        }

        sc = m_evtDataMgrSvc->clearStore();
        if (sc.isFailure()) {
            log << MSG::DEBUG << "Clear of Event data store failed" << endreq;
        }

        // Setup event in the event store
        if (m_evtContext) {
            IOpaqueAddress* addr = 0;
            // Only if there is a EventSelector
            sc = getEventRoot(addr);
            if (sc.isFailure())  {
                log << MSG::INFO << "No more events in event selection " << endreq;
                return StatusCode::SUCCESS;
            }

            // Set root clears the event data store first
            sc = m_evtDataMgrSvc->setRoot("/Event", addr);
            if (sc.isFailure())  {
                log << MSG::WARNING << "Error declaring event root address." << endreq;
                continue; // not failure?
            }
            DataObject* pObject = 0;
            sc = m_evtDataSvc->retrieveObject("/Event", pObject);
            if( sc.isFailure() ) {
                log << MSG::WARNING << "Unable to retrieve Event root object" << endreq;
                return StatusCode::FAILURE;
            }
        }
        else {
            sc = m_evtDataMgrSvc->setRoot ("/Event", new DataObject());
            if (sc.isFailure() )  {
                log << MSG::WARNING << "Error declaring event root DataObject" << endreq;
            } 
        }
        // Execute event for all required algorithms
        sc = executeEvent(NULL);
        if (sc.isFailure()){
            log << MSG::ERROR << "Terminating event processing loop due to errors" << endreq;
            return StatusCode::FAILURE;
        }
    }
    return StatusCode::SUCCESS;
}

StatusCode DybEventLoopMgr::getEventRoot(IOpaqueAddress*& refpAddr)  
{
    refpAddr = 0;
    StatusCode sc = m_evtSelector->next(*m_evtContext);
    if (sc.isFailure())  {
        return sc;
    }

    // Create root address and assign address to data service
    sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
    if (sc.isFailure()) {
        sc = m_evtSelector->next(*m_evtContext);
        if (sc.isSuccess()) {
            sc = m_evtSelector->createAddress(*m_evtContext,refpAddr);
            if (sc.isFailure())  {
                MsgStream log( msgSvc(), name() );
                log << MSG::WARNING << "Error creating IOpaqueAddress." << endreq;
            }
        }
    }
    return sc;
}