Athena::xAODEventSelector Class Reference

Class implementing the GAUDI IEvtSelector interface using ROOT TTree or RNTuple as a backend. More...

#include <xAODEventSelector.h>

Inheritance diagram for Athena::xAODEventSelector:

Classes
struct	CollMetaData

Public Member Functions
	xAODEventSelector (const std::string &name, ISvcLocator *svcLoc)
	Constructor with parameters:
virtual	~xAODEventSelector ()
	Destructor:
virtual StatusCode	initialize () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual void	handle (const Incident &incident) override
virtual StatusCode	io_reinit () override
	Callback method to reinitialize the internal state of the component for I/O purposes (e.g.
virtual int	size (Context &refCtxt) const override
	ICollectionSize interface
virtual StatusCode	createContext (Context *&refpCtxt) const override
virtual StatusCode	last (Context &refContext) const override
virtual StatusCode	next (Context &refCtxt) const override
virtual StatusCode	next (Context &refCtxt, int jump) const override
virtual StatusCode	previous (Context &refCtxt) const override
virtual StatusCode	previous (Context &refCtxt, int jump) const override
virtual StatusCode	rewind (Context &refCtxt) const override
virtual StatusCode	createAddress (const Context &refCtxt, IOpaqueAddress *&) const override
virtual StatusCode	releaseContext (Context *&refCtxt) const override
virtual StatusCode	resetCriteria (const std::string &cr, Context &ctx) const override
virtual StatusCode	seek (Context &refCtxt, int evtnum) const override
	Seek to a given event number.
virtual int	curEvent (const Context &refCtxt) const override
	return the current event number.
virtual StatusCode	preLoadAddresses (StoreID::type storeID, tadList &list) override
virtual StatusCode	loadAddresses (StoreID::type storeID, tadList &list) override
	get all new addresses from Provider for this Event.
virtual StatusCode	updateAddress (StoreID::type storeID, SG::TransientAddress *tad, const EventContext &ctx) override
	update a transient Address

Private Member Functions
StatusCode	createRootBranchAddresses (StoreID::type storeID, tadList &tads)
	helper method to create proxies
TFile *	fetchNtupleFile (const std::string &fname) const
	helper method to retrieve the correct tuple
StatusCode	createMetaDataRootBranchAddresses () const
	helper method to create proxies for the metadata store
StatusCode	do_init_io ()
	helper method to init the i/o components
StatusCode	setFile (const std::string &fname)
	switch to given file, loading metadata and triggering a beginInputFile incident
int	find_coll_idx (int evtidx) const
	helper method to get the collection index (into m_inputCollectionsName) for a given event index evtidx.
xAODEventSelector *	self () const
	non-const access to self (b/c ::next() is const)

Private Attributes
ServiceHandle< StoreGateSvc >	m_dataStore
	Pointer to the StoreGateSvc event store.
ServiceHandle< StoreGateSvc >	m_imetaStore
	Pointer to the StoreGateSvc input metadata store.
ServiceHandle< StoreGateSvc >	m_ometaStore
	Pointer to the StoreGateSvc output metadata store.
ServiceHandle< IClassIDSvc >	m_clidsvc
	Pointer to the IClassIDSvc.
ServiceHandle< IDictLoaderSvc >	m_dictsvc
	Pointer to the IDictLoaderSvc.
ServiceHandle< IIncidentSvc >	m_incsvc
	Handle to the incident service.
ServiceHandle< IPoolSvc >	m_poolSvc
	Handle to the PoolSvc (used in Hybrid mode when user is reading metadata with pool).
ServiceHandle< IProxyProviderSvc >	m_ppSvc
	Handle to the proxy provider svc.
StringArrayProperty	m_inputCollectionsName
	List of input files containing TTree or RNTuple.
long	m_skipEvts
	Number of events to skip at the beginning.
long	m_nbrEvts
	Number of Events read so far.
long	m_curEvt
	current event index
long	m_collIdx
	current collection index (into m_inputCollectionsName)
std::vector< CollMetaData >	m_collEvts
	cache of the number of entries for each collection
bool	m_needReload
std::unordered_map< SG::TransientAddress *, bool >	m_rootAddresses
std::unique_ptr< xAOD::Event >	m_event
	current Event being read (xAODTEvent for TTree or xAODREvent for RNTuple)
TFile *	m_tfile
	current TFile being read
long	m_event_entries
int	m_accessMode
bool	m_isRNTuple = false
bool	m_fillEventInfo = false
bool	m_readMetadataWithPool = false
bool	m_printPerfStats = false
bool	m_printEventProxyWarnings = true
std::optional< InputFileIncidentGuard >	m_inputFileGuard
	RAII guard: guarantees a matching EndInputFile for every BeginInputFile.

Friends
class	Athena::xAODEventContext

Detailed Description

Class implementing the GAUDI IEvtSelector interface using ROOT TTree or RNTuple as a backend.

Definition at line 50 of file xAODEventSelector.h.

Constructor & Destructor Documentation

xAODEventSelector()

Athena::xAODEventSelector::xAODEventSelector	(	const std::string &	name,
		ISvcLocator *	svcLoc )

Constructor with parameters:

Definition at line 125 of file xAODEventSelector.cxx.

                                                                        :
  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);
 
}

