RootIoSvc.cxx

Go to the documentation of this file.

/**
 * @file RootIoSvc.cxx
 * @brief definition of the class RootIoSvc
 *
 *  $Header: /bes/bes/BossCvs/Event/RootIO/src/RootIoSvc.cxx,v 1.4 2011/02/17 01:27:10 maqm Exp
 * $ Original author: Heather Kelly heather@lheapop.gsfc.nasa.gov
 */
 
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/MsgStream.h"
 
#include "CLHEP/Random/Random.h"
 
#include <algorithm>
#include <vector>
 
/**
 * \class RootIoSvc
 *
 * \brief Service that implements the IRunable interface, to control the event loop.
 *Based on RootIoSvc of Glast.
 */
 
// includes
#include "Gaudi/Property.h"
#include "GaudiKernel/IRunable.h"
#include "GaudiKernel/Service.h"
#include "TSystem.h"
 
#include "RootIoSvc/IRootIoSvc.h"
 
// forward declarations
template <class TYPE> class SvcFactory;
class IAppMgrUI;
 
class RootIoSvc : virtual public Service,
                  virtual public IIncidentListener,
                  virtual public IRootIoSvc,
                  virtual public IRunable {
public:
  /// for the IRunnable interfce
  virtual StatusCode run();
 
  //------------------------------------------------------------------
  //  stuff required by a Service
 
  /// perform initializations for this service.
  virtual StatusCode initialize();
 
  /// perform the finalization, as required for a service.
  virtual StatusCode finalize();
 
  /// Query interface
  virtual StatusCode queryInterface( const InterfaceID& riid, void** ppvUnknown );
 
  /// Handles incidents, implementing IIncidentListener interface
  virtual void handle( const Incident& inc );
 
  virtual int getEvtMax() { return m_evtMax; };
 
  virtual void setRootEvtMax( unsigned int max );
 
  virtual void setRootTimeMax( unsigned int max );
 
  virtual void registerRootTree( TChain* ch );
 
  virtual bool setIndex( int i );
  virtual int  index() { return m_index; };
 
  virtual bool                setRunEventPair( std::pair<int, int> ids );
  virtual std::pair<int, int> runEventPair() { return m_runEventPair; };
 
  virtual int getAutoSaveInterval() { return m_autoSaveInterval; };
 
protected:
  /// Standard Constructor
  RootIoSvc( const std::string& name, ISvcLocator* al );
 
  /// destructor
  virtual ~RootIoSvc();
 
private:
  void beginEvent();
  void endEvent();
 
  /// Allow SvcFactory to instantiate the service.
  friend class SvcFactory<RootIoSvc>;
 
  /// Reference to application manager UI
  IAppMgrUI*      m_appMgrUI;
  IntegerProperty m_evtMax;
  IntegerProperty m_autoSaveInterval;
 
  // starting and ending times for orbital simulation
  DoubleProperty m_startTime;
  DoubleProperty m_endTime;
 
  unsigned int         m_rootEvtMax;
  int                  m_index;
  std::pair<int, int>  m_runEventPair;
  std::vector<TChain*> m_chainCol;
};
 
// declare the service factories for the RootIoSvc
// static SvcFactory<RootIoSvc> a_factory;
// const ISvcFactory& RootIoSvcFactory = a_factory;
 
// ------------------------------------------------
// Implementation of the RootIoSvc class
// ------------------------------------------------
/// Standard Constructor
RootIoSvc::RootIoSvc( const std::string& name, ISvcLocator* svc ) : Service( name, svc ) {
 
  declareProperty( "EvtMax", m_evtMax = 0 );
  declareProperty( "StartTime", m_startTime = 0 );
  declareProperty( "EndTime", m_endTime = 0 );
  declareProperty( "AutoSaveInterval", m_autoSaveInterval = 1000 );
  declareProperty( "StartingIndex", m_index = -1 );
  m_rootEvtMax = 0;
  // m_index = -1;
  m_runEventPair = std::pair<int, int>( -1, -1 );
  m_chainCol.clear();
}
 
/// Standard Destructor
RootIoSvc::~RootIoSvc() { m_chainCol.clear(); }
 
// initialize
StatusCode RootIoSvc::initialize() {
  StatusCode status = Service::initialize();
 
  // bind all of the properties for this service
  // setProperties ();
 
  // open the message log
  MsgStream log( msgSvc(), name() );
 
  status = serviceLocator()->queryInterface( IAppMgrUI::interfaceID(), (void**)&m_appMgrUI );
 
  // use the incident service to register begin, end events
  IIncidentSvc* incsvc = 0;
  status               = service( "IncidentSvc", incsvc, true );
 
  if ( status.isFailure() ) return status;
 
  incsvc->addListener( this, "BeginEvent", 100 );
  incsvc->addListener( this, "EndEvent", 0 );
 
  // Tell ROOT to reset signals to their default behavior
  gSystem->ResetSignal( kSigBus );
  gSystem->ResetSignal( kSigSegmentationViolation );
  gSystem->ResetSignal( kSigIllegalInstruction );
  gSystem->ResetSignal( kSigFloatingException );
 
  return StatusCode::SUCCESS;
}
 
// finalize
StatusCode RootIoSvc::finalize() {
  StatusCode status = StatusCode::SUCCESS;
  return status;
}
 
/// Query interface
StatusCode RootIoSvc::queryInterface( const InterfaceID& riid, void** ppvInterface ) {
  if ( IID_IRootIoSvc.versionMatch( riid ) ) { *ppvInterface = (IRootIoSvc*)this; }
  else if ( IRunable::interfaceID().versionMatch( riid ) ) { *ppvInterface = (IRunable*)this; }
  else if ( IIncidentListener::interfaceID().versionMatch( riid ) )
  { *ppvInterface = (IIncidentListener*)this; }
  else { return Service::queryInterface( riid, ppvInterface ); }
 
  addRef();
  return StatusCode::SUCCESS;
}
 
