Control/xAODRootAccess/xAODRootAccess/TEvent.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
//
#ifndef XAODROOTACCESS_TEVENT_H
#define XAODROOTACCESS_TEVENT_H
 
// STL include(s):
#include <unordered_map>
#include <set>
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
 
// ROOT include(s):
#include <Rtypes.h>
 
// EDM include(s):
#include "xAODEventFormat/EventFormat.h"
#include "AthContainersInterfaces/IAuxStoreHolder.h"
#include "CxxUtils/checker_macros.h"
#include "AthContainers/tools/threading.h"
#include "CxxUtils/sgkey_t.h"
 
// Interface include(s):
#include "xAODRootAccessInterfaces/TVirtualEvent.h"
 
// Local include(s):
#include "AsgMessaging/StatusCode.h"
#include "CxxUtils/checker_macros.h"
#include "xAODRootAccess/tools/IProxyDict.h"
 
// Forward declaration(s):
class TFile;
class TChain;
class TTree;
namespace std {
   class type_info;
}
namespace SG {
   class IAuxStore;
}
namespace xAODPrivate {
   class THolderBucket;
   class TLoader;
}
namespace CP {
   class xAODWriterAlg;
}
class xAODTEventBranch;
class xAODTMetaBranch;
 
namespace xAOD {
 
   // Forward declaration(s):
   class TVirtualManager;
   class TVirtualIncidentListener;
   class TObjectManager;
   class TAuxStore;
   class TChainStateTracker;
   class TFileMerger;
   class TEvent;
   class TTreeMgr;
   class THolder;
   ::TTree* MakeTransientTree ATLAS_NOT_THREAD_SAFE ( TEvent&, const char* );
 
 
#ifdef XAOD_STANDALONE
   class TEvent : public TVirtualEvent, IProxyDict {
#else
   class TEvent : public TVirtualEvent, public implements<IProxyDict> {
#endif
      // Declare the friend functions/classes:
      friend ::TTree* MakeTransientTree( TEvent&, const char* );
      friend class ::xAODTEventBranch;
      friend class ::xAODTMetaBranch;
      friend class xAOD::TFileMerger;
      friend class xAOD::TTreeMgr;
      friend class xAODPrivate::THolderBucket;
      friend class xAODPrivate::TLoader;
      friend class CP::xAODWriterAlg;
 
   public:
      enum EAuxMode {
         kBranchAccess = 0, 
         kClassAccess  = 1, 
         kAthenaAccess = 2, 
         kUndefinedAccess = 3 
      };
 
      TEvent( EAuxMode mode = kUndefinedAccess );
      TEvent( ::TFile* file, EAuxMode mode = kUndefinedAccess);
      TEvent( ::TTree* tree, EAuxMode mode = kUndefinedAccess);
      virtual ~TEvent();
 
      TEvent( const TEvent& parent ) = delete;
      TEvent& operator=( const TEvent& rhs ) = delete;
 
      EAuxMode auxMode() const;
 
      std::string dump();
 
      void printIOStats() const;
 
      void setPrintEventProxyWarnings(bool);
 
 
      StatusCode readFrom( ::TFile* file, Bool_t useTreeCache = kTRUE,
                            const char* treeName = EVENT_TREE_NAME );
      StatusCode readFrom( ::TTree* tree, Bool_t useTreeCache = kTRUE );
      StatusCode writeTo( ::TFile* file, Int_t autoFlush = 200,
                           const char* treeName = EVENT_TREE_NAME );
      StatusCode finishWritingTo( ::TFile* file );
 
      void setActive() const;
 
      void setAuxItemList( const std::string& containerKey,
                           const std::string& itemList );
 
      StatusCode addListener( TVirtualIncidentListener* listener );
      StatusCode removeListener( TVirtualIncidentListener* listener );
      void clearListeners();
 
      StatusCode addNameRemap( const std::string& onfile,
                                const std::string& newName );
      void clearNameRemap();
      void printNameRemap() const;
 
 
 
      template< typename T >
      ::Bool_t contains( const std::string& key );
      template< typename T >
      ::Bool_t transientContains( const std::string& key ) const;
 