~xAODEventSelector()

Athena::xAODEventSelector::~xAODEventSelector ( )

virtual

Destructor:

Definition at line 168 of file xAODEventSelector.cxx.

{}

Member Function Documentation

createAddress()

StatusCode Athena::xAODEventSelector::createAddress ( const Context & refCtxt, IOpaqueAddress *&  ) const

overridevirtual

Definition at line 586 of file xAODEventSelector.cxx.

{
  //std::cerr << "::TTES::createAddress()...\n";
  return StatusCode::SUCCESS;
}

createContext()

StatusCode Athena::xAODEventSelector::createContext ( Context *& refpCtxt ) const

overridevirtual

IEvtSelector interface

Definition at line 578 of file xAODEventSelector.cxx.

{
  xAODEventContext *ctx = new xAODEventContext(this);
  refCtx = ctx;
  return StatusCode::SUCCESS;
}

createMetaDataRootBranchAddresses()

StatusCode Athena::xAODEventSelector::createMetaDataRootBranchAddresses ( ) const

private

helper method to create proxies for the metadata store

Definition at line 917 of file xAODEventSelector.cxx.

{
 
  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;
}

createRootBranchAddresses()

StatusCode Athena::xAODEventSelector::createRootBranchAddresses ( StoreID::type storeID, tadList & tads )

private

helper method to create proxies

className.ReplaceAll("vector","std::vector");

Definition at line 781 of file xAODEventSelector.cxx.

{
  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;
}

curEvent()

int Athena::xAODEventSelector::curEvent ( const Context & refCtxt ) const

overridevirtual

return the current event number.

Returns

The current event number.

Definition at line 663 of file xAODEventSelector.cxx.

{
  return m_curEvt;
}

do_init_io()

StatusCode Athena::xAODEventSelector::do_init_io ( )

private

helper method to init the i/o components

Definition at line 1110 of file xAODEventSelector.cxx.

{
  // 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;
}

fetchNtupleFile()

TFile * Athena::xAODEventSelector::fetchNtupleFile ( const std::string & fname ) const

private

helper method to retrieve the correct tuple

Definition at line 1029 of file xAODEventSelector.cxx.

{
  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;
}

finalize()

StatusCode Athena::xAODEventSelector::finalize ( )

overridevirtual

Definition at line 372 of file xAODEventSelector.cxx.

{
  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;
}

find_coll_idx()

int Athena::xAODEventSelector::find_coll_idx ( int evtidx ) const

private

helper method to get the collection index (into m_inputCollectionsName) for a given event index evtidx.

returns -1 if not found.

Definition at line 1145 of file xAODEventSelector.cxx.

{
  // 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;
}

handle()

void Athena::xAODEventSelector::handle ( const Incident & incident )

overridevirtual

Definition at line 1192 of file xAODEventSelector.cxx.

                                                {
 
}

initialize()

StatusCode Athena::xAODEventSelector::initialize ( )

overridevirtual

Definition at line 171 of file xAODEventSelector.cxx.

{
  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;
}

io_reinit()

StatusCode Athena::xAODEventSelector::io_reinit ( )

overridevirtual

Callback method to reinitialize the internal state of the component for I/O purposes (e.g.

upon fork(2))

Definition at line 671 of file xAODEventSelector.cxx.

{
  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;
}

last()

StatusCode Athena::xAODEventSelector::last ( Context & refContext ) const

overridevirtual

Definition at line 564 of file xAODEventSelector.cxx.

{
  ATH_MSG_ERROR ("............. Last Event Not Implemented .............");
  return StatusCode::FAILURE;
}

loadAddresses()

StatusCode Athena::xAODEventSelector::loadAddresses ( StoreID::type storeID, tadList & list )

overridevirtual

get all new addresses from Provider for this Event.

Definition at line 742 of file xAODEventSelector.cxx.

