xAODEventSelector.cxx

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// xAODEventSelector.cxx
// Implementation file for class xAODEventSelector
// Author: Johannes Elmsheuser, Will Buttinger
 
// STL includes
#include <string>
#include <algorithm>
#include <memory>
#include <vector>
#include <stdint.h>
 
// ROOT includes
#include "TROOT.h"
#include "TClass.h"
#include "TFile.h"
#include "TKey.h"
#include "TLeaf.h"
#include "RootUtils/TBranchElementClang.h"
#include <ROOT/RNTuple.hxx>
#include <ROOT/RNTupleReader.hxx>
 
#include "Gaudi/Property.h"
 
// Framework includes
#include "GaudiKernel/FileIncident.h"
#include "GaudiKernel/IIoComponentMgr.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/ITHistSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/IClassIDSvc.h"
#include "AthenaKernel/IDictLoaderSvc.h"
#include "AthenaKernel/CLIDRegistry.h"
#include "CxxUtils/checker_macros.h"
#include "StorageSvc/DbType.h"
 
// StoreGate includes
 
#include "SGTools/BuiltinsClids.h"   // to make sure we have their clids
#include "SGTools/StlMapClids.h"     // to make sure we have their clids
#include "SGTools/StlVectorClids.h"  // to make sure we have their clids
#include "SGTools/TransientAddress.h"
#include "StoreGate/StoreGateSvc.h"
 
// EventInfo includes
#include "EventInfo/EventInfo.h"
#include "EventInfo/EventType.h"
#include "EventInfo/EventID.h"
#include "xAODEventInfo/EventInfo.h"
 
// Package includes
#include "xAODEventSelector.h"
#include "xAODBranchAddress.h"
#include "xAODEvent.h"
#include "RootGlobalsRestore.h"
 
// xAOD include(s):
#include "xAODRootAccess/Init.h"
#include "xAODRootAccess/tools/Utils.h"
 
#include "GaudiKernel/ServiceHandle.h"
#include "AthenaKernel/IProxyProviderSvc.h"
 
#include "xAODCore/tools/ReadStats.h"
#include "xAODCore/tools/PerfStats.h"
#include "xAODCore/tools/IOStats.h"
 
namespace Athena {
 
namespace {
  bool isRNTupleFile(const TFile& file) {
    if (file.FindKey(xAOD::Event::EVENT_RNTUPLE_NAME)) return true;
    if (file.FindKey(xAOD::Event::EVENT_TREE_NAME)) return false;
    const TKey* key = file.FindKey(xAOD::Event::METADATA_OBJECT_NAME);
    if (!key) return false;
    const TClass* cl = TClass::GetClass(key->GetClassName(), kFALSE, kTRUE);
    return cl && cl->InheritsFrom(ROOT::RNTuple::Class());
  }
}

class xAODEventContext : public ::IEvtSelector::Context
{
public:
  xAODEventContext(const xAODEventSelector* sel) : m_evtsel(sel) {}
  virtual ~xAODEventContext() {}
  virtual void* identifier() const override {
    void* id ATLAS_THREAD_SAFE = const_cast<xAODEventSelector*>(m_evtsel);
    return id;
  }

  const std::vector<std::string>& files() const { return m_evtsel->m_inputCollectionsName.value(); }
  const TFile* file() const { return m_evtsel->m_tfile; }
  StatusCode setFile ATLAS_NOT_THREAD_SAFE (const std::string& fname) {
    return const_cast<xAODEventSelector*>(m_evtsel)->setFile(fname);
  }

