xAODEventSelector.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// xAODEventSelector.h 
// Header file for class xAODEventSelector
// Author: Johannes Elmsheuser, Will Buttinger
#ifndef ATHENAROOTCOMPS_ATHENA_XAODEVENTSELECTOR_H 
#define ATHENAROOTCOMPS_ATHENA_XAODEVENTSELECTOR_H 1
 
// framework includes
#include "AthenaBaseComps/AthService.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/IEvtSelector.h"
#include "GaudiKernel/IIoComponent.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
#include "AthenaKernel/IEvtSelectorSeek.h"
#include "AthenaKernel/IAddressProvider.h"
#include "AthenaKernel/InputFileIncidentGuard.h"
 
#include "PoolSvc/IPoolSvc.h"
 
#include "TFile.h"
 
#include "xAODRootAccess/Event.h"
 
#include <memory>
#include <optional>
#include <unordered_map>
 
// Forward declaration
class ISvcLocator;
class StoreGateSvc;
class TTree;
class IClassIDSvc;
class IDictLoaderSvc;
namespace Athena { class xAODEventContext; }
 
namespace Athena {

class ATLAS_NOT_THREAD_SAFE xAODEventSelector :
    public extends<::AthService,
                    IEvtSelector,
                    IEvtSelectorSeek,
                    IAddressProvider,
                    IIoComponent,
                    IIncidentListener>
{
  friend class Athena::xAODEventContext;
 
 

  // Public methods: 
 public: 

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

  virtual ~xAODEventSelector(); 
 
  // Athena hooks
  virtual StatusCode initialize() override;
  virtual StatusCode stop() override;
  virtual StatusCode finalize() override;
 
  virtual void handle(const Incident& incident) override;

  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;

  virtual int curEvent (const Context& refCtxt) const override;
  
  virtual StatusCode io_reinit() override;

  virtual 
  StatusCode preLoadAddresses(StoreID::type storeID, tadList& list) override;
 
  virtual 
  StatusCode loadAddresses(StoreID::type storeID, tadList& list) override;
 
  virtual 
  StatusCode updateAddress(StoreID::type storeID, SG::TransientAddress* tad,
                           const EventContext& ctx) override;

  virtual int size (Context& refCtxt) const override;
 
 
 private: 

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

  TFile* fetchNtupleFile(const std::string& fname) const;

  StatusCode createMetaDataRootBranchAddresses() const;

  StatusCode do_init_io();

  StatusCode setFile(const std::string& fname);

  int find_coll_idx(int evtidx) const;

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

  // Private data: 
 private: 

  ServiceHandle<StoreGateSvc> m_dataStore;
  ServiceHandle<StoreGateSvc> m_imetaStore;
  ServiceHandle<StoreGateSvc> m_ometaStore;
  ServiceHandle<IClassIDSvc> m_clidsvc;
  ServiceHandle<IDictLoaderSvc> m_dictsvc;
  ServiceHandle<IIncidentSvc> m_incsvc;
  ServiceHandle<IPoolSvc> m_poolSvc;
  ServiceHandle<IProxyProviderSvc> m_ppSvc;

  StringArrayProperty m_inputCollectionsName;

  long m_skipEvts;

  mutable long m_nbrEvts;
  
  mutable long m_curEvt;

  mutable long m_collIdx;
 
  struct CollMetaData {
    long min_entries;
    long max_entries;
  };

  mutable std::vector<CollMetaData> m_collEvts;
 
 
  // flag to trigger reloading of root branch addresses
  mutable bool m_needReload;
 
  // the list of transient addresses we "manage" or know about
  // these addresses are the things we can retrieve from the TEvent
  // for the event data
  std::unordered_map<SG::TransientAddress*, bool> m_rootAddresses;
 

  mutable std::unique_ptr<xAOD::Event> m_event;

  mutable TFile* m_tfile;
 
  mutable long m_event_entries; //used to cache getEntries result of event
 
  int m_accessMode; //tevent access mode
 
  bool m_isRNTuple = false; //input files store event data in RNTuple, decided from the first file
 
  bool m_fillEventInfo = false; //if true, will fill EventInfo from xAOD::EventInfo
 
  bool m_readMetadataWithPool = false; //metadata read by MetaDataSvc via AthenaPoolCnvSvc instead of TEvent
 
  bool m_printPerfStats = false; //should we monitor the touched input branches?
 
  bool m_printEventProxyWarnings = true;

  mutable std::optional<InputFileIncidentGuard> m_inputFileGuard;
}; 

// Inline methods: 
 
} //> namespace Athena
 
#endif //> ATHENAROOTCOMPS_ATHENA_XAODEVENTSELECTOR_H