void RootIoSvc::setRootEvtMax( unsigned int max ) {
  // Purpose and Method:  Allow users of the RootIoSvc to specify the number
  //  of events found in their ROOT files
  if ( m_rootEvtMax == 0 )
  {
    m_rootEvtMax = max;
    return;
  }
 
  if ( m_rootEvtMax > max ) m_rootEvtMax = max;
}
 
void RootIoSvc::setRootTimeMax( unsigned int max ) {
  // Not yet used
  return;
}
 
void RootIoSvc::registerRootTree( TChain* ch ) { m_chainCol.push_back( ch ); }
 
bool RootIoSvc::setIndex( int i ) {
  if ( i < 0 ) return false;
  std::vector<TChain*>::iterator it;
  for ( it = m_chainCol.begin(); it != m_chainCol.end(); it++ )
  {
    if ( i >= ( *it )->GetEntries() ) return false;
  }
  m_index        = i;
  m_runEventPair = std::pair<int, int>( -1, -1 );
  return true;
}
 
bool RootIoSvc::setRunEventPair( std::pair<int, int> ids ) {
  std::vector<TChain*>::iterator it;
  for ( it = m_chainCol.begin(); it != m_chainCol.end(); it++ )
  {
    int readInd = ( *it )->GetEntryNumberWithIndex( ids.first, ids.second );
    if ( ( readInd < 0 ) || ( readInd >= ( *it )->GetEntries() ) ) return false;
  }
  m_runEventPair = ids;
  m_index        = -1;
  return true;
}
 
// handle "incidents"
void RootIoSvc::handle( const Incident& inc ) {
  if ( inc.type() == "BeginEvent" ) beginEvent();
  else if ( inc.type() == "EndEvent" ) endEvent();
}
 
void RootIoSvc::beginEvent() // should be called at the beginning of an event
{}
 
void RootIoSvc::endEvent() // must be called at the end of an event to update, allow pause
{
  m_index        = -1;
  m_runEventPair = std::pair<int, int>( -1, -1 );
}
 
StatusCode RootIoSvc::run() {
  // Purpose and Method:  Control the event loop
 
  StatusCode status = StatusCode::FAILURE;
  MsgStream  log( msgSvc(), name() );
 
  if ( 0 == m_appMgrUI ) return status;
 
  IProperty* propMgr = 0;
  status             = serviceLocator()->service( "ApplicationMgr", propMgr );
  if ( status.isFailure() )
  {
    log << MSG::ERROR << "Unable to locate PropertyManager Service" << endmsg;
    return status;
  }
 
  IntegerProperty evtMax( "EvtMax", 0 );
  status = propMgr->getProperty( &evtMax );
  if ( status.isFailure() ) return status;
 
  // Determine if the min number of ROOT events is less than the
  // requested number of events in the jobOptions file
  IntegerProperty rootEvtMax( "EvtMax", m_rootEvtMax );
  if ( rootEvtMax < evtMax ) setProperty( rootEvtMax );
  else setProperty( evtMax );
 
  // now find the top alg so we can monitor its error count
  //
  IAlgManager* theAlgMgr;
  status = serviceLocator()->getService( "ApplicationMgr", IAlgManager::interfaceID(),
                                         (IInterface*&)theAlgMgr );
  IAlgorithm*     theIAlg;
  Algorithm*      theAlgorithm = 0;
  IntegerProperty errorProperty( "ErrorCount", 0 );
 
  status = theAlgMgr->getAlgorithm( "Top", theIAlg );
  if ( status.isSuccess() )
  {
    try
    { theAlgorithm = dynamic_cast<Algorithm*>( theIAlg ); } catch ( ... )
    { status = StatusCode::FAILURE; }
  }
  if ( status.isFailure() )
  {
    log << MSG::WARNING << "Could not find algorithm 'Top'; will not monitor errors" << endmsg;
  }
 
  // loop over the events
 
  int    eventNumber = 0;
  double currentTime = m_startTime;
 
  {
    bool noend = true;
    log << MSG::INFO << "Runable interface starting event loop as :";
    if ( m_evtMax > 0 )
    {
      log << " MaxEvt = " << m_evtMax;
      noend = false;
    }
    if ( m_endTime > 0 )
    {
      log << " EndTime= " << m_endTime;
      noend = false;
    }
    log << endmsg;
 
    if ( noend )
    {
      log << MSG::WARNING << "No end condition specified: will not process any events!"
          << endmsg;
    }
  }
  // Not yet using time as a control on the event loop for ROOT
  while ( m_evtMax > 0 && eventNumber < m_evtMax || m_endTime > 0 && currentTime < m_endTime )
  {
 
    status = m_appMgrUI->nextEvent( 1 ); // currently, always success
 
    // the single event may have created a failure. Check the ErrorCount propery of the Top
    // alg.
    if ( theAlgorithm != 0 ) theAlgorithm->getProperty( &errorProperty );
    if ( status.isFailure() || errorProperty.value() > 0 ) { status = StatusCode::FAILURE; }
 
    if ( status.isFailure() ) break;
    // if(flux!=0){
    //    currentTime = flux->gpsTime();
    // }
    eventNumber++;
  }
  if ( status.isFailure() )
  { log << MSG::ERROR << "Terminating RootIoSvc loop due to error" << endmsg; }
  else if ( m_endTime > 0 && currentTime >= m_endTime )
  { log << MSG::INFO << "Loop terminated by time " << endmsg; }
  else { log << MSG::INFO << "Processing loop terminated by event count" << endmsg; }
  return status;
}