  std::size_t fileIndex() const { return m_evtsel->m_collIdx; }
  int64_t entry() const { return m_evtsel->m_curEvt; }
 
private:
  const xAODEventSelector* m_evtsel;
};
 
xAODEventSelector::xAODEventSelector( const std::string& name,
                                                  ISvcLocator* svcLoc ) :
  base_class ( name,    svcLoc ),
  m_dataStore( "StoreGateSvc/StoreGateSvc", name ),
  m_imetaStore( "StoreGateSvc/InputMetaDataStore", name ),
  m_ometaStore( "StoreGateSvc/MetaDataStore", name ),
  m_clidsvc  ( "ClassIDSvc",   name ),
  m_dictsvc  ( "AthDictLoaderSvc", name ),
  m_incsvc   ( "IncidentSvc", name ),
  m_poolSvc  ( "PoolSvc" , name ),
  m_ppSvc    ( "ProxyProviderSvc" , name ),
  m_nbrEvts  ( 0 ),
  m_curEvt   ( 0 ),
  m_collIdx  ( 0 ),
  m_collEvts (   ),
  m_needReload (true),
  m_rootAddresses (),
  m_event(),
  m_tfile(NULL),
  m_event_entries(0)
{
//Properties important to end user:
   declareProperty( "InputCollections", m_inputCollectionsName,"List of input (ROOT) file names" );
   declareProperty( "SkipEvents",m_skipEvts = 0,"Number of events to skip at the beginning" );
   declareProperty( "AccessMode", m_accessMode = -1, "-1 = use TEvent Default; 0 = BranchAccess; 1 = ClassAccess; 2 = AthenaAccess" );
 
   declareProperty( "FillEventInfo", m_fillEventInfo=false,"If True, will fill old EDM EventInfo with xAOD::EventInfo content, necessary for database reading (IOVDbSvc)");
 
   declareProperty( "PrintPerfStats", m_printPerfStats=false,"If True, at end of job will print the xAOD perf stats");
 
//Expert Properties:
  declareProperty( "EvtStore", m_dataStore,       "Store where to publish data");
  declareProperty( "ProxyProviderSvc" , m_ppSvc , "The ProxyProviderSvc that we should register ourself in and connect the EvtStore to");
  declareProperty( "InputMetaStore",m_imetaStore,  "Store where to publish (input) metadata");
  declareProperty( "MetaStore",m_ometaStore,       "Store where to publish (output) metadata");
 
  declareProperty( "ReadMetaDataWithPool", m_readMetadataWithPool=false, "If true, metadata is read with POOL (by MetaDataSvc) instead of xAOD::Event");
  declareProperty( "printEventProxyWarnings", m_printEventProxyWarnings);
 
}
 
// Destructor
xAODEventSelector::~xAODEventSelector()
{}
 
StatusCode xAODEventSelector::initialize()
{
  ATH_MSG_VERBOSE ("Enter xAODEventSelector initialization...");
 
  CHECK( m_clidsvc.retrieve() );
  CHECK( m_dictsvc.retrieve() );
 
  const std::size_t nbrInputFiles = m_inputCollectionsName.value().size();
  if ( nbrInputFiles < 1 ) {
    ATH_MSG_ERROR("You need to give at least 1 input file !!" << endmsg
       << "(Got [" << nbrInputFiles << "] file instead !)");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_INFO("Selector configured to read [" << nbrInputFiles << "] file(s)...");
  }
 
  ATH_MSG_DEBUG("Calling xAOD::Init...");
  int old_level = gErrorIgnoreLevel;
  gErrorIgnoreLevel = kWarning;
  xAOD::Init().ignore();
  gErrorIgnoreLevel = old_level;
  //if using the AthROOTErrorHandlerSvc, need to initialize it once again to give back error handling control to svc
  if(serviceLocator()->existsService("AthROOTErrorHandlerSvc")) {
    ServiceHandle<IService> ehSvc("AthROOTErrorHandlerSvc",name());
    CHECK( ehSvc.retrieve() );
    CHECK( ehSvc->initialize() ); //gives back control to svc
    CHECK( ehSvc.release() );
  }
  //use the first file to decide on the storage technology (TTree or RNTuple)
  //of all input files and if reading metadata with POOL is ok
  {
    std::unique_ptr<TFile> f( TFile::Open( m_inputCollectionsName.value()[0].c_str() ) );
    if(!f) {
      ATH_MSG_ERROR("Failed to open first input file: " << m_inputCollectionsName.value()[0]);
      return StatusCode::FAILURE;
    }
    m_isRNTuple = isRNTupleFile(*f);
    //use FindKey as Get would read (and leak) the RNTuple anchor
    if(m_readMetadataWithPool && !f->FindKey("##Shapes")) {
      ATH_MSG_INFO("First file is not POOL file (e.g. is CxAOD), so reading metadata with xAOD::Event instead");
      m_readMetadataWithPool = false;
    }
    f->Close();
  }
 
  if(m_isRNTuple) {
    ATH_MSG_INFO("Using RNTuple xAOD access (AccessMode is only used for TTree input)");
    m_event = std::make_unique<xAOD::xAODREvent>(); //our special class inheriting from xAOD::REvent
  } else {
    switch(m_accessMode) {
      case -1: ATH_MSG_INFO("Using DEFAULT xAOD access mode (usually same as CLASS mode)"); break;
      case 0: ATH_MSG_INFO("Using BRANCH xAOD access mode"); break;
      case 1: ATH_MSG_INFO("Using CLASS xAOD access mode"); break;
      case 2: ATH_MSG_INFO("Using ATHENA xAOD access mode"); break;
    }
    if(m_accessMode != -1) {
     m_event = std::make_unique<xAOD::xAODTEvent>(xAOD::TEvent::EAuxMode(m_accessMode)); //our special class inheriting from xAOD::TEvent
    } else {
     m_event = std::make_unique<xAOD::xAODTEvent>(); //our special class inheriting from xAOD::TEvent
    }
  }
  m_event->printProxyWarnings(m_printEventProxyWarnings);
 
 
  {
    // register this service for 'I/O' events
    ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
    if (!iomgr.retrieve().isSuccess()) {
      ATH_MSG_FATAL("Could not retrieve IoComponentMgr !");
      return StatusCode::FAILURE;
    }
    if (!iomgr->io_register(this).isSuccess()) {
      ATH_MSG_FATAL("Could not register myself with the IoComponentMgr !");
      return StatusCode::FAILURE;
    }
    // register input file's names with the I/O manager
    const std::vector<std::string>& incol = m_inputCollectionsName.value();
    bool allGood = true;
    for (std::size_t icol = 0, imax = incol.size(); icol < imax; icol++) {
      if (!iomgr->io_register(this,
                              IIoComponentMgr::IoMode::READ,
                              incol[icol]).isSuccess()) {
        ATH_MSG_FATAL("could not register [" << incol[icol] << "] for output !");
        allGood = false;
      } else {
        ATH_MSG_VERBOSE("io_register[" << this->name() << "](" << incol[icol] << ") [ok]");
      }
    }
    if (!allGood) {
      return StatusCode::FAILURE;
    }
  }
 
  if (!do_init_io().isSuccess()) {
    return StatusCode::FAILURE;
  }
 
  // retrieve event stores
  // this needs to happen *after* having initialized the i/o
  // as our branches (which need a valid m_ntuple pointer)
  // may be asked to be registered as we are a ProxyProvider.
  // retrieving the event store will poke the ProxyProviderSvc...
/*
  if ( !m_dataStore.retrieve().isSuccess() ) {
    ATH_MSG_ERROR("Could not retrieve [" << m_dataStore.typeAndName() << "] !!");
    return StatusCode::FAILURE;
  }
 
  // ditto for (input) meta data store
  if (!m_imetaStore.retrieve().isSuccess()) {
    ATH_MSG_ERROR("Could not retrieve [" << m_imetaStore.typeAndName() << "] !!");
    return StatusCode::FAILURE;
  }
 
  // ditto for (output) meta data store
  if (!m_ometaStore.retrieve().isSuccess()) {
    ATH_MSG_ERROR
      ("Could not retrieve [" << m_ometaStore.typeAndName() << "] !!");
    return StatusCode::FAILURE;
  }
*/
 
  //ensure the xAODCnvSvc is listed in the EventPersistencySvc
  ServiceHandle<IProperty> epSvc("EventPersistencySvc",name());
 
 
  std::vector<std::string> propVal;
  CHECK( Gaudi::Parsers::parse( propVal , epSvc->getProperty("CnvServices").toString() ) );
  bool foundSvc(false); bool foundPoolSvc(false);
  for(const std::string& s : propVal) {
    if(s=="Athena::xAODCnvSvc") { foundSvc=true; }
    if(s=="AthenaPoolCnvSvc") { foundPoolSvc=true; } //only need this if in hybrid mode
  }
  if(!foundSvc) propVal.push_back("Athena::xAODCnvSvc");
  if(!foundPoolSvc && m_readMetadataWithPool) propVal.push_back("AthenaPoolCnvSvc");
 
  if(!foundSvc || (!foundPoolSvc && m_readMetadataWithPool)) {
    CHECK( epSvc->setProperty("CnvServices", Gaudi::Utils::toString( propVal ) ));
  }
 
 
  //we should also add ourself as a proxy provider
  CHECK( m_ppSvc.retrieve() );
 
  //ensure the MetaDataSvc is added as a provider first, if we are in hybrid mode
  if(m_readMetadataWithPool) {
    std::vector<std::string> propVal;
    IProperty* prop = dynamic_cast<IProperty*>(&*m_ppSvc);
    if (!prop) {
      return StatusCode::FAILURE;
    }
    CHECK( Gaudi::Parsers::parse( propVal , prop->getProperty("ProviderNames").toString() ) );
    bool foundSvc(false);
    for(const std::string& s : propVal) {
      if(s=="MetaDataSvc") { foundSvc=true; break; }
    }
    if(!foundSvc) {
      propVal.push_back("MetaDataSvc");
      IProperty* prop = dynamic_cast<IProperty*>(&*m_ppSvc);
      if (!prop) {
        return StatusCode::FAILURE;
      }
      CHECK( prop->setProperty("ProviderNames", Gaudi::Utils::toString( propVal ) ));
    }
  }
 
  //now we add ourself as a provider
  m_ppSvc->addProvider( this );
  //trigger a reload of proxies in the storegate, which will poke the proxyprovidersvc
  //not actually needed
  //CHECK( m_dataStore->loadEventProxies() );
 
 
  //finally ensure the storegate has our proxy set in it
  //FIXME: this doesnt seem to allow multi storegates on the fly ???
  //m_dataStore->setProxyProviderSvc( &*m_ppSvc );
 
  CHECK( m_ppSvc.release() );
 
 
  //load the first file .. this is so metadata can be read even if no events present
  //checked above that there's at least one file
  CHECK( setFile(m_inputCollectionsName.value()[0]) );
 
  //first FirstInputFile incident so that input metadata store is populated by MetaDataSvc
  m_incsvc->fireIncident(FileIncident(name(), "FirstInputFile", m_inputCollectionsName.value()[0]));
 
  if(m_printPerfStats) xAOD::PerfStats::instance().start();
 
 
  return StatusCode::SUCCESS;
}
 
StatusCode xAODEventSelector::stop()
{
  // Fire EndInputFile for any file still open (the event loop may end
  // before the file is fully read).
  m_inputFileGuard.reset();
  return StatusCode::SUCCESS;
}
 
StatusCode xAODEventSelector::finalize()
{
  ATH_MSG_VERBOSE ("Finalize...");
  // FIXME: this should be tweaked/updated if/when a selection function
  //        or filtering predicate is applied (one day?)
  ATH_MSG_INFO ("Total events read: " << (m_nbrEvts - m_skipEvts));
 
  if(m_printPerfStats) {
    xAOD::PerfStats::instance().stop();
    xAOD::IOStats::instance().stats().Print();
  }
 
 
  return StatusCode::SUCCESS;
}

// Const methods:
 
StatusCode
xAODEventSelector::next( IEvtSelector::Context& ctx ) const
{
  // std::cout << "::next(fidx=" << m_collIdx << ", eidx=" << m_curEvt << ")"
  //           << std::endl;
  ATH_MSG_DEBUG ("next() : iEvt " << m_curEvt);
 
  // get evt context
  xAODEventContext* rctx = dynamic_cast<xAODEventContext*>(&ctx);
  if ( 0 == rctx ) {
    ATH_MSG_ERROR ("Could not dyn-cast to xAODEventContext !!");
    throw GaudiException("xAODEventSelector::next() - Unable to get xAODEventContext","xAODEventSelector",StatusCode::FAILURE);
  }
 
 
  const TFile *file = rctx->file();
  if(file && m_nbrEvts==0) {
    //fire the BeginInputFile incident for the first file
    m_inputFileGuard = InputFileIncidentGuard::begin(*m_incsvc, name(),
                            file->GetName(), {},
                            /*endFileName=*/file->GetName());
  }
 
  if (!file) { //must be starting another file ...
    auto& fnames = rctx->files();
    //std::size_t fidx = rctx->fileIndex();
    if( rctx->setFile("").isFailure() ) {
      throw GaudiException("xAODEventSelector::next() - Fatal error when trying to setFile('')","xAODEventSelector",StatusCode::FAILURE);
    }
 
    while( m_event_entries == 0 ) { //iterate through files until we have one with entries
      if (m_collIdx < int(rctx->files().size())) {
         const std::string& fname = fnames[m_collIdx];
         if( rctx->setFile( fname ).isFailure() ) {
       throw GaudiException("xAODEventSelector::next() - Fatal error when trying to setFile('" + fname + "')","xAODEventSelector",StatusCode::FAILURE);
     }
         ATH_MSG_DEBUG("Event entries = " << m_event_entries);
     //fire incident for this file ..
     InputFileIncidentGuard::transition(m_inputFileGuard, *m_incsvc, name(),
                             rctx->file()->GetName(), {},
                             /*endFileName=*/rctx->file()->GetName());
      } else {
         // end of collections
    return StatusCode::FAILURE; //this is a valid failure ... athena will interpret as 'finished looping'
      }
      if( m_event_entries==0) m_collIdx++;
 
 
   } //end of while loop
 
  }
 
 
  ATH_MSG_DEBUG("m_curEvt=" << m_curEvt);
 
   //Infer the local entry (entry of current file) from the global entry
 
  int64_t global_entry = rctx->entry(); //the actual event counter
  int64_t entry = global_entry;
  if (m_collEvts[m_collIdx].min_entries < 0) {
    // need to trigger collmetadata...
    const_cast<xAODEventSelector*>(this)->find_coll_idx(entry);
  }
  // rctx::entry is the *global* entry number.
  // we need the local one...
  entry = global_entry - m_collEvts[m_collIdx].min_entries; //actual entry in the current file
 
 
 
  if ( m_event_entries > entry ) {
 
    // Load the event:
    if( m_event->getEntry( entry ) < 0 ) {
         ATH_MSG_ERROR( "Failed to load entry " << static_cast< int >( entry ) );
     throw GaudiException("xAODEventSelector::next() - xAOD::Event::getEntry returned less than 0 bytes","xAODEventSelector",StatusCode::FAILURE);
    }
 
    ++m_nbrEvts;
    m_curEvt = global_entry + 1;
 
    // std::cout << "--event-info--" << std::endl;
    // event info
 
    // EventInfo is required, otherwise Athena will crash
    const xAOD::EventInfo* xaodEventInfo = 0;
    if(m_fillEventInfo) {
      if(m_event->retrieve( xaodEventInfo , "EventInfo").isFailure()) {
    ATH_MSG_ERROR("Could not find xAOD::EventInfo");
    throw GaudiException("xAODEventSelector::next() - Could not find xAOD::EventInfo","xAODEventSelector",StatusCode::FAILURE);
      }
    }
    EventType* evtType = new EventType;
    //const std::size_t runNbr = (xaodEventInfo) ? xaodEventInfo->runNumber() : 0;
    EventInfo* evtInfo = new EventInfo(
                       (xaodEventInfo) ? new EventID(xaodEventInfo->runNumber(), xaodEventInfo->eventNumber(), xaodEventInfo->timeStamp(), xaodEventInfo->timeStampNSOffset(), xaodEventInfo->lumiBlock(), xaodEventInfo->bcid()) : new EventID(0, m_curEvt-1,0 ), evtType);
    if ( !m_dataStore->record( evtInfo, "EventInfo" ).isSuccess() ) {
      ATH_MSG_ERROR ("Could not record EventInfo !");
      delete evtInfo; evtInfo = 0;
      throw GaudiException("xAODEventSelector::next() - Could not record EventInfo","xAODEventSelector",StatusCode::FAILURE);
    }
 
    return StatusCode::SUCCESS;
 
  } else {
    // file is depleted — fire EndInputFile
    m_inputFileGuard.reset();
 
    // prepare for next file, if any...
    // std::cout << "=========================================================="
    //           << std::endl;
    // std::cerr << "::switch to next file...\n";
 
    // iterate over our "cached" transient addresses,
    // marking them as garbage and dropping the RootBranchAddress (as a side effect of
    // ::setAddress(NULL).
    // this way, the next time we hit ::createRootBranchAddress or ::updateAddress
    // all internal states are kosher.
 
    /*
     * Problem for rel22 --
     * The proxyProviderSvc 'moves' the transient addresses created in this class
     * and thus invalidates them.
     * The sequence is proxyProviderSvc will call "loadAddresses" method below but
     * when it puts them into a DataProxy it will move the addresses so they are now invalid
     *
     * Shortest route to fixing this is just to clear the addresses and not touch them again
     */
    self()->m_rootAddresses.clear();
 
    for (auto& iaddr : self()->m_rootAddresses) {
      iaddr.second = false; // mark as invalid
      SG::TransientAddress* taddr = iaddr.first;
      taddr->setAddress(NULL);
    }
    const bool forceRemove = false;
    CHECK( m_dataStore->clearStore(forceRemove) ); //must clear the storegate so that any tampering user did in EndInputFile incident is cleared
    m_needReload = true;
 
    m_collIdx += 1;
    CHECK( rctx->setFile("") );
    return next(*rctx);
  }
 
  // NOT REACHED
  // std::cout << "***end of collections***" << std::endl;
  // end of collections
  //return StatusCode::FAILURE;
}
 
StatusCode xAODEventSelector::next( Context& ctx, int jump ) const
{
  ATH_MSG_DEBUG ("next(" << jump << ") : iEvt " << m_curEvt);
 
  if (self()->seek(ctx, m_curEvt + jump).isSuccess()) {
    return StatusCode::FAILURE;
  }
  return next(ctx);
}
 
StatusCode
xAODEventSelector::previous( IEvtSelector::Context& ctx ) const
{
  return next( ctx, -1 );
}
 
StatusCode
xAODEventSelector::previous( Context& ctx, int jump ) const
{
  return next( ctx, -jump );
}
 
StatusCode
xAODEventSelector::last( Context& /*ctxt*/ ) const
{
  ATH_MSG_ERROR ("............. Last Event Not Implemented .............");
  return StatusCode::FAILURE;
}
 
 
StatusCode
xAODEventSelector::rewind( Context& ctxt ) const
{
  return self()->seek(ctxt, 0);
}
 
StatusCode
xAODEventSelector::createContext( Context*& refCtx ) const
{
  xAODEventContext *ctx = new xAODEventContext(this);
  refCtx = ctx;
  return StatusCode::SUCCESS;
}
 
StatusCode
xAODEventSelector::createAddress( const Context& /*refCtx*/,
                                        IOpaqueAddress*& /*addr*/ ) const
{
  //std::cerr << "::TTES::createAddress()...\n";
  return StatusCode::SUCCESS;
}
 
StatusCode
xAODEventSelector::releaseContext( Context*& refCtxt ) const
{
  if(refCtxt==0) return StatusCode::SUCCESS; //added to avoid warning from MetaDataSvc, which passes an empty context
  xAODEventContext *ctx  = dynamic_cast<xAODEventContext*>(refCtxt);
  if ( ctx )   {
    delete ctx; ctx = 0;
    return StatusCode::SUCCESS;
  }
 
  return StatusCode::FAILURE;
}
 
StatusCode
xAODEventSelector::resetCriteria( const std::string&, Context& ) const
{
  ATH_MSG_ERROR ("............. resetCriteria Not Implemented .............");
  return StatusCode::FAILURE;
}

// Non-const methods:

StatusCode
xAODEventSelector::seek (Context& refCtxt, int evtnum) const
{
  // std::cout << "::seek - evtnum=" << evtnum
  //           << " curevt=" << m_curEvt
  //           << " curcol=" << m_collIdx
  //           << std::endl;
  long coll_idx = find_coll_idx(evtnum);
  // std::cout << "::seek - evtnum=" << evtnum
  //           << " curevt=" << m_curEvt
  //           << " curcol=" << m_collIdx
  //           << " colidx=" << coll_idx
  //           << std::endl;
  if (coll_idx == -1 && evtnum < m_curEvt) {
    coll_idx = m_collIdx;
  }
 
  if (coll_idx == -1) {
    ATH_MSG_INFO("seek: reached end of input.");
    return StatusCode::RECOVERABLE;
  }
 
  if (coll_idx != m_collIdx) {
    // tell everyone we switched files...
    xAODEventContext* rctx = dynamic_cast<xAODEventContext*>(&refCtxt);
    if (!rctx) {
      return StatusCode::FAILURE;
    }
    ATH_CHECK(rctx->setFile(""));
  }
 
  m_collIdx = coll_idx;
  m_curEvt = evtnum;
 
  return StatusCode::SUCCESS;
}

int
xAODEventSelector::curEvent (const Context& /*refCtxt*/) const
{
  return m_curEvt;
}

StatusCode
xAODEventSelector::io_reinit()
{
  ATH_MSG_VERBOSE("I/O reinitialization...");
 
  ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
  if (!iomgr.retrieve().isSuccess()) {
    ATH_MSG_FATAL("Could not retrieve IoComponentMgr !");
    return StatusCode::FAILURE;
  }
  if (!iomgr->io_hasitem(this)) {
    ATH_MSG_FATAL("IoComponentMgr does not know about myself !");
    return StatusCode::FAILURE;
  }
  std::vector<std::string> inputCollections = m_inputCollectionsName.value();
 
  for (std::size_t
         i = 0,
         imax = m_inputCollectionsName.value().size();
       i < imax;
       ++i) {
    std::string &fname = inputCollections[i];
    // std::cout << "--retrieve new name for [" << fname << "]...\n";
    if (!iomgr->io_contains(this, fname)) {
      ATH_MSG_ERROR("IoComponentMgr does not know about [" << fname << "] !");
      return StatusCode::FAILURE;
    }
    if (!iomgr->io_retrieve(this, fname).isSuccess()) {
      ATH_MSG_FATAL("Could not retrieve new value for [" << fname << "] !");
      return StatusCode::FAILURE;
    }
    // std::cout << "--> [" << fname << "]\n" << std::flush;
  }
  // all good... copy over.
  m_inputCollectionsName = inputCollections;
 
  // remove our EventInfo if any...
  // {
  //   const bool force_remove = true;
  //   if (!m_dataStore->clearStore(force_remove).isSuccess()) {
  //     ATH_MSG_ERROR("could not clear event store!");
  //     return StatusCode::FAILURE;
  //   } else {
  //     ATH_MSG_INFO("sgdump: \n" << m_dataStore->dump());
  //   }
  // }
 
  // std::cout << "--> do_init_io...\n" << std::flush;
  if (!do_init_io().isSuccess()) {
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("I/O reinitialization... [done]");
  return StatusCode::SUCCESS;
}
 

StatusCode
xAODEventSelector::preLoadAddresses(StoreID::type /*storeID*/,
                                          tadList& /*tads*/)
{
  // std::cerr << "TTES::preLoadAddresses(" << int(storeID)
  //        << "," << tads.size()
  //        << ")...\n";
  return StatusCode::SUCCESS;
}

StatusCode
xAODEventSelector::loadAddresses(StoreID::type storeID, tadList& tads)
{
  if (m_needReload || m_rootAddresses.empty()) {
    //CHECK(createMetaDataRootBranchAddresses());
    return createRootBranchAddresses(storeID, tads);
  }
 
  return StatusCode::SUCCESS;
}

StatusCode
xAODEventSelector::updateAddress(StoreID::type /*storeID*/, SG::TransientAddress* tad,
                                 const EventContext& /*ctx*/)
{
  // check if this tad is known to us.
  if (tad) {
    auto itr = m_rootAddresses.find(tad);
    if ( itr != m_rootAddresses.end() && itr->second ) {
      return StatusCode::SUCCESS;
    }
    ATH_MSG_DEBUG("updateAddress: address [" << tad->clID() << "#"
          << tad->name() << ") NOT known to us.");
    return StatusCode::FAILURE;
  }
 
  // do nothing.
  return StatusCode::SUCCESS;
}


// Protected methods:
 
 
 
 
StatusCode
xAODEventSelector::createRootBranchAddresses(StoreID::type storeID,
                                                   tadList &tads)
{
  if (storeID != StoreID::EVENT_STORE) {
    ATH_MSG_INFO("-- not the event-store --");
    return(StatusCode::SUCCESS);
  }
 
  if (0 == m_tfile) {
    ATH_MSG_ERROR("null pointer to n-tuple !");
    return StatusCode::FAILURE;
  }
 
  TTree* inputTree = nullptr;
  std::unique_ptr<ROOT::RNTupleReader> inputNTuple;
  std::string ntupleName;
  if (m_isRNTuple) {
    if (m_tfile->FindKey(xAOD::Event::EVENT_RNTUPLE_NAME)) {
      inputNTuple = ROOT::RNTupleReader::Open(xAOD::Event::EVENT_RNTUPLE_NAME, m_tfile->GetName());
      ntupleName = xAOD::Event::EVENT_RNTUPLE_NAME;
    }
  } else {
    inputTree = dynamic_cast<TTree*>(m_tfile->Get(xAOD::Event::EVENT_TREE_NAME));
    ntupleName = xAOD::Event::EVENT_TREE_NAME;
  }
 
  //check if an object is available in the input collection, for RNTuple
  //the field name is derived as in xAOD::Experimental::REvent::connectObject
  auto hasInputObject = [&](const std::string& name) {
    if (inputTree) return inputTree->GetBranch(name.c_str()) != nullptr;
    const ROOT::RNTupleDescriptor& descriptor = inputNTuple->GetDescriptor();
    return descriptor.FindFieldId(xAOD::Utils::getFieldName(descriptor, name)) != ROOT::kInvalidDescriptorId;
  };
 
  if(inputTree != nullptr || inputNTuple != nullptr) {
 
 
    ATH_MSG_DEBUG("Reading xAOD::EventFormat");
 
    //  m_event->dump();
 
    const void* value_ptr = m_event.get(); //passed as 'parameter' to the address object
 
    std::set<std::string> missingAux;
 
    for( auto itr = m_event->inputEventFormat()->begin(); itr!=m_event->inputEventFormat()->end();++itr) {
      if(!hasInputObject(itr->second.branchName())) continue; //skip branches that are not available in the input collection
      ATH_MSG_VERBOSE("EFE:" << itr->first << " branchName = " << itr->second.branchName() << " className=" << itr->second.className());
      CLID id = 0;
      if( m_clidsvc->getIDOfTypeInfoName(itr->second.className(), id).isFailure() &&
      m_clidsvc->getIDOfTypeName(itr->second.className(), id).isFailure()) {
    //if this is an AuxStore (infer if key ends in Aux.), its possible we schema-evolved away from the version in the input file, but that this evolution is actually 'ok' in some cases. So don't print an error if the CLID is missing for an Aux, but we will print a warning at the end for these aux stores
    if(itr->second.branchName().compare(itr->second.branchName().length()-4,4,"Aux.")==0) {
      missingAux.insert( itr->second.className() );continue;
    } else {
      //vectors can be missing their std:: prefix, so add that and retry before failing
      TString className =  itr->second.className();
      //ALT solution to this is do what RootNtupleEventSelector does: uses TClass:GetClass
      //and GetTypeInfo() method to get the proper type info
      TClass *cls = TClass::GetClass(className);
      if(cls) {
        const std::type_info *ti = cls->GetTypeInfo();
        if(ti) className = System::typeinfoName(*ti);
      }
 
      if( m_clidsvc->getIDOfTypeInfoName(className.Data(), id).isFailure() &&
          m_clidsvc->getIDOfTypeName(className.Data(), id).isFailure()) {
        ATH_MSG_WARNING("No CLID for class " << itr->second.className() << " , cannot read " << itr->second.branchName());
        continue;
      }
    }
      }
 
      const std::string br_name = itr->second.branchName();
 
      Athena::xAODBranchAddress* addr = new Athena::xAODBranchAddress
        (pool::ROOT_StorageType.type(), id,
         ntupleName,
         br_name,
         (unsigned long)(value_ptr),
         (unsigned long)(0)); //IMPORTANT THIS IS 0: signals to xAODBranchAddress to read event-level info (see setEventAddress)
      // recycle old rootaddress, if any.
      SG::TransientAddress* taddr = NULL;
      // FIXME: should we only iterate over m_rootAddresses which have been marked
      //        as invalid ? (ie: iaddr->second == false)
      //        probably not worth it... (but depends on the "occupancy")
      for (auto
             iaddr = m_rootAddresses.begin(),
             iaddre= m_rootAddresses.end();
           iaddr != iaddre;
           ++iaddr) {
        SG::TransientAddress *old = iaddr->first;
        if (old->clID() == id &&
            old->name() == br_name) {
          // found a "cached" transient address which corresponds to this clid+key
          // bind it to our new RootBranchAddress...
          old->setAddress(addr);
          taddr = old;
          iaddr->second = true; // mark as valid
          break;
        }
      }
      if (taddr == NULL) {
        taddr = new SG::TransientAddress(id, br_name, addr);
        taddr->setProvider(this, storeID);
        taddr->clearAddress(false);
        // only add the *new* TransientAddress to the input list as the *old* ones
        // are already tracked by the datastore (via the sticky proxies)
        tads.push_back(taddr);
        // note: we can store this taddr *b/c* we don't clearAddress it
        // ie: b/c we just called clearAddress(false) so it will be recycled
        // over the events.
        m_rootAddresses.insert(std::make_pair(taddr, true));
      }
      // }
    }
 
 
    if(missingAux.size()) {
      std::string allAux; for(auto& s : missingAux) allAux += s + ", ";
      ATH_MSG_WARNING("The following AuxStore types are not directly accessible (missing CLID, possibly from schema evolution): " << allAux);
    }
  } //end if block of requiring input tree to exist
  else {
    ATH_MSG_DEBUG("No input collection found in input file " << m_tfile->GetTitle() );
  }
 
  m_needReload = false;
 
  ATH_MSG_DEBUG("In xAODEventSelector::createRootBranchAddresses end ...");
 
  return StatusCode::SUCCESS;
}
 
StatusCode
xAODEventSelector::createMetaDataRootBranchAddresses() const
{
 
  ATH_MSG_DEBUG("In xAODEventSelector::createMetaDataRootBranchAddresses start ...");
 
  if ( 0 == m_tfile ) {
    ATH_MSG_ERROR ("Could not get m_tfile !!");
    throw "xAODEventSelector: Unable to get m_tfile";
  }
 
  //FIXME JE
  ATH_MSG_DEBUG("m_tfile = " << m_tfile );
 
  // collect the names and type names of the metadata objects,
  // stored as branches (TTree) or top-level fields (RNTuple)
  std::vector<std::pair<std::string, std::string>> objects;
  if (m_isRNTuple) {
    if (!m_tfile->FindKey(xAOD::Event::METADATA_OBJECT_NAME)) std::abort();
    auto reader = ROOT::RNTupleReader::Open(xAOD::Event::METADATA_OBJECT_NAME, m_tfile->GetName());
    for (const auto& field : reader->GetDescriptor().GetTopLevelFields()) {
      // RNTuples store fields with an "Aux:" postfix instead of "Aux."
      std::string br_name = field.GetFieldName();
      if (br_name.ends_with("Aux:")) br_name.back() = '.';
      objects.emplace_back(std::move(br_name), field.GetTypeName());
    }
  } else {
    TTree* tree = dynamic_cast<TTree*>(m_tfile->Get(xAOD::Event::METADATA_OBJECT_NAME));
    ATH_MSG_DEBUG("tree = " << tree );
    if (!tree) std::abort();
    TObjArray *leaves = tree->GetListOfLeaves();
    if (!leaves) {
      ATH_MSG_INFO("no leaves!!");
      return StatusCode::SUCCESS;
    }
    for (Int_t i = 0; i < leaves->GetEntries(); ++i) {
      TLeaf *leaf = (TLeaf *)leaves->At(i);
      TBranch *branch = leaf->GetBranch();
      if (branch) {
        objects.emplace_back(branch->GetName(), leaf->GetTypeName());
      }
    }
  }
 
  // loop over metadata objects
  const std::string toCheck = "xAOD::";
  for (const auto& [br_name, type_name] : objects) {
 
      CLID id = 0;
      const void* value_ptr = m_event.get();
      // Skip if type_name does contain xAOD, ie. is not an xAOD container
      if (!type_name.contains(toCheck)) {
    ATH_MSG_DEBUG("** Skip type-name = " << type_name << ", br_name = " << br_name );
    continue;
      }
      const std::string sg_key = br_name;//m_tupleName.value()+"/"+br_name;
      TClass *cls = TClass::GetClass(type_name.c_str());
      const std::type_info *ti = 0;
 
      // Skip the EventFormat branch. That must not be disturbed by the
      // generic metadata handling.
      if( br_name == "EventFormat" ) continue;
 
      if (cls) {
        ti = cls->GetTypeInfo();
        // first, try to load a dict for that class...
        if (ti) {
          m_dictsvc->load_type(*ti);
        }
        if (!ti) {
          ATH_MSG_DEBUG("could not find a type-info for [" <<
                          type_name << "]");
          continue;
        }
 
    // Find the clid for the typeInfo
    id = CLIDRegistry::typeinfoToCLID(*ti);
 
    if (id == 0) {
      ATH_MSG_DEBUG("** could not find a CLID for type-name ["
            << type_name << "]");
      continue;
    }
 
 
 
    ATH_MSG_DEBUG("id = " << id << ", br_name = " << br_name << ", value_ptr = " << value_ptr);
        CxxUtils::RefCountedPtr<Athena::xAODBranchAddress> addr
          (new Athena::xAODBranchAddress
           (pool::ROOT_StorageType.type(), id,
            xAOD::Event::METADATA_OBJECT_NAME,
            br_name,
            (unsigned long)(value_ptr),
            (unsigned long)(1))); //IMPORTANT THIS IS 1: signals to BranchAddress to read metadata
    if (!m_imetaStore->recordAddress(br_name, std::move(addr), true).isSuccess()) {
      ATH_MSG_ERROR("could not record address at [" << br_name << "] in store ["
            << m_imetaStore->name() << "]");
    }
    // SG::TransientAddress* taddr = new SG::TransientAddress
    //   (id, sg_key, addr);
    // taddr->setProvider(this);
    // taddr->clearAddress(true);
    // tads.push_back(taddr);
      }
  }
 
  ATH_MSG_DEBUG("In xAODEventSelector::createMetaDataRootBranchAddresses end ...");
 
  return StatusCode::SUCCESS;
}
 
 
TFile*
xAODEventSelector::fetchNtupleFile(const std::string& fname) const
{
  TFile* file = NULL;
  if(fname.empty()) return file; //if blank, return 0
  RootGlobalsRestore rgr;
  //see if file already open
  file = (TFile*)gROOT->GetListOfFiles()->FindObject(fname.c_str());
  if (!file) {
    //open the file
    file = TFile::Open(fname.c_str(), "READ");
    if (file) file->SetName(fname.c_str());
  }
  //check file is ok before returning
  if (!file || file->IsZombie()) {
    ATH_MSG_ERROR("could not open next file in input collection ["
                  << fname << "]");
    if (file) {
      file->Close();
    }
    return 0;
  }
  return file;
}
 
//move onto given file
StatusCode xAODEventSelector::setFile(const std::string& fname) {
 
  TFile* newFile = fetchNtupleFile(fname);
  if(!newFile && !fname.empty()) {
      ATH_MSG_FATAL( "xAODEventSelector: Unable to fetch Ntuple: " << fname);
      return StatusCode::FAILURE; //failed to load file
  }
 
  if(m_tfile && m_tfile != newFile) {
    const std::string currFile = m_tfile->GetName();
    //disconnect pool if necessary ... always fire this, hopefully it is safe even if not needed
    m_poolSvc->disconnectDb("PFN:"+currFile).ignore();
    //close existing file
    m_tfile->Close();
    //we should also cleanup after pool, in case it has left open files dangling
  }
  m_tfile = newFile;
  m_event_entries = 0; //will set in a moment
 
  if(!m_tfile) return StatusCode::SUCCESS; //must have been setting to blank file
 
  //the event object can only read files of the storage technology of the first file
  if(isRNTupleFile(*m_tfile) != m_isRNTuple) {
      ATH_MSG_FATAL( "xAODEventSelector: Cannot read " << fname << ", mixing TTree and RNTuple input files is not supported");
      return StatusCode::FAILURE;
  }
 
  if(m_event->readFrom( *m_tfile ).isFailure()) {
      ATH_MSG_FATAL( "xAODEventSelector: xAOD::Event cannot read " << fname);
      return StatusCode::FAILURE;
  }
 
  m_event_entries = m_event->getEntries();
 
  //need to load metadata for file
   if (!m_imetaStore->clearStore().isSuccess()) {
      ATH_MSG_INFO("could not clear store [" << m_imetaStore.typeAndName() << "]");
      return StatusCode::FAILURE;
   }
 
 
  //with POOL, metadata is read by MetaDataSvc (which connects the file on demand), triggered by the BeginInputFile call
  if(!m_readMetadataWithPool) {
      if (!createMetaDataRootBranchAddresses().isSuccess()) {
         ATH_MSG_ERROR("Could not load metadata");
      }
  }
 
 
 
  return StatusCode::SUCCESS;
 
}
 
 
StatusCode
xAODEventSelector::do_init_io()
{
  // std::cout << "::fetchNtuple..." << std::endl;
 
  // initialize some helper structures and data
  {
    CollMetaData zero;
    zero.min_entries = -1;
    zero.max_entries = -1;
    m_collEvts.resize(m_inputCollectionsName.value().size(), zero);
    m_collIdx = 0;
  }
 
 
 
  //CHECK( setFile( m_inputCollectionsName.value()[m_collIdx] ) );
 
 
  // std::cout << "::clear-root-addresses..." << std::endl;
  // reset the list of branches
  //m_rootAddresses.clear();
  m_needReload = true;
 
  // skip events we are asked to skip
  m_curEvt  = m_skipEvts;
  m_nbrEvts = 0;
 
  // std::cout << "::fetchNtuple...[done]" << std::endl;
  return StatusCode::SUCCESS;
}

int
xAODEventSelector::find_coll_idx(int evtidx) const
{
  // std::cout << "--find_coll_idx(" << evtidx << ")..." << std::endl
  //           << "--collsize: " << m_collEvts.size() << std::endl;
  for (std::size_t i = 0, imax = m_collEvts.size();
       i < imax;
       ++i) {
    // std::cout << "--[" << i << "]...\n";
    CollMetaData &itr = m_collEvts[i];
    if (itr.min_entries == -1) {
      TFile *file = fetchNtupleFile(m_inputCollectionsName.value()[i]);
      if (file) {
        long offset = 0;
        if (i > 0) {
          CollMetaData &jtr = m_collEvts[i-1];
          offset += jtr.max_entries;
        }
        itr.min_entries = offset;
        if (m_isRNTuple) {
          const bool hasEvents = file->FindKey(xAOD::Event::EVENT_RNTUPLE_NAME) != nullptr;
          itr.max_entries = offset + ( (hasEvents) ? ROOT::RNTupleReader::Open(xAOD::Event::EVENT_RNTUPLE_NAME, file->GetName())->GetNEntries() : 0);
        } else {
          TTree* tree = dynamic_cast<TTree*>(file->Get(xAOD::Event::EVENT_TREE_NAME));
          itr.max_entries = offset + ( (tree) ? tree->GetEntriesFast() : 0);
        }
      } else {
    throw "xAODEventSelector: Unable to fetch ntuple";
      }
    }
    // std::cout << "--[" << i << "] => [" << itr.min_entries << ", "
    //           << itr.max_entries << ") evtidx=[" << evtidx << "]"
    //           << std::endl;
    if (itr.min_entries <= evtidx && evtidx < itr.max_entries) {
      return i;
    }
  }
  return -1;
}
 
 
int xAODEventSelector::size (Context& /*refCtxt*/) const {
   //use find_coll_idx to trigger a population of the m_collEvts ... dummy call with -1 to trigger all colls loaded
   find_coll_idx(-1);
   return m_collEvts.back().max_entries;
}
 
//not used for anything
void xAODEventSelector::handle(const Incident& /*incident*/) {
 
}
 
} //> namespace Athena