RootNtupleEventSelector.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// RootNtupleEventSelector.h 
// Header file for class RootNtupleEventSelector
// Author: S.Binet<binet@cern.ch>
#ifndef ATHENAROOTCOMPS_ATHENA_ROOTNTUPLEEVENTSELECTOR_H 
#define ATHENAROOTCOMPS_ATHENA_ROOTNTUPLEEVENTSELECTOR_H 1
 
// STL includes
#include <unordered_map>
 
// framework includes
#include "AthenaBaseComps/AthService.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 "CxxUtils/checker_macros.h"
 
#include "TFile.h"
#include "TObjString.h"
 
#include <optional>
 
// Forward declaration
class ISvcLocator;
class StoreGateSvc;
class TTree;
class IClassIDSvc;
class IDictLoaderSvc;
namespace Athena { class RootNtupleEventContext; }
 
namespace Athena {

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

  // Public methods: 
 public: 

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

  virtual ~RootNtupleEventSelector(); 
 
  // 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;

  // Const methods: 

  // Non-const methods: 

  // Private methods: 
 private:
 
  StatusCode endInputFile (RootNtupleEventContext* rctx) const;

  void setupInputCollection( Gaudi::Details::PropertyBase& inputCollectionsName );

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

  TTree* fetchNtuple(const std::string& fname,
                     const std::string& tupleName) const;
 
  void addMetadataFromDirectoryName(const std::string &metadirname, 
                                    TFile *fileObj, 
                                    const std::string &prefix = "") const;
  void addMetadataFromDirectory(TDirectoryFile *metadir, 
                                const std::string &prefix = "") const;
  void addMetadata(TTree *metatree, const std::string &path = "") const;
  void addMetadata(TObjString *metastring, const std::string &path = "") const;
  
  StatusCode createMetaDataRootBranchAddresses(StoreGateSvc *store,
                           TTree *tree,
                           const std::string& prefix) const;

  StatusCode do_init_io();

  void find_coll_idx(int evtidx, long& coll_idx, long& tuple_idx) const;

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

  // Private data: 
 private: 
 
  typedef ServiceHandle<StoreGateSvc> StoreGateSvc_t;
  StoreGateSvc_t m_dataStore;

  StoreGateSvc_t m_imetaStore;

  StoreGateSvc_t m_ometaStore;
 
  typedef ServiceHandle<IClassIDSvc> ICLIDSvc_t;
  ICLIDSvc_t m_clidsvc;
 
  typedef ServiceHandle<IDictLoaderSvc> IDictSvc_t;
  IDictSvc_t m_dictsvc;
 
  typedef ServiceHandle<IIncidentSvc> IIncSvc_t;
  IIncSvc_t m_incsvc;

  StringArrayProperty m_inputCollectionsName;

  StringProperty m_tupleName;

  StringArrayProperty m_activeBranchNames;

  StringProperty m_eventNumberVar
    { this, "EventNumberVar", "", "Optional event number variable to propagate to EventInfo" };
  StringProperty m_runNumberVar
    { this, "RunNumberVar", "", "Optional run number variable to propagate to EventInfo" };
  StringProperty m_lbnVar
    { this, "LBNVar", "", "Optional LBN variable to propagate to EventInfo" };

  long m_skipEvts;

  std::vector<std::string> m_tupleNames;

  mutable long m_nbrEvts;
  
  mutable long m_curEvt;
 
  struct CollMetaData {
    long min_entries;
    long max_entries;
    long entries;
  };
  mutable std::vector<std::vector<CollMetaData> > m_collEvts;

  mutable TTree *m_tuple;

  //PyObject* m_pySelectionFct;
 
  // flag to trigger reloading of root branch addresses
  mutable bool m_needReload;

  mutable std::optional<InputFileIncidentGuard> m_inputFileGuard;
  mutable bool m_fireBIF{true};
 
  // the list of transient addresses we "manage" or know about
  // these addresses are the actual TTree's branch names
  // for the metadata tree(s)
  //Addrs_t m_rootAddressesMetaData;
 
  // List of files that we've created, so that we can delete them
  // during finalize.  FIXME: get rid of the mutable.
  mutable std::vector<TFile*> m_files;
}; 

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