{
  if (m_needReload || m_rootAddresses.empty()) {
    //CHECK(createMetaDataRootBranchAddresses());
    return createRootBranchAddresses(storeID, tads);
  }
 
  return StatusCode::SUCCESS;
}

next() [1/2]

virtual StatusCode Athena::xAODEventSelector::next ( Context & refCtxt ) const

overridevirtual

next() [2/2]

StatusCode Athena::xAODEventSelector::next ( Context & refCtxt, int jump ) const

overridevirtual

Definition at line 541 of file xAODEventSelector.cxx.

{
  ATH_MSG_DEBUG ("next(" << jump << ") : iEvt " << m_curEvt);
 
  if (self()->seek(ctx, m_curEvt + jump).isSuccess()) {
    return StatusCode::FAILURE;
  }
  return next(ctx);
}

preLoadAddresses()

StatusCode Athena::xAODEventSelector::preLoadAddresses ( StoreID::type storeID, tadList & list )

overridevirtual

IAddressProvider interface get all addresses from Provider : Called before Begin Event

Definition at line 731 of file xAODEventSelector.cxx.

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

previous() [1/2]

virtual StatusCode Athena::xAODEventSelector::previous ( Context & refCtxt ) const

overridevirtual

previous() [2/2]

StatusCode Athena::xAODEventSelector::previous ( Context & refCtxt, int jump ) const

overridevirtual

Definition at line 558 of file xAODEventSelector.cxx.

{
  return next( ctx, -jump );
}

releaseContext()

StatusCode Athena::xAODEventSelector::releaseContext ( Context *& refCtxt ) const

overridevirtual

Definition at line 594 of file xAODEventSelector.cxx.

{
  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;
}

resetCriteria()

StatusCode Athena::xAODEventSelector::resetCriteria ( const std::string & cr, Context & ctx ) const

overridevirtual

Definition at line 607 of file xAODEventSelector.cxx.

{
  ATH_MSG_ERROR ("............. resetCriteria Not Implemented .............");
  return StatusCode::FAILURE;
}

rewind()

StatusCode Athena::xAODEventSelector::rewind ( Context & refCtxt ) const

overridevirtual

Definition at line 572 of file xAODEventSelector.cxx.

{
  return self()->seek(ctxt, 0);
}

seek()

StatusCode Athena::xAODEventSelector::seek ( Context & refCtxt, int evtnum ) const

overridevirtual

Seek to a given event number.

IEventSeek interface

Parameters

evtnum	The event number to which to seek.
evtnum	The event number to which to seek.

Definition at line 622 of file xAODEventSelector.cxx.

{
  // 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;
}

self()

xAODEventSelector * Athena::xAODEventSelector::self ( ) const

inlineprivate

non-const access to self (b/c ::next() is const)

Definition at line 162 of file xAODEventSelector.h.

  { return const_cast<xAODEventSelector*>(this); }

setFile()

StatusCode Athena::xAODEventSelector::setFile ( const std::string & fname )

private

switch to given file, loading metadata and triggering a beginInputFile incident

Definition at line 1054 of file xAODEventSelector.cxx.

                                                            {
 
  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;
 
}

size()

int Athena::xAODEventSelector::size ( Context & refCtxt ) const

overridevirtual

ICollectionSize interface

Definition at line 1185 of file xAODEventSelector.cxx.

                                             {
   //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;
}

stop()

StatusCode Athena::xAODEventSelector::stop ( )

overridevirtual

Definition at line 364 of file xAODEventSelector.cxx.

{
  // Fire EndInputFile for any file still open (the event loop may end
  // before the file is fully read).
  m_inputFileGuard.reset();
  return StatusCode::SUCCESS;
}

updateAddress()

StatusCode Athena::xAODEventSelector::updateAddress ( StoreID::type storeID, SG::TransientAddress * tad, const EventContext & ctx )

overridevirtual

update a transient Address

Definition at line 754 of file xAODEventSelector.cxx.

{
  // 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;
}

Friends And Related Symbol Documentation

Athena::xAODEventContext

friend class Athena::xAODEventContext

friend

Definition at line 58 of file xAODEventSelector.h.

Member Data Documentation

m_accessMode

int Athena::xAODEventSelector::m_accessMode

private

Definition at line 229 of file xAODEventSelector.h.

m_clidsvc

ServiceHandle<IClassIDSvc> Athena::xAODEventSelector::m_clidsvc

private

Pointer to the IClassIDSvc.

Definition at line 177 of file xAODEventSelector.h.

m_collEvts

std::vector<CollMetaData> Athena::xAODEventSelector::m_collEvts

mutableprivate

cache of the number of entries for each collection

