RootEvtSelector.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Event/RootCnvSvc/src/RootEvtSelector.cxx,v 1.23 2022/01/24
// 04:07:17 maqm Exp $
//
// Description:
#include "RootCnvSvc/RootEvtSelector.h"
#include "EventModel/EventModel.h"
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/StatusCode.h"
#include "RootCnvSvc/RootEventContext.h"
#include "RootCnvSvc/RootInterface.h"
#include "TagFilterSvc/ITagFilterSvc.h"
// #include "TagFilterSvc/TagFilterSvc.h"
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/SmartIF.h"
 
#include "TFile.h"
#include "TFormula.h"
#include "TTree.h"
#include <fstream>
#include <vector>
 
extern const CLID&    CLID_Event;
extern const long int ROOT_StorageType;
 
// static const SvcFactory<RootEvtSelector> s_factory;
// const ISvcFactory& RootEvtSelectorFactory = s_factory;
 
// Constructor
 
DECLARE_COMPONENT( RootEvtSelector )
RootEvtSelector::RootEvtSelector( const std::string& name, ISvcLocator* svcloc )
    : base_class( name, svcloc ), p_beginContext( 0 ), p_endContext( 0 ) {
  m_recId      = new int;
  ( *m_recId ) = -1;
  declareProperty( "Input", m_jobInput = "ROOT" );
  getMaxEvent();
}
RootEvtSelector::~RootEvtSelector() { delete m_recId; }
// Instantiation of a static factory class used by clients to create
// instances of this service
StatusCode RootEvtSelector::initialize() {
  MsgStream  log( msgSvc(), name() );
  StatusCode sc = Service::initialize();
  log << MSG::DEBUG << "RootEvtSelector::initialize" << endmsg;
  if ( sc.isSuccess() )
  {
    // setProperties();
  }
  else { log << MSG::ERROR << "Unable to initialize service " << endmsg; }
 
  if ( m_jobInput.value() != " " )
  {
    sc = setCriteria( m_jobInput );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Unable to get input value" << endmsg;
      return sc;
    }
  }
 
  // Retrieve conversion service handling event iteration
  sc = serviceLocator()->service( "EventCnvSvc", m_addrCreator );
  if ( !sc.isSuccess() )
  {
    log << MSG::ERROR << "Unable to localize interface IID_IAddressCreator from service:"
        << "RootEventSelector" << endmsg;
    return sc;
  }
 
  // Get DataSvc
  IDataManagerSvc* eds = 0;
  sc                   = serviceLocator()->service( "EventDataSvc", eds, true );
  if ( !sc.isSuccess() )
  {
    log << MSG::ERROR << "Unable to localize interface IID_IDataManagerSvc "
        << "from RootEventSelector" << endmsg;
    return sc;
  }
 
  m_rootCLID = eds->rootCLID();
 
  // provide access to the Root Interface
  m_rootInterface = RootInterface::Instance( name() );
  log << MSG::INFO << "currentFile in RootEvtSelector::initialize "
      << m_rootInterface->getCurrentFileName() << endmsg;
  if ( !m_rootInterface )
    log << MSG::ERROR << "Unable to start Root service within RootCnvSvc" << endmsg;
 
  // create root event context
  p_beginContext = new RootEventContext( this );
 
  ISvcLocator* svcLocator = Gaudi::svcLocator();
  StatusCode   status     = svcLocator->service( "TagFilterSvc", m_tagFilterSvc );
  if ( status.isSuccess() ) { log << MSG::INFO << "get the TagFilterSvc" << endmsg; }
  else { log << MSG::WARNING << "could not get the TagFilterSvc. Ignore it." << endmsg; }
 
  auto tag_files = m_tagFilterSvc->getTagFiles();
  cout << "RootEvtSelector, tag_files: " << tag_files.size() << endl;
 
  m_rootInterface->setTagInputFile( tag_files );
 
  // m_rootInterface->setTagInputFile( m_tagFilterSvc->getTagFiles() );
 
  vector<string> dstFiles = m_tagFilterSvc->getDstFiles();
  int            size     = dstFiles.size();
  std::string    treeName = "Event";
 
  for ( int i = 0; i < size; i++ )
  {
    std::cout << "RootEvtSelector, dstFile: " << dstFiles[i] << std::endl;
    m_rootInterface->addInput( treeName, dstFiles[i].c_str() );
  }
  return sc;
}
 