      template< typename T >
      StatusCode retrieve( const T*& obj, const std::string& key );
      template< typename T >
      StatusCode retrieve( T*& obj, const std::string& key );
 
      template< typename T >
      StatusCode record( T* obj, const std::string& key,
                          ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
      template< typename T >
      StatusCode record( std::unique_ptr< T > obj, const std::string& key,
                          ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
 
      SG::IAuxStore* recordAux( const std::string& key,
                                SG::IAuxStoreHolder::AuxStoreType type =
                                SG::IAuxStoreHolder::AST_ContainerStore,
                                Int_t basketSize = 32000,
                                Int_t splitLevel = 0 );
 
      StatusCode copy( const std::string& key,
                        ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
      StatusCode copy( ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
 
 
 
      template< typename T >
      ::Bool_t containsMeta( const std::string& key );
      template< typename T >
      ::Bool_t transientContainsMeta( const std::string& key ) const;
 
      template< typename T >
      StatusCode retrieveMetaInput( const T*& obj, const std::string& key );
 
      template< typename T >
      StatusCode retrieveMetaOutput( const T*& obj, const std::string& key );
      template< typename T >
      StatusCode retrieveMetaOutput( T*& obj, const std::string& key );
 
      template< typename T >
      StatusCode recordMeta( T* obj, const std::string& key,
                              ::Int_t basketSize = 32000,
                              ::Int_t splitLevel = 1 );
      template< typename T >
      StatusCode recordMeta( std::unique_ptr< T > obj, const std::string& key,
                              ::Int_t basketSize = 32000,
                              ::Int_t splitLevel = 1 );
 
 
 
      ::Long64_t getEntries() const;
      ::Int_t getEntry( ::Long64_t entry, ::Int_t getall = 0 );
 
      ::Long64_t getFiles() const;
      ::Int_t getFile( ::Long64_t file, ::Int_t getall = 0 );
 
      ::Int_t fill();
 
      const EventFormat* inputEventFormat() const;
      const EventFormat* outputEventFormat() const;
 
 
 
      SG::sgkey_t getHash( const std::string& key ) const override;
      SG::sgkey_t getKey( const void* obj ) const override;
      const std::string& getName( const void* obj ) const override;
      const std::string& getName( SG::sgkey_t hash ) const override;
 
      // Declared public so we can call it from python.
      StatusCode record( void* obj, const std::string& typeName,
                          const std::string& key,
                          ::Int_t basketSize, ::Int_t splitLevel,
                          ::Bool_t overwrite = kFALSE,
                          ::Bool_t metadata = kFALSE,
                          ::Bool_t isOwner = kTRUE );
 
   protected:
      void* getOutputObject( SG::sgkey_t key,
                             const std::type_info& ti ) override;
      const void* getInputObject( SG::sgkey_t key,
                                  const std::type_info& ti,
                                  bool silent = false ) override;
 
      void getNames(const std::string& targetClassName,
                    std::vector<std::string>& vkeys,
                    bool metadata = false) const override;
 
 
 
      SG::DataProxy* proxy( const void* const pTransient ) const override;
 
      SG::DataProxy* proxy( const CLID& id,
                            const std::string& key ) const override;
 
      SG::DataProxy* proxy_exact( SG::sgkey_t sgkey ) const override;
 
      StatusCode addToStore( CLID id, SG::DataProxy* proxy ) override;
 
      std::vector< const SG::DataProxy* > proxies() const override;
 
      SG::sgkey_t stringToKey( const std::string& str, CLID clid ) override;
 
      const std::string* keyToString( SG::sgkey_t key ) const override;
 
      const std::string* keyToString( SG::sgkey_t key,
                                      CLID& clid ) const override;
 
      void registerKey( SG::sgkey_t key, const std::string& str,
                        CLID clid ) override;
 
      SG::DataProxy*
      recordObject( SG::DataObjectSharedPtr< DataObject > obj,
                    const std::string& key,
                    bool allowMods,
                    bool returnExisting ) override;
 
      const std::string& name() const override;
 
 
      StatusCode initStats();
      void* getOutputObject( const std::string& key,
                             const std::type_info& ti,
                             ::Bool_t metadata = kFALSE ) const;
      const void* getInputObject( const std::string& key,
                                  const std::type_info& ti,
                                  ::Bool_t silent = kFALSE,
                                  ::Bool_t metadata = kFALSE );
      StatusCode record( TAuxStore* store, const std::string& key,
                          ::Int_t basketSize, ::Int_t splitLevel,
                          ::Bool_t ownsStore = kFALSE );
      StatusCode connectBranch( const std::string& key,
                                 ::Bool_t silent = kFALSE );
      StatusCode connectMetaBranch( const std::string& key,
                                     ::Bool_t silent = kFALSE );
      StatusCode connectAux( const std::string& prefix, ::Bool_t standalone );
      StatusCode connectMetaAux( const std::string& prefix,
                                  ::Bool_t standalone );
      StatusCode setUpDynamicStore( TObjectManager& mgr, ::TTree* tree );
      StatusCode setAuxStore( TObjectManager& mgr,
                               ::Bool_t metadata = kFALSE );
      StatusCode putAux( ::TTree& outTree, TVirtualManager& mgr,
                          ::Int_t basketSize = 32000, ::Int_t splitLevel = 0,
                          ::Bool_t metadata = kFALSE );
      static ::Bool_t hasAuxStore( const TObjectManager& mgr );
      static ::Bool_t isAuxStore( const TObjectManager& mgr );
      static ::Bool_t isStandalone( const TObjectManager& mgr );
      ::Bool_t contains( const std::string& key,
                         const std::type_info& ti,
                         ::Bool_t metadata = kFALSE );
      ::Bool_t transientContains( const std::string& key,
                                  const std::type_info& ti,
                                  ::Bool_t metadata = kFALSE ) const;
 
      typedef std::unordered_map< std::string,
                                  TVirtualManager* > Object_t;
      typedef std::vector< TVirtualIncidentListener* > Listener_t;
 
      static const ::Int_t CACHE_SIZE;
      static const char* const EVENT_TREE_NAME;
      static const char* const METADATA_TREE_NAME;
 
      EAuxMode m_auxMode;
 
      ::TTree* m_inTree;
      ::Bool_t m_inTreeMissing;
      ::TChain* m_inChain;
      TChainStateTracker* m_inChainTracker;
      ::Int_t m_inTreeNumber;
      ::TTree* m_inMetaTree;
      ::Long64_t m_entry;
 
      ::TTree* m_outTree;
 
      Object_t m_inputObjects;
      std::set< std::string > m_inputMissingObjects;
      Object_t m_outputObjects;
 
      Object_t m_inputMetaObjects;
      Object_t m_outputMetaObjects;
 
      EventFormat m_inputEventFormat;
      EventFormat* m_outputEventFormat;
 
      std::unordered_map< std::string, std::set< std::string > > m_auxItemList;
 
      Listener_t m_listeners;
 
      std::unordered_map< std::string, std::string > m_nameRemapping;
 
      Bool_t m_printEventProxyWarnings = true;
 
 
      struct BranchInfo {
         std::unique_ptr< SG::DataProxy > m_proxy;
         const ::TClass* m_class = 0;
      }; // struct BranchInfo
 
      typedef AthContainers_detail::upgrade_mutex upgrade_mutex_t;
      typedef AthContainers_detail::upgrading_lock< upgrade_mutex_t > upgrading_lock_t;
      mutable upgrade_mutex_t m_branchesMutex;
 
      mutable SG::SGKeyMap< BranchInfo > m_branches ATLAS_THREAD_SAFE; // protected by mutex
 
 
 
      const xAOD::EventFormatElement*
      getEventFormatElement( SG::sgkey_t sgkey ) const;
 
      const BranchInfo* getBranchInfo( SG::sgkey_t sgkey ) const;
 
 
   }; // class TEvent
 
} // namespace xAOD
 
// Include the template implementation(s).
#include "TEvent.icc"
 
#endif // XAODROOTACCESS_TEVENT_H