Definition at line 209 of file xAODEventSelector.h.

m_collIdx

long Athena::xAODEventSelector::m_collIdx

mutableprivate

current collection index (into m_inputCollectionsName)

Definition at line 200 of file xAODEventSelector.h.

m_curEvt

long Athena::xAODEventSelector::m_curEvt

mutableprivate

current event index

Definition at line 197 of file xAODEventSelector.h.

m_dataStore

ServiceHandle<StoreGateSvc> Athena::xAODEventSelector::m_dataStore

private

Pointer to the StoreGateSvc event store.

Definition at line 171 of file xAODEventSelector.h.

m_dictsvc

ServiceHandle<IDictLoaderSvc> Athena::xAODEventSelector::m_dictsvc

private

Pointer to the IDictLoaderSvc.

Definition at line 179 of file xAODEventSelector.h.

m_event

std::unique_ptr<xAOD::Event> Athena::xAODEventSelector::m_event

mutableprivate

current Event being read (xAODTEvent for TTree or xAODREvent for RNTuple)

Definition at line 222 of file xAODEventSelector.h.

m_event_entries

long Athena::xAODEventSelector::m_event_entries

mutableprivate

Definition at line 227 of file xAODEventSelector.h.

m_fillEventInfo

bool Athena::xAODEventSelector::m_fillEventInfo = false

private

Definition at line 233 of file xAODEventSelector.h.

m_imetaStore

ServiceHandle<StoreGateSvc> Athena::xAODEventSelector::m_imetaStore

private

Pointer to the StoreGateSvc input metadata store.

Definition at line 173 of file xAODEventSelector.h.

m_incsvc

ServiceHandle<IIncidentSvc> Athena::xAODEventSelector::m_incsvc

private

Handle to the incident service.

Definition at line 181 of file xAODEventSelector.h.

m_inputCollectionsName

StringArrayProperty Athena::xAODEventSelector::m_inputCollectionsName

private

List of input files containing TTree or RNTuple.

Definition at line 188 of file xAODEventSelector.h.

m_inputFileGuard

std::optional<InputFileIncidentGuard> Athena::xAODEventSelector::m_inputFileGuard

mutableprivate

RAII guard: guarantees a matching EndInputFile for every BeginInputFile.

Definition at line 242 of file xAODEventSelector.h.

m_isRNTuple

bool Athena::xAODEventSelector::m_isRNTuple = false

private

Definition at line 231 of file xAODEventSelector.h.

m_nbrEvts

long Athena::xAODEventSelector::m_nbrEvts

mutableprivate

Number of Events read so far.

Definition at line 194 of file xAODEventSelector.h.

m_needReload

bool Athena::xAODEventSelector::m_needReload

mutableprivate

Definition at line 213 of file xAODEventSelector.h.

m_ometaStore

ServiceHandle<StoreGateSvc> Athena::xAODEventSelector::m_ometaStore

private

Pointer to the StoreGateSvc output metadata store.

Definition at line 175 of file xAODEventSelector.h.

m_poolSvc

ServiceHandle<IPoolSvc> Athena::xAODEventSelector::m_poolSvc

private

Handle to the PoolSvc (used in Hybrid mode when user is reading metadata with pool).

Definition at line 183 of file xAODEventSelector.h.

m_ppSvc

ServiceHandle<IProxyProviderSvc> Athena::xAODEventSelector::m_ppSvc

private

Handle to the proxy provider svc.

Definition at line 185 of file xAODEventSelector.h.

m_printEventProxyWarnings

bool Athena::xAODEventSelector::m_printEventProxyWarnings = true

private

Definition at line 239 of file xAODEventSelector.h.

m_printPerfStats

bool Athena::xAODEventSelector::m_printPerfStats = false

private

Definition at line 237 of file xAODEventSelector.h.

m_readMetadataWithPool

bool Athena::xAODEventSelector::m_readMetadataWithPool = false

private

Definition at line 235 of file xAODEventSelector.h.

m_rootAddresses

std::unordered_map<SG::TransientAddress*, bool> Athena::xAODEventSelector::m_rootAddresses

private

Definition at line 218 of file xAODEventSelector.h.

m_skipEvts

long Athena::xAODEventSelector::m_skipEvts

private

Number of events to skip at the beginning.

Definition at line 191 of file xAODEventSelector.h.

m_tfile

TFile* Athena::xAODEventSelector::m_tfile

mutableprivate

current TFile being read

Definition at line 225 of file xAODEventSelector.h.

---

The documentation for this class was generated from the following files:

• xAODEventSelector.h
• xAODEventSelector.cxx