StatusCode RootEvtSelector::setCriteria( const std::string& criteria ) {
  // Purpose and Method:  set the input criteria
  MsgStream log( msgSvc(), name() );
  m_criteria = criteria;
 
  if ( criteria == "ROOT" )
  {
    log << MSG::INFO << "RootEvtSelector input has been set to ROOT" << endmsg;
    m_criteriaType = ROOT;
  }
  else if ( criteria == "NONE" )
  {
    m_criteriaType = NONE;
    log << MSG::INFO << "RootEvtSelector input has been set to NONE" << endmsg;
  }
  else
  {
    log << MSG::ERROR << "Invalid Event Selection Criteria: " << criteria << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}
 
StatusCode RootEvtSelector::createContext( IEvtSelector::Context*& it ) const {
  it = p_beginContext;
  return ( StatusCode::SUCCESS );
}
 
// Implementation of IEvtSelector::next().
StatusCode RootEvtSelector::next( IEvtSelector::Context& it ) const { return this->next(); }
 
//__________________________________________________________________________
StatusCode RootEvtSelector::next( IEvtSelector::Context& ctxt, int jump ) const {
  if ( jump > 0 )
  {
    for ( int i = 0; i < jump; ++i )
    {
      StatusCode status = next( ctxt );
      if ( !status.isSuccess() ) { return status; }
    }
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}
 
StatusCode RootEvtSelector::previous( IEvtSelector::Context& /*it*/ ) const {
  MsgStream log( msgSvc(), name() );
  log << MSG::ERROR << "RootEvtSelector::previous() not implemented" << endmsg;
  return ( StatusCode::FAILURE );
}
 
StatusCode RootEvtSelector::previous( IEvtSelector::Context& it, int /*jump*/ ) const {
  return ( previous( it ) );
}
 
StatusCode RootEvtSelector::last( IEvtSelector::Context& it ) const {
  if ( it.identifier() == p_endContext->identifier() )
  {
    MsgStream log( msgSvc(), name() );
    log << MSG::DEBUG << "last(): Last event in InputStream." << endmsg;
    return ( StatusCode::SUCCESS );
  }
  return ( StatusCode::FAILURE );
}
 
StatusCode RootEvtSelector::resetCriteria( const std::string& /*criteria*/,
                                           IEvtSelector::Context& /*ctxt*/ ) const {
  return ( StatusCode::SUCCESS );
}
 
StatusCode RootEvtSelector::rewind( IEvtSelector::Context& /*it*/ ) const {
  MsgStream log( msgSvc(), name() );
  log << MSG::ERROR << "RootEvtSelector::rewind() not implemented" << endmsg;
  return ( StatusCode::FAILURE );
}
 
StatusCode RootEvtSelector::releaseContext( IEvtSelector::Context*& /*it*/ ) const {
  return ( StatusCode::SUCCESS );
}
 
StatusCode RootEvtSelector::createAddress( const IEvtSelector::Context& /*it*/,
                                           IOpaqueAddress*& iop ) const {
  iop = new GenericAddress( ROOT_StorageType, CLID_Event, " ", " ", 0 );
  return ( StatusCode::SUCCESS );
}
 
void RootEvtSelector::getEntryFromTag() const {
  bool flag = true;
  ;
  MsgStream          log( msgSvc(), name() );
  static std::string tempFile = "";
  log << MSG::DEBUG << "current file: " << m_rootInterface->getCurrentFileName() << endmsg;
  std::ifstream           fin;
  static std::string      tagFile;
  static int              i = -1;
  static std::vector<int> ventry;
  int                     num1 = m_rootInterface->getCurrentFileNum();
  int                     num2 = m_rootInterface->getTotalFileNum();
 
  if ( tempFile != m_rootInterface->getCurrentFileName() )
  {
    tempFile = m_rootInterface->getCurrentFileName();
    log << MSG::DEBUG << "temp file: " << tempFile << endmsg;
    i = -1;
    ventry.clear();
    log << MSG::DEBUG << "num1: " << num1 << " num2: " << num2 << endmsg;
    tagFile = ( m_rootInterface->getTagInputFile() )[num1];
    log << MSG::DEBUG << "tag file: " << tagFile << endmsg;
    m_tagFilterSvc->getVEntry( tagFile, ventry );
  } // end of read a tag file
 
  i++;
  log << MSG::DEBUG << "ventry i: " << i << endmsg;
  log << MSG::DEBUG << "ventry size: " << ventry.size() << endmsg;
  if ( i < ventry.size() )
  {
    ( *m_recId ) = ventry[i];
    log << MSG::DEBUG << "ventry[i]: " << ventry[i] << endmsg;
  }
  else ( *m_recId ) = -1;
 
  log << MSG::DEBUG << "(*m_recId): " << ( *m_recId ) << endmsg;
 
  int vs = ventry.size();
 
  if ( ( i > ( vs - 1 ) ) && ( num1 < ( num2 - 1 ) ) )
  {
    bool endAll = m_rootInterface->checkEndOfTree();
    getEntryFromTag();
  }
  if ( ( i > ( vs - 1 ) ) && ( num1 == ( num2 - 1 ) ) ) ( *m_recId ) = -1;
}
 
StatusCode RootEvtSelector::next() const {
  MsgStream log( msgSvc(), name() );
  if ( m_criteriaType == ROOT )
  {
    log << MSG::INFO << "m_criteriaType == ROOT" << endmsg;
    if ( m_rootInterface->getSelectFromTag() != 0 )
    {
      getEntryFromTag();
      if ( ( *m_recId ) < 0 ) return StatusCode::FAILURE;
    }
 
    else
    {
      ( *m_recId )++;
 
      // if((*m_recId)>m_evtMax){ // if get the max event number?
      //   return StatusCode::FAILURE;
      // }else{  //didn't get the max event number
 
      static int entry = 0;
 
      bool endOfFile = m_rootInterface->getEOF();
      entry++;
      bool maxEntry =
          ( entry > m_rootInterface->getEntries() && m_rootInterface->getEntries() >= 0 );
      if ( maxEntry ) entry = 1;
      log << MSG::INFO << "entry = " << entry << "    " << maxEntry << "   " << endOfFile
          << endmsg;
      if ( endOfFile || maxEntry )
      { // the using file is get max event or get the end of file
        bool endAll = m_rootInterface->checkEndOfTree();
 
        if ( endAll )
        { // if all is finished ?
          return StatusCode::FAILURE;
        }
      }
    }
    //}  // to make it run if not set event number from jobOption
  } // end if(m_criteriaType == ROOT)
  else if ( m_criteriaType == NONE )
  {
    log << MSG::DEBUG << "Reading Event " << ( *m_recId ) << endmsg;
    // If we go over the count set equal to the end
    if ( ( *m_recId ) > m_evtMax ) { return StatusCode::FAILURE; }
  }
  else
  {
    // We are going to blow up if this situation happens
    log << MSG::FATAL << "Cannot iterate a dead iterator" << endmsg;
    return StatusCode::FAILURE;
  }
 
  log << MSG::DEBUG << "Reading Event " << ( *m_recId ) << endmsg;
  log << MSG::DEBUG << "Max Event " << m_evtMax << endmsg;
  return StatusCode::SUCCESS;
}
 
StatusCode RootEvtSelector::queryInterface( const InterfaceID& riid, void** ppvInterface ) {
  if ( riid == IID_IRootEvtSelector ) { *ppvInterface = (RootEvtSelector*)this; }
  else if ( riid == IEvtSelector::interfaceID() ) { *ppvInterface = (IEvtSelector*)this; }
  else if ( riid == IProperty::interfaceID() ) { *ppvInterface = (IProperty*)this; }
  else { return Service::queryInterface( riid, ppvInterface ); }
  addRef();
  return StatusCode::SUCCESS;
}
 
StatusCode RootEvtSelector::getMaxEvent() {
  IProperty* appPropMgr = 0;
  StatusCode status =
      serviceLocator()->getService( "ApplicationMgr", IProperty::interfaceID(),
                                    reinterpret_cast<IInterface*&>( appPropMgr ) );
  if ( status.isFailure() ) return status;
 
  IntegerProperty evtMax( "EvtMax", 0 );
  status = appPropMgr->getProperty( &evtMax );
  if ( status.isFailure() ) return status;
 
  m_evtMax = evtMax.value();
  return status;
}