Control/xAODRootAccess/Root/TEvent.cxx

Go to the documentation of this file.

// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 
// System include(s):
#include <cassert>
#include <sstream>
#include <iomanip>
#include <cstring>
 
// ROOT include(s):
#include <TFile.h>
#include <TTree.h>
#include <TKey.h>
#include <TChain.h>
#include <TFriendElement.h>
#include <TChainElement.h>
#include <TBranch.h>
#include <TError.h>
#include <TMethodCall.h>
#include <TSystem.h>
 
// Gaudi/Athena include(s):
#include "AthContainersInterfaces/IAuxStoreIO.h"
#include "AthContainersInterfaces/IAuxStoreHolder.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/AuxVectorBase.h"
#include "AthContainers/AuxElement.h"
#include "AthContainers/normalizedTypeinfoName.h"
#ifndef XAOD_STANDALONE
#   include "SGTools/CurrentEventStore.h"
#   include "SGTools/DataProxy.h"
#endif // not XAOD_STANDALONE
#include "CxxUtils/ClassName.h"
#include "CxxUtils/no_sanitize_undefined.h"
 
// Interface include(s):
#include "xAODRootAccessInterfaces/TActiveEvent.h"
 
// xAOD include(s):
#include "xAODCore/tools/IOStats.h"
#include "xAODCore/tools/ReadStats.h"
#include "xAODCore/tools/PerfStats.h"
#include "xAODCore/AuxSelection.h"
 
// Local include(s):
#include "xAODRootAccess/TEvent.h"
#include "xAODRootAccess/TAuxStore.h"
#include "xAODRootAccess/TVirtualIncidentListener.h"
#include "xAODRootAccess/TStore.h"
#include "xAODRootAccess/TActiveStore.h"
#include "xAODRootAccess/tools/TAuxManager.h"
#include "xAODRootAccess/tools/TObjectManager.h"
#include "xAODRootAccess/tools/TAuxBranchManager.h"
#include "xAODRootAccess/tools/TPrimitiveAuxBranchManager.h"
#include "xAODRootAccess/tools/THolder.h"
#include "xAODRootAccess/tools/Utils.h"
#include "xAODRootAccess/tools/Message.h"
#include "xAODRootAccess/tools/TEventFormatRegistry.h"
#include "xAODRootAccess/tools/TDirectoryReset.h"
#include "xAODRootAccess/tools/TIncident.h"
#include "xAODRootAccess/tools/ReturnCheck.h"
#include "xAODRootAccess/tools/TChainStateTracker.h"
#include "xAODRootAccess/tools/TFileAccessTracer.h"
 
namespace {
 
   void removeVersionNames( std::string& name ) {
 
      size_t pos = 0;
      while( ( pos = name.find( "_v1" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
      while( ( pos = name.find( "_v2" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
      while( ( pos = name.find( "_v3" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
      while( ( pos = name.find( "_v4" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
      while( ( pos = name.find( "_v5" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
      while( ( pos = name.find( "_v6" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
      while( ( pos = name.find( "_v7" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
      while( ( pos = name.find( "_v8" ) ) != name.npos ) {
         name.erase( pos, 3 );
      }
 
      return;
   }
 
   class ForceTrackIndices : public SG::AuxVectorBase {
   public:
      using SG::AuxVectorBase::initAuxVectorBase;
   }; // class ForceTrackIndices
 
   void forceTrackIndices NO_SANITIZE_UNDEFINED ( SG::AuxVectorBase& vec ) {
      // Treat the received object like it would be of type @c ForceTrackIndices
      ForceTrackIndices& xvec = static_cast< ForceTrackIndices& >( vec );
      xvec.initAuxVectorBase< DataVector< SG::IAuxElement > >( SG::OWN_ELEMENTS,
                                                               SG::ALWAYS_TRACK_INDICES );
      return;
   }
 
} // private namespace
 
namespace xAOD {
 
   //
   // Initialise the static data:
   //
   const ::Int_t TEvent::CACHE_SIZE = -1;
   const char* const TEvent::EVENT_TREE_NAME    = "CollectionTree";
   const char* const TEvent::METADATA_TREE_NAME = "MetaData";
 
   static const TEvent::EAuxMode DEFAULT_ACCESS_MODE = TEvent::kClassAccess;
   static const TEvent::EAuxMode UNIT_TEST_ACCESS_MODE = TEvent::kAthenaAccess;
 
   TEvent::TEvent( EAuxMode mode )
      : m_auxMode( mode ),
        m_inTree( nullptr ), m_inTreeMissing( kFALSE ),
        m_inChain( nullptr ), m_inChainTracker( nullptr ),
        m_inTreeNumber( -1 ), m_inMetaTree( nullptr ),
        m_entry( -1 ), m_outTree( nullptr ),
        m_inputObjects(), m_inputMissingObjects(), m_outputObjects(),
        m_inputMetaObjects(), m_outputMetaObjects(),
        m_inputEventFormat(), m_outputEventFormat( nullptr ),
        m_auxItemList(), m_listeners(), m_nameRemapping() {
 
      // Make sure that the I/O monitoring is active:
      PerfStats::instance();
 
      // Make this the active event:
      setActive();
 
      // If the user didn't ask for one particular access type, chose one
      // based on the running environment:
      if( m_auxMode == kUndefinedAccess ) {
         if( gSystem->Getenv( "ROOTCORE_AUTO_UT" ) ||
             gSystem->Getenv( "ROOTCORE_FAST_UT" ) ||
             gSystem->Getenv( "ROOTCORE_SLOW_UT" ) ) {
            ::Info( "xAOD::TEvent::TEvent",
                    "Using access mode \"%i\" for the unit test",
                    static_cast< int >( UNIT_TEST_ACCESS_MODE ) );
            m_auxMode = UNIT_TEST_ACCESS_MODE;
         } else {
            m_auxMode = DEFAULT_ACCESS_MODE;
         }
      }
   }
 
   TEvent::TEvent( ::TFile* file, EAuxMode mode )
      : m_auxMode( mode ),
        m_inTree( nullptr ), m_inTreeMissing( kFALSE ),
        m_inChain( nullptr ), m_inChainTracker( nullptr ),
        m_inTreeNumber( -1 ), m_inMetaTree( nullptr ),
        m_entry( -1 ), m_outTree( nullptr ),
        m_inputObjects(), m_inputMissingObjects(), m_outputObjects(),
        m_inputMetaObjects(), m_outputMetaObjects(),
        m_inputEventFormat(), m_outputEventFormat( nullptr ),
        m_auxItemList(), m_listeners(), m_nameRemapping() {
 
      // Make sure that the I/O monitoring is active:
      PerfStats::instance();
 
      // Make this the active event:
      setActive();
 
      // If the user didn't ask for one particular access type, chose one
      // based on the running environment:
      if( m_auxMode == kUndefinedAccess ) {
         if( gSystem->Getenv( "ROOTCORE_AUTO_UT" ) ||
             gSystem->Getenv( "ROOTCORE_FAST_UT" ) ||
             gSystem->Getenv( "ROOTCORE_SLOW_UT" ) ) {
            ::Info( "xAOD::TEvent::TEvent",
                    "Using access mode \"%i\" for the unit test",
                    static_cast< int >( UNIT_TEST_ACCESS_MODE ) );
            m_auxMode = UNIT_TEST_ACCESS_MODE;
         } else {
            m_auxMode = DEFAULT_ACCESS_MODE;
         }
      }
 
      // Let the initialisation function deal with setting up the object:
      readFrom( file ).ignore();
   }
 
   TEvent::TEvent( ::TTree* tree, EAuxMode mode )
      : m_auxMode( mode ),
        m_inTree( nullptr ), m_inTreeMissing( kFALSE ),
        m_inChain( nullptr ), m_inChainTracker( nullptr ),
        m_inTreeNumber( -1 ), m_inMetaTree( nullptr ),
        m_entry( -1 ), m_outTree( nullptr ),
        m_inputObjects(), m_inputMissingObjects(), m_outputObjects(),
        m_inputMetaObjects(), m_outputMetaObjects(),
        m_inputEventFormat(), m_outputEventFormat( nullptr ),
        m_auxItemList(), m_listeners(), m_nameRemapping() {
 
      // Make sure that the I/O monitoring is active:
      PerfStats::instance();
 
      // Make this the active event:
      setActive();
 
      // If the user didn't ask for one particular access type, chose one
      // based on the running environment:
      if( m_auxMode == kUndefinedAccess ) {
         if( gSystem->Getenv( "ROOTCORE_AUTO_UT" ) ||
             gSystem->Getenv( "ROOTCORE_FAST_UT" ) ||
             gSystem->Getenv( "ROOTCORE_SLOW_UT" ) ) {
            ::Info( "xAOD::TEvent::TEvent",
                    "Using access mode \"%i\" for the unit test",
                    static_cast< int >( UNIT_TEST_ACCESS_MODE ) );
            m_auxMode = UNIT_TEST_ACCESS_MODE;
         } else {
            m_auxMode = DEFAULT_ACCESS_MODE;
         }
      }
 
      // Let the initialisation function deal with setting up the object:
      readFrom( tree ).ignore();
   }
 
   TEvent::~TEvent() {
 
      Object_t::iterator itr = m_inputObjects.begin();
      Object_t::iterator end = m_inputObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
      itr = m_outputObjects.begin();
      end = m_outputObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
      itr = m_inputMetaObjects.begin();
      end = m_inputMetaObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
      itr = m_outputMetaObjects.begin();
      end = m_outputMetaObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
 
      if( m_inChainTracker ) {
         delete m_inChainTracker;
      }
 
      // If this is set up as the active event at the moment, notify
      // the active event object that this object will no longer be
      // available.
      if( TActiveEvent::event() == this ) {
         TActiveEvent::setEvent( nullptr );
      }
#ifndef XAOD_STANDALONE
      if( SG::CurrentEventStore::store() == this ) {
         SG::CurrentEventStore::setStore( nullptr );
      }
#endif // not XAOD_STANDALONE
   }
 
   TEvent::EAuxMode TEvent::auxMode() const {
 
      return m_auxMode;
   }
 
   std::string TEvent::dump() {
 
      // The internal stream object:
      std::ostringstream ost;
      ost << "<<<<<<<<<<<<<<<<<<<< xAOD::TEvent Dump >>>>>>>>>>>>>>>>>>>>\n";
 
      // Loop over the EventFormat object:
      EventFormat::const_iterator ef_itr = m_inputEventFormat.begin();
      EventFormat::const_iterator ef_end = m_inputEventFormat.end();
      for( ; ef_itr != ef_end; ++ef_itr ) {
 
         // Construct the type name:
         std::string typeName = ef_itr->second.className();
         removeVersionNames( typeName );
 
         // Get the type:
         ::TClass* cl =
              ::TClass::GetClass( ef_itr->second.className().c_str() );
         const std::type_info* ti = ( cl ? cl->GetTypeInfo() : nullptr );
         if( ( ! cl ) || ( ! cl->IsLoaded() ) || ( ! ti ) ) {
            Warning( "xAOD::TEvent::dump",
                     "Unknown type (%s) found in the event format",
                     ef_itr->second.className().c_str() );
            continue;
         }
 
         // Skip containers that are not available anyway:
         if( ! contains( ef_itr->second.branchName(), *ti ) ) {
            continue;
         }
 
         // Do the printout:
         ost << " Hash: 0x" << std::setw( 8 ) << std::setfill( '0' )
             << std::hex << ef_itr->second.hash()
             << " Key: \"" << ef_itr->second.branchName() << "\"\n";
 
         ost << "   type: " << typeName << "\n";
         const bool isNonConst = transientContains( ef_itr->second.branchName(),
                                                    *ti );
         ost << "   isConst: " << ( isNonConst ? "No" : "Yes" ) << "\n";
         ost << "   Data: "
             << ( isNonConst ? getOutputObject( ef_itr->second.branchName(),
                                                *ti ) :
                  getInputObject( ef_itr->second.branchName(), *ti ) ) << "\n";
      }
 
      // Finish with the construction:
      ost << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
      return ost.str();
   }
 
   void TEvent::printIOStats() const {
 
      // Simply do this via the xAODCore code:
      IOStats::instance().stats().Print( "Summary" );
 
      return;
   }
 
   StatusCode TEvent::readFrom( ::TFile* file, Bool_t useTreeCache,
                                 const char* treeName ) {
 
      // If no file was specified, return gracefully:
      if( ! file ) return StatusCode::SUCCESS;
 
      // Clear the cached input objects:
      Object_t::iterator itr = m_inputObjects.begin();
      Object_t::iterator end = m_inputObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
      m_inputObjects.clear();
      m_inputMissingObjects.clear();
      {
        upgrading_lock_t lock(m_branchesMutex);
        lock.upgrade();
        m_branches.clear();
      }
 
      // Clear the cached input meta-objects:
      itr = m_inputMetaObjects.begin();
      end = m_inputMetaObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
      m_inputMetaObjects.clear();
 
      // Reset the internal flags:
      m_inTreeMissing = kFALSE;
      m_entry = -1;
 
      // Make sure we return to the current directory:
      TDirectoryReset dr;
 
      // Set up the file access tracer:
      static TFileAccessTracer tracer ATLAS_THREAD_SAFE;
      tracer.add( *file );
 
      // Look for the metadata tree:
      m_inMetaTree =
         dynamic_cast< ::TTree* >( file->Get( METADATA_TREE_NAME ) );
      if( ! m_inMetaTree ) {
         ::Error( "xAOD::TEvent::readFrom",
                  XAOD_MESSAGE( "Couldn't find metadata tree on input. Object "
                                "unusable!" ) );
         return StatusCode::FAILURE;
      }
 
      // Set metadata entry to be read
      // NB: no reading is done calling LoadTree
      if ( m_inMetaTree->LoadTree(0) < 0 ){
         ::Error( "xAOD::TEvent::readFrom",
                  XAOD_MESSAGE( "Failed to load entry for metadata tree=%s" ),
                  m_inMetaTree->GetName() );
         return StatusCode::FAILURE;
      }
 
      // A sanity check:
      if( m_inMetaTree->GetEntries() != 1 ) {
         ::Info( "xAOD::TEvent::readFrom",
                 "Was expecting a metadata tree with size 1, instead of %i.",
                 static_cast< int >( m_inMetaTree->GetEntries() ) );
         ::Info( "xAOD::TEvent::readFrom",
                 "File most probably produced by hadd..." );
      }
 
      // Make sure that the xAOD::EventFormat dictonary is loaded.
      // This may not be the case if streamer information reading is turned
      // off.
      static const std::string eventFormatTypeName =
         Utils::getTypeName( typeid( EventFormat ) );
      ::TClass* cl = ::TClass::GetClass( eventFormatTypeName.c_str() );
      if( ! cl ) {
         ::Warning( "xAOD::TEvent::readFrom",
                    "Couldn't load the EventFormat dictionary" );
      }
 
      // Check if the EventFormat branch is available:
      const std::string eventFormatBranchName =
         Utils::getFirstBranchMatch( m_inMetaTree, "EventFormat");
      if( ! m_inMetaTree->GetBranch( eventFormatBranchName.c_str() ) ) {
         // This can happen when the file was produced by an Athena job that
         // didn't have any input events itself. This means that the file
         // doesn't actually have any useful metadata.
         ::Info( "xAOD::TEvent::readFrom", "Input file provides no event or "
                 "metadata" );
         m_inTree = 0;
         m_inTreeMissing = kTRUE;
         return StatusCode::SUCCESS;
      }
 
      // Read in the event format object:
      EventFormat* format = 0; ::TBranch* br = 0;
      const Int_t status =
         m_inMetaTree->SetBranchAddress( eventFormatBranchName.c_str(),
                                         &format, &br );
      if( status < 0 ) {
         ::Error( "xAOD::TEvent::readFrom",
                  XAOD_MESSAGE( "Failed to connect to EventFormat object" ) );
         return StatusCode::FAILURE;
      }
 
      // Read in the object to our private member:
      br->GetEntry( 0 );
      m_inputEventFormat = *format;
 
      // This is a strange place. The object has to be deleted, as it is the
      // responsibility of the user code to do so. But if I also explicitly
      // tell the branch to forget about the address of the pointer, then
      // all hell breaks loose...
      delete format;
 
 
      // List all the other Metadata trees in the input file
      // Having several metatrees can happen for augmented files for instance
      // as one metadata tree per stream is produced
      std::set<std::string> lOtherMetaTreeNames = {};
      TList *lKeys = file->GetListOfKeys();
 
      if (lKeys){
         for (int iKey = 0; iKey < lKeys->GetEntries() ; iKey++){
            // iterate over keys and add
            std::string keyName = lKeys->At(iKey)->GetName();
            // Make sure the key corresponds to a metadata tree but
            // do not add the current metadata tree in the list of other trees
            // and do not add the metadata tree handlers to the list
            if (  (keyName != METADATA_TREE_NAME)
               && (keyName.find("MetaData") != std::string::npos)
               && !(keyName.find("MetaDataHdr") != std::string::npos)){
               // Make sure key corresponds to a tree
               const char *className = ((::TKey*)lKeys->At(iKey))->GetClassName();
               static constexpr Bool_t LOAD = kFALSE;
               static constexpr Bool_t SILENT = kTRUE;
               ::TClass* cl = ::TClass::GetClass(className, LOAD, SILENT);
               if ((cl != nullptr) && cl->InheritsFrom(::TTree::Class())){
                  // key is corresponding to a metadata tree
                  lOtherMetaTreeNames.insert(std::move(keyName));
               }
            }
         }
      }
 
      // Loop over the other metadata trees found (if any)
      for (const std::string & metaTreeName : lOtherMetaTreeNames){
         TTree *tmpMetaTree =  dynamic_cast< ::TTree* >( file->Get( metaTreeName.c_str() ) );
 
         if (!tmpMetaTree){
            // Skip tree if could not read it
            ::Warning( "xAOD::TEvent::readFrom", "Could not read metadata tree=%s",metaTreeName.c_str());
            continue;
         }
 
         // Set metadata entry to be read
         // NB: no reading is done calling LoadTree
         if ( tmpMetaTree->LoadTree(0) < 0 ){
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "Failed to load entry for metadata tree=%s" ),
                     tmpMetaTree->GetName() );
            return StatusCode::FAILURE;
         }
 
         // Check if the EventFormat branch is available:
         const std::string tmpEventFormatBranchName =
            Utils::getFirstBranchMatch( tmpMetaTree, "EventFormat");
         if( ! tmpMetaTree->GetBranch( tmpEventFormatBranchName.c_str() ) ) {
           // skip the additionnal metadata tree
           ::Warning( "xAOD::TEvent::readFrom", "No EventFormat branch found in metadata tree=%s",tmpMetaTree->GetName() );
            continue ;
         }
         // Read in the event format object:
         EventFormat* tmpFormat = 0; ::TBranch* tmpBr = 0;
         const Int_t status =
            tmpMetaTree->SetBranchAddress( tmpEventFormatBranchName.c_str(),
                                          &tmpFormat, &tmpBr );
         if( status < 0 ) {
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "Failed to connect to EventFormat object for metadata tree = %s"), tmpMetaTree->GetName() );
            return StatusCode::FAILURE;
         }
         // Read in the object
         tmpBr->GetEntry( 0 );
         // read all objects contained in the event format
         for (const std::pair<const std::string, xAOD::EventFormatElement> &evtElem : *tmpFormat){
            // if element is not existing
            // then add it to the private event format member
            if (!m_inputEventFormat.exists(evtElem.first)){
               m_inputEventFormat.add(evtElem.second);
            }
         }
         delete tmpFormat;
      }
 
      // Look for the event tree in the input file:
      m_inTree = dynamic_cast< ::TTree* >( file->Get( treeName ) );
      if( ! m_inTree ) {
         // This is no longer an error condition. As it can happen for DxAODs
         // that don't have any events in them. But they still have metadata
         // that needs to be collected.
         m_inTreeMissing = kTRUE;
      }
 
      // Turn on the cache if requested:
      if( m_inTree && useTreeCache && ( ! m_inTree->GetCacheSize() ) ) {
         m_inTree->SetCacheSize( CACHE_SIZE );
         m_inTree->SetCacheLearnEntries( 10 );
      }
 
      // Init the statistics collection:
      RETURN_CHECK( "xAOD::TEvent::readFrom", initStats() );
      // Update the event counter in the statistics object:
      xAOD::ReadStats& stats = IOStats::instance().stats();
      if( m_inTree ) {
         stats.setNEvents( stats.nEvents() + m_inTree->GetEntries() );
      }
 
      // Notify the listeners that a new file was opened:
      const TIncident beginIncident( IncidentType::BeginInputFile );
      for( TVirtualIncidentListener* listener : m_listeners ) {
         listener->handle( beginIncident );
      }
      // For now implement a very simple scheme in which we claim already
      // at the start that the entire file was processed. Since we have no way
      // of ensuring that the user indeed does this. And we can't delay calling
      // this function, as the user may likely close his/her output file before
      // closing the last opened input file.
      const TIncident endIncident( IncidentType::EndInputFile );
      for( TVirtualIncidentListener* listener : m_listeners ) {
         listener->handle( endIncident );
      }
 
      // The initialisation was successful:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::readFrom( ::TTree* tree, Bool_t useTreeCache ) {
 
      // Remember the info:
      m_inTree = 0;
      m_inTreeMissing = kFALSE;
      m_inChain = dynamic_cast< ::TChain* >( tree );
      m_inMetaTree = 0;
 
      if( m_inChain ) {
 
         // Set up the caching on the chain level. The individual trees of the
         // input files will get a cache set up automatically after this.
         if( useTreeCache && ( ! m_inChain->GetCacheSize() ) ) {
            m_inChain->SetCacheSize( CACHE_SIZE );
            m_inChain->SetCacheLearnEntries( 10 );
         }
 
         // Explicitly open the first file of the chain. To correctly auto-load
         // the dictionaries necessary. This doesn't happen automatically with
         // some ROOT versions...
         const TObjArray* files = m_inChain->GetListOfFiles();
         if( ! files ) {
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "Couldn't get the list of files from the "
                                   "input TChain" ) );
            return StatusCode::FAILURE;
         }
         if( ! files->GetEntries() ) {
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "No files are present in the received "
                                   "TChain" ) );
            return StatusCode::FAILURE;
         }
         const ::TChainElement* chEl =
              dynamic_cast< const ::TChainElement* >( files->At( 0 ) );
         if( ! chEl ) {
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "Couldn't cast object to TChainElement" ) );
            return StatusCode::FAILURE;
         }
         ::TFile* dummyFile = ::TFile::Open( chEl->GetTitle() );
         if( ! dummyFile ) {
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "Couldn't open file %s" ),
                                   chEl->GetTitle() );
            return StatusCode::FAILURE;
         }
         delete dummyFile;
 
         // Set up a tracker for the chain:
         if( ! m_inChainTracker ) {
            m_inChainTracker = new TChainStateTracker();
         }
         m_inChainTracker->reset();
         tree->SetNotify( m_inChainTracker );
 
         // Stop at this point. The first file will be opened when the user
         // asks for the first event. Otherwise we open the first file of the
         // chain multiple times.
         m_inTreeNumber = -1;
         return StatusCode::SUCCESS;
 
      } else {
 
         // If it's a simple TTree, then let's fully initialise the object
         // using its file:
         m_inTreeNumber = -1;
         if( m_inChainTracker ) {
            delete m_inChainTracker;
            m_inChainTracker = 0;
         }
         ::TFile* file = tree->GetCurrentFile();
         return readFrom( file, useTreeCache, tree->GetName() );
 
      }
   }
 
   StatusCode TEvent::writeTo( ::TFile* file, Int_t autoFlush,
                                const char* treeName ) {
 
      // Just a simple security check:
      if( ! file ) {
         ::Error( "xAOD::TEvent::writeTo",
                  XAOD_MESSAGE( "Null pointer given to the function!" ) );
         return StatusCode::FAILURE;
      }
 
      // Check that the object is in the "right state":
      if( m_outTree ) {
         ::Error( "xAOD::TEvent::writeTo",
                  XAOD_MESSAGE( "Object already writing to a file. Close that "
                                "file first!" ) );
         return StatusCode::FAILURE;
      }
 
      // Make sure we return to the current directory:
      TDirectoryReset dr;
 
      // Create the output TTree:
      file->cd();
      m_outTree = new ::TTree( treeName, "xAOD event tree" );
      m_outTree->SetDirectory( file );
      m_outTree->SetAutoSave( 1000000 );
      m_outTree->SetAutoFlush( autoFlush );
 
      // Access the EventFormat object associated with this file:
      m_outputEventFormat =
         &( TEventFormatRegistry::instance().getEventFormat( file ) );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::finishWritingTo( ::TFile* file ) {
 
      // A small sanity check:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::finishWritingTo",
                  XAOD_MESSAGE( "The object doesn't seem to be connected to an "
                                "output file!" ) );
         return StatusCode::FAILURE;
      }
 
      // Make sure we return to the current directory:
      TDirectoryReset dr;
 
      // Notify the listeners that they should write out their metadata, if they
      // have any.
      const TIncident incident( IncidentType::MetaDataStop );
      Listener_t::iterator l_itr = m_listeners.begin();
      Listener_t::iterator l_end = m_listeners.end();
      for( ; l_itr != l_end; ++l_itr ) {
         ( *l_itr )->handle( incident );
      }
 
      // Write out the event tree, and delete it:
      m_outTree->AutoSave( "FlushBaskets" );
      m_outTree->SetDirectory( 0 );
      delete m_outTree;
      m_outTree = 0;
 
      // Now go to the output file:
      file->cd();
 
      // Check if there's already a metadata tree in the output:
      if( file->Get( METADATA_TREE_NAME ) ) {
         // Let's assume that the metadata is complete in the file already.
         return StatusCode::SUCCESS;
      }
 
      // Create the metadata tree:
      ::TTree* metatree =
         new ::TTree( METADATA_TREE_NAME, "xAOD metadata tree" );
      metatree->SetAutoSave( 10000 );
      metatree->SetAutoFlush( -30000000 );
      metatree->SetDirectory( file );
 
      // Create the only branch in it:
      try {
        metatree->Branch( "EventFormat",
           SG::normalizedTypeinfoName( typeid( xAOD::EventFormat ) ).c_str(),
           &m_outputEventFormat );
      }
      catch (const CxxUtils::ClassName::ExcBadClassName& e) {
         ::Error( "xAOD::TEvent::finishWritingTo",
                  XAOD_MESSAGE( "Class name parsing fails for %s ! " ),
                  e.what() );
         return StatusCode::FAILURE;
      }
 
      // Create a copy of the m_outputMetaObjects variable. This is necessary
      // because the putAux(...) function will modify this variable while we
      // loop over it.
      Object_t outputMetaObjects = m_outputMetaObjects;
 
      // Now loop over all the metadata objects that need to be put into the
      // output file:
      for( auto& object : outputMetaObjects ) {
         // All metadata objects should be held by TObjectManager objects.
         // Anything else is an error.
         TObjectManager* mgr = dynamic_cast< TObjectManager* >( object.second );
         if( ! mgr ) {
            ::Error( "xAOD::TEvent::finishWritingTo",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
         // Select a split level depending on whether this is an interface or an
         // auxiliary object:
         const ::Int_t splitLevel = ( object.first.find( "Aux." ) ==
                                      ( object.first.size() - 4 ) ? 1 : 0 );
         // Create the new branch:
         *( mgr->branchPtr() ) =
            metatree->Branch( object.first.c_str(),
                              mgr->holder()->getClass()->GetName(),
                              mgr->holder()->getPtr(), 32000, splitLevel );
         if( ! mgr->branch() ) {
            ::Error( "xAOD::TEvent::finishWritingTo",
                     XAOD_MESSAGE( "Failed to create metadata branch "
                                   "\"%s/%s\"" ),
                     mgr->holder()->getClass()->GetName(),
                     object.first.c_str() );
            return StatusCode::FAILURE;
         }
         // Set up the saving of all the dynamic auxiliary properties
         // of the object if it has any:
         RETURN_CHECK( "xAOD::TEvent::finishWritingTo",
                       putAux( *metatree, *( object.second ), 32000, 0,
                               kTRUE ) );
      }
 
      // Write the metadata objects:
      if( metatree->Fill() <= 0 ) {
         ::Error( "xAOD::TEvent::finishWritingTo",
                  XAOD_MESSAGE( "Failed to write event format metadata into "
                                "the output" ) );
         metatree->SetDirectory( 0 );
         delete metatree;
         return StatusCode::FAILURE;
      }
 
      // Now clean up:
      metatree->Write();
      metatree->SetDirectory( 0 );
      delete metatree;
      m_outputEventFormat = 0;
      Object_t::iterator obj_itr = m_outputObjects.begin();
      Object_t::iterator obj_end = m_outputObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
         delete obj_itr->second;
      }
      m_outputObjects.clear();
      obj_itr = m_outputMetaObjects.begin();
      obj_end = m_outputMetaObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
         delete obj_itr->second;
      }
      m_outputMetaObjects.clear();
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   void TEvent::setActive() const {
 
      // The active event and current store are thread-local globals:
      TEvent* nc_this ATLAS_THREAD_SAFE = const_cast<TEvent*>(this);
 
      TActiveEvent::setEvent( static_cast<TVirtualEvent*>( nc_this ) );
 
#ifndef XAOD_STANDALONE
      SG::CurrentEventStore::setStore( nc_this );
#endif // not XAOD_STANDALONE
 
      // Return gracefully:
      return;
   }
 
   void TEvent::setAuxItemList( const std::string& containerKey,
                                const std::string& itemList ) {
 
      // Decoded attributes:
      std::set< std::string > attributes;
 
      // Split up the received string using "." as the separator:
      if( itemList.size() ) {
         std::stringstream ss( itemList );
         std::string attr;
         while( std::getline( ss, attr, '.' ) ) {
            attributes.insert( attr );
         }
      }
 
      // Remember the setting:
      m_auxItemList[ containerKey ] = std::move(attributes);
 
      return;
   }
 
   StatusCode TEvent::addListener( TVirtualIncidentListener* listener ) {
 
      // Check that we received a valid pointer:
      if( ! listener ) {
         ::Error( "xAOD::TEvent::addListener",
                  XAOD_MESSAGE( "Received a null pointer for the listener" ) );
         return StatusCode::FAILURE;
      }
 
      // Check if this listener is already in our list:
      bool listenerKnown = false;
      for( TVirtualIncidentListener* l : m_listeners ) {
         if( l == listener ) {
            ::Warning( "xAOD::TEvent::addListener",
                       "Listener %p was added previously already",
                       static_cast< void* >( listener ) );
            listenerKnown = true;
            break;
         }
      }
 
      // If we don't know it yet, let's add it now:
      if( ! listenerKnown ) {
         m_listeners.push_back( listener );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::removeListener( TVirtualIncidentListener* listener ) {
 
      // Find the pointer if we can...
      Listener_t::iterator itr = std::find( m_listeners.begin(),
                                            m_listeners.end(), listener );
 
      // If we didn't find it:
      if( itr == m_listeners.end() ) {
         ::Error( "xAOD::TEvent::removeListener",
                  XAOD_MESSAGE( "Listener %p not known" ),
                  static_cast< void* >( listener ) );
         return StatusCode::FAILURE;
      }
 
      // Remove it:
      m_listeners.erase( itr );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   void TEvent::clearListeners() {
 
      m_listeners.clear();
      return;
   }
 
   StatusCode TEvent::addNameRemap( const std::string& onfile,
                                     const std::string& newName ) {
 
      // Check if this name is known on the input or output already. As that's
      // not good.
      if( m_inputEventFormat.exists( newName ) ) {
         ::Error( "xAOD::TEvent::addNameRemap",
                  XAOD_MESSAGE( "Can't use \"%s\" as the target name in the"
                                "\"%s\" -> \"%s\" remapping" ),
                  newName.c_str(), onfile.c_str(), newName.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Check if this name was remapped to something already:
      auto itr = m_nameRemapping.find( newName );
      if( itr != m_nameRemapping.end() ) {
         ::Warning( "xAOD::TEvent::addNameRemap",
                    "Overriding existing name remapping \"%s\" -> \"%s\"",
                    itr->second.c_str(), itr->first.c_str() );
         ::Warning( "xAOD::TEvent::addNameRemap", "  with: \"%s\" -> \"%s\"",
                    onfile.c_str(), newName.c_str() );
      }
 
      m_nameRemapping[ newName ] = onfile;
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   void TEvent::clearNameRemap() {
 
      m_nameRemapping.clear();
      return;
   }
 
   void TEvent::printNameRemap() const {
 
      // Print a header:
      ::Info( "xAOD::TEvent::printNameRemap", "Name remapping rules:" );
 
      // In case no remapping rules have been set:
      if( ! m_nameRemapping.size() ) {
         ::Info( "xAOD::TEvent::printNameRemap", "   NONE" );
         return;
      }
 
      // Otherwise:
      for( auto itr = m_nameRemapping.begin(); itr != m_nameRemapping.end();
           ++itr ) {
         ::Info( "xAOD::TEvent::printNameRemap", "   \"%s\" -> \"%s\"",
                 itr->second.c_str(), itr->first.c_str() );
      }
 
      // Return gracefully:
      return;
   }
 
   SG::IAuxStore* TEvent::recordAux( const std::string& key,
                                     SG::IAuxStoreHolder::AuxStoreType type,
                                     ::Int_t basketSize, ::Int_t splitLevel ) {
 
      // A sanity check:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::recordAux",
                  XAOD_MESSAGE( "No output tree given to the object" ) );
         return 0;
      }
 
      // Check for an object with this name in the output list:
      Object_t::iterator itr = m_outputObjects.find( key );
      if( itr == m_outputObjects.end() ) {
         // Create one if if it doesn't exist yet...
         // Translate the store type:
         TAuxStore::EStructMode mode = TAuxStore::EStructMode::kUndefinedStore;
         switch( type ) {
         case SG::IAuxStoreHolder::AST_ObjectStore:
            mode = TAuxStore::EStructMode::kObjectStore;
            break;
         case SG::IAuxStoreHolder::AST_ContainerStore:
            mode = TAuxStore::EStructMode::kContainerStore;
            break;
         default:
            ::Error( "xAOD::TEvent::recordAux",
                     XAOD_MESSAGE( "Unknown store type (%i) requested" ),
                     static_cast< int >( type ) );
            return 0;
         }
         // Create and record the object:
         TAuxStore* store = new TAuxStore( key, kTRUE, mode,
                                           basketSize, splitLevel );
         if( record( store, key, basketSize, splitLevel, kTRUE ).isFailure() ) {
            ::Error( "xAOD::TEvent::recordAux",
                     XAOD_MESSAGE( "Couldn't connect TAuxStore object to the "
                                   "output" ) );
            delete store;
            return 0;
         }
         // Update the iterator:
         itr = m_outputObjects.find( key );
      }
 
      // A security check:
      if( itr == m_outputObjects.end() ) {
         ::Error( "xAOD::TEvent::recordAux",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return 0;
      }
 
      // Check that it is of the right type:
      TAuxManager* mgr = dynamic_cast< TAuxManager* >( itr->second );
      if( ! mgr ) {
         ::Error( "xAOD::TEvent::recordAux",
                  XAOD_MESSAGE( "Object of non-TAuxStore type registered "
                                "with key \"%s\"" ), key.c_str() );
         return 0;
      }
 
      // Extract the pointer out of it:
      TAuxStore* store = mgr->getStore();
 
      // Give it to the user:
      return store;
   }
 
   StatusCode TEvent::copy( const std::string& key,
                             ::Int_t basketSize, ::Int_t splitLevel ) {
 
      // Check if a name re-mapping should be applied or not:
      std::string keyToUse = key;
      auto remap_itr = m_nameRemapping.find( key );
      if( ( remap_itr != m_nameRemapping.end() ) &&
          ( ! m_inputEventFormat.exists( key ) ) &&
          m_inputEventFormat.exists( remap_itr->second ) ) {
         keyToUse = remap_itr->second;
      }
 
      // Make sure that the branch got connected to:
      RETURN_CHECK( "xAOD::TEvent::copy", connectBranch( keyToUse ) );
 
      // Make sure that the input object is properly updated:
      Object_t::const_iterator vobjMgr = m_inputObjects.find( keyToUse );
      if( vobjMgr == m_inputObjects.end() ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
      TObjectManager* objMgr =
         dynamic_cast< TObjectManager* >( vobjMgr->second );
      if( ! objMgr ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
      if( ! getInputObject( key,
                       *( objMgr->holder()->getClass()->GetTypeInfo() ) ) ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
 
      // Put the interface object into the output:
      RETURN_CHECK( "xAOD::TEvent::copy",
                    record( objMgr->object(),
                            objMgr->holder()->getClass()->GetName(),
                            key, basketSize, splitLevel, kTRUE ) );
 
      // Check if we have a filtering rule for the store:
      const std::set< std::string >* filter = 0;
      auto fitr = m_auxItemList.find( key + "Aux." );
      if( fitr != m_auxItemList.end() ) {
         filter = &( fitr->second );
      }
 
      // Put the auxiliary store object into the output:
      Object_t::const_iterator vauxMgr = m_inputObjects.find( keyToUse +
                                                              "Aux." );
      if( vauxMgr == m_inputObjects.end() ) {
         // If there is no auxiliary store for this object/container, we're
         // done already:
         return StatusCode::SUCCESS;
      }
      // Check what type of auxiliary store this is:
      if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
         TObjectManager* auxMgr =
            dynamic_cast< TObjectManager* >( vauxMgr->second );
         if( ! auxMgr ) {
            ::Error( "xAOD::TEvent::copy",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
         RETURN_CHECK( "xAOD::TEvent::copy",
                       record( auxMgr->object(),
                               auxMgr->holder()->getClass()->GetName(),
                               key + "Aux.", basketSize, splitLevel, kTRUE ) );
      } else if( m_auxMode == kBranchAccess ) {
         TAuxManager* auxMgr =
            dynamic_cast< TAuxManager* >( vauxMgr->second );
         if( ! auxMgr ) {
            ::Error( "xAOD::TEvent::copy",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
         // Set up the filtering:
         if( filter ) {
            auxMgr->getStore()->selectAux( *filter );
         }
         RETURN_CHECK( "xAOD::TEvent::copy",
                       record( auxMgr->getStore(),
                               key + "Aux.", basketSize, splitLevel ) );
      } else {
         ::Fatal( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::copy( ::Int_t basketSize, ::Int_t splitLevel ) {
 
      // Make sure that an input TTree is available:
      if( ! m_inTree ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "No input TTree is open" ) );
         return StatusCode::FAILURE;
      }
 
      // Loop over the known input containers:
      EventFormat::const_iterator itr = m_inputEventFormat.begin();
      EventFormat::const_iterator end = m_inputEventFormat.end();
      for( ; itr != end; ++itr ) {
 
         // Convenience reference:
         const EventFormatElement& efe = itr->second;
 
         // Ignore objects that don't exist on the input:
         if( ! m_inTree->GetBranch( efe.branchName().c_str() ) ) {
            continue;
         }
         // Skip all branches ending in "Aux.":
         if( efe.branchName().find( "Aux." ) ==
             ( efe.branchName().size() - 4 ) ) {
            continue;
         }
         // Also skip dynamic branches:
         if( efe.parentName() != "" ) {
            continue;
         }
         // Check if the class in question is known:
         ::TClass* cl = ::TClass::GetClass( efe.className().c_str() );
         if( ( ! cl ) || ( ! cl->IsLoaded() ) ) {
            continue;
         }
 
         // Make the copy then...
         RETURN_CHECK( "xAOD::TEvent::copy",
                       this->copy( efe.branchName(), basketSize, splitLevel ) );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   ::Long64_t TEvent::getEntries() const {
 
      if( m_inChain ) {
         return m_inChain->GetEntries();
      } else if( m_inTree ) {
         return m_inTree->GetEntries();
      } else if( m_inTreeMissing ) {
         // The input file is empty:
         return 0;
      } else {
         ::Error( "xAOD::TEvent::getEntries",
                  XAOD_MESSAGE( "Function called on an uninitialised "
                                "object" ) );
         return 0;
      }
   }
 
   ::Int_t TEvent::getEntry( ::Long64_t entry, ::Int_t getall ) {
 
      // A little sanity check:
      if( ( ! m_inTree ) && ( ! m_inChain ) ) {
         ::Error( "xAOD::TEvent::getEntry",
                  XAOD_MESSAGE( "Function called on an uninitialised "
                                "object" ) );
         return -1;
      }
 
      // If we have a chain as input:
      if( m_inChain ) {
         // Make sure that the correct tree is loaded:
         const ::Long64_t fileEntry = m_inChain->LoadTree( entry );
         if( fileEntry < 0 ) {
            ::Error( "xAOD::TEvent::getEntry",
                     XAOD_MESSAGE( "Failure in loading entry %i from the "
                                   "input chain" ),
                     static_cast< int >( entry ) );
            return -1;
         }
         // Check if a new file was loaded:
         if( ( m_inTreeNumber != m_inChain->GetTreeNumber() ) ||
             m_inChainTracker->internalStateChanged() ) {
            // Reset the tracker:
            m_inChainTracker->reset();
            // Connect to this new file:
            m_inTreeNumber = m_inChain->GetTreeNumber();
            ::TFile* file = m_inChain->GetFile();
            // The useTreeCache parameter is set to false, since the cache
            // is anyway set up through the TChain. It shouldn't be modified
            // on the file level.
            if( ! readFrom( file, kFALSE, m_inChain->GetName() ) ) {
               ::Error( "xAOD::TEvent::getEntry",
                        XAOD_MESSAGE( "Couldn't connect to input file #%i "
                                      "of the input chain" ), m_inTreeNumber );
               return -1;
            }
         }
         // Restore the previously received entry number.
         m_entry = fileEntry;
      }
      // If we have a regular file/tree as input:
      else {
         m_entry = entry;
      }
 
      // In order to make the reading of branches+tree cache work
      // NB: TTree::LoadTree() only set the entry that should be read for each branch
      // but no reading of the branch content is performed when calling that function.
      // The entry set that can be retrieved with
      // branch->GetTree()->GetReadEntry()
      // For friend trees, if an index was built, then the entry which is set for the related branches
      // is found by the LoadTree function by matching
      // the the major and minor values of the main tree and friend tree
      if( m_inTree && m_inTree->LoadTree( m_entry ) < 0 ) {
         ::Error( "xAOD::TEvent::getEntry",
                  XAOD_MESSAGE( "Failure in loading entry %i from the input "
                                "file" ), static_cast< int >( m_entry ) );
         return -1;
      }
 
      // Stats counter needs to know it's the next event:
      IOStats::instance().stats().nextEvent();
 
      // If force-reading is not requested, we're done:
      if( ! getall ) {
 
         // Notify the listeners that a new event was loaded:
         const TIncident incident( IncidentType::BeginEvent );
         Listener_t::iterator l_itr = m_listeners.begin();
         Listener_t::iterator l_end = m_listeners.end();
         for( ; l_itr != l_end; ++l_itr ) {
            ( *l_itr )->handle( incident );
         }
 
         // No real reading was done:
         return 0;
      }
 
      // Loop over all input object managers, and force them to load their
      // content:
      ::Int_t result = 0;
      if( m_auxMode == kAthenaAccess ) {
         // In kAthenaAccess mode we need to use getInputObject(...) to load
         // all the input objects correctly.
         for( auto& inObj : m_inputObjects ) {
            static const std::string dynStorePostfix = "Aux.Dynamic";
            if( inObj.first.find( dynStorePostfix ) ==
                ( inObj.first.size() - dynStorePostfix.size() ) ) {
               // Ignore the dynamic store objects. They get loaded through
               // their parents.
            } else {
               // Load the objects and their auxiliary stores through the
               // getInputObject(...) function, which takes care of correctly
               // setting them up. The type is irrelevant here. We don't
               // really care about the exact type of the objects.
               getInputObject( inObj.first, typeid( int ), kTRUE, kFALSE );
            }
         }
      } else {
         // In a "reasonable" access mode, we do something very simple:
         for( auto& inObj : m_inputObjects ) {
            result += inObj.second->getEntry( getall );
         }
      }
 
      // Notify the listeners that a new event was loaded:
      const TIncident incident( IncidentType::BeginEvent );
      Listener_t::iterator l_itr = m_listeners.begin();
      Listener_t::iterator l_end = m_listeners.end();
      for( ; l_itr != l_end; ++l_itr ) {
         ( *l_itr )->handle( incident );
      }
 
      // Return the number of bytes read:
      return result;
   }
 
   ::Long64_t TEvent::getFiles() const {
 
      if( m_inChain ) {
         return m_inChain->GetListOfFiles()->GetEntries();
      } else if( m_inTree || m_inTreeMissing ) {
         return 1;
      } else {
         return 0;
      }
   }
 
   ::Int_t TEvent::getFile( ::Long64_t file, ::Int_t getall ) {
 
      // Check if the file number is valid:
      if( ( file < 0 ) || ( file >= getFiles() ) ) {
         ::Error( "xAOD::TEvent::getFile",
                  XAOD_MESSAGE( "Function called with invalid file number "
                                "(%i)" ), static_cast< int >( file ) );
         return -1;
      }
 
      // If we are not reading a TChain, return at this point. As the one and
      // only file is open already...
      if( ! m_inChain ) {
         return 0;
      }
 
      // Trigger the "scanning" of the input files, so the TChain would know
      // how many entries are in the various files.
      getEntries();
 
      // Calculate which entry/event we need to load:
      ::Long64_t entry = 0;
      for( ::Long64_t i = 0; i < file; ++i ) {
         entry += m_inChain->GetTreeOffset()[ i ];
      }
 
      // Load this entry using the regular event opening function:
      return getEntry( entry, getall );
   }
 
   ::Int_t TEvent::fill() {
 
      // A little sanity check:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::fill",
                  XAOD_MESSAGE( "Object not connected to an output file!" ) );
         return 0;
      }
 
      // Make sure that all objects have been read in. The 99 as the value
      // has a special meaning for TAuxStore. With this value it doesn't
      // delete its transient (decoration) variables. Otherwise it does.
      // (As it's supposed to, when moving to a new event.)
      if( m_inChain ) {
         if (getEntry( m_inChain->GetReadEntry(), 99 ) < 0) {
           ::Error( "xAOD::TEvent::fill",
                    XAOD_MESSAGE( "getEntry failed!" ) );
           return 0;
         }
      } else if( m_inTree ) {
         if (getEntry( m_entry, 99 ) < 0) {
           ::Error( "xAOD::TEvent::fill",
                    XAOD_MESSAGE( "getEntry failed!" ) );
           return 0;
         }
      }
 
      // Prepare the objects for writing. Note that we need to iterate over a
      // copy of the m_outputObjects container. Since the putAux(...) function
      // called inside the loop may itself add elements to the m_outputObject
      // container.
      std::string unsetObjects;
      Object_t outputObjectsCopy = m_outputObjects;
      for( auto& itr : outputObjectsCopy ) {
         // Check that a new object was provided in the event:
         if( ! itr.second->create() ) {
            // We are now going to fail. But let's collect the names of
            // all the unset objects:
            if( unsetObjects.size() ) {
               unsetObjects.append( ", \"" + itr.first + "\"" );
            } else {
               unsetObjects.append( "\"" + itr.first + "\"" );
            }
            continue;
         }
         // Make sure that any dynamic auxiliary variables that
         // were added to the object after it was put into the event,
         // get added to the output:
         if( ! putAux( *m_outTree, *( itr.second ) ) ) {
            ::Error( "xAOD::TEvent::fill",
                     XAOD_MESSAGE( "Failed to put dynamic auxiliary variables "
                                   "in the output for object \"%s\"" ),
                     itr.first.c_str() );
            return 0;
         }
      }
 
      // Check if there were any unset objects:
      if( unsetObjects.size() ) {
         ::Error( "xAOD::TEvent::fill",
                  XAOD_MESSAGE( "The following objects were not set in the "
                                "current event: %s" ), unsetObjects.c_str() );
         return 0;
      }
 
      // Write the entry, and check the return value:
      const ::Int_t ret = m_outTree->Fill();
      if( ret <= 0 ) {
         ::Error( "xAOD::TEvent::fill",
                  XAOD_MESSAGE( "Output tree filling failed with return "
                                "value: %i" ), ret );
      }
 
      // Reset the object managers:
      Object_t::iterator ncitr = m_outputObjects.begin();
      Object_t::iterator ncend = m_outputObjects.end();
      for( ; ncitr != ncend; ++ncitr ) {
         ncitr->second->reset();
      }
 
      // Return the value:
      return ret;
   }
 
   const EventFormat* TEvent::inputEventFormat() const {
 
      // If we *are* reading an input file:
      if( m_inTree || m_inTreeMissing ) {
         return &m_inputEventFormat;
      }
 
      // If not, let's complain:
      ::Warning( "xAOD::TEvent::inputEventFormat",
                 "No input file is connected at the moment" );
      return 0;
   }
 
   const EventFormat* TEvent::outputEventFormat() const {
 
      // If we *are* reading an input file:
      if( m_outTree ) {
         return m_outputEventFormat;
      }
 
      // If not, let's complain:
      ::Warning( "xAOD::TEvent::outputEventFormat",
                 "No output file is connected at the moment" );
      return 0;
   }
 
   SG::sgkey_t TEvent::getHash( const std::string& key ) const {
 
      // For empty keys let's finish quickly:
      if( key == "" ) return 0;
 
      // If the key is used in the input file, let's use the same hash for
      // the output file as well:
      if( m_inputEventFormat.exists( key ) ) {
         return m_inputEventFormat.get( key )->hash();
      }
 
      // If it's a new key, make a new hash for it from scratch:
      return Utils::hash( key );
   }
 
   SG::sgkey_t TEvent::getKey( const void* obj ) const {
 
      // Make use of the getName function:
      return getHash( getName( obj ) );
   }
 
   const std::string& TEvent::getName( const void* obj ) const {
 
      // First look among the output objects:
      Object_t::const_iterator obj_itr = m_outputObjects.begin();
      Object_t::const_iterator obj_end = m_outputObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
 
         // Check if this is our object:
         if( obj_itr->second->object() != obj ) continue;
 
         // If it is, let's return right away:
         return obj_itr->first;
      }
 
      // Now look among the input objects:
      obj_itr = m_inputObjects.begin();
      obj_end = m_inputObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
 
         // Check if this is our object:
         if( obj_itr->second->object() != obj ) continue;
 
         // If it is, let's return:
         return obj_itr->first;
      }
 
      // If it's not there either, check if it's in an active TStore object:
      const TStore* store = TActiveStore::store();
      if( store && store->contains( obj ) ) {
         // Get the name from the store then:
         return store->getName( obj );
      }
 
      // We didn't find the object in the event...
      ::Warning( "xAOD::TEvent::getName",
                 "Didn't find object with pointer %p in the event",
                 obj );
      static const std::string dummy;
      return dummy;
   }
 
   void TEvent::getNames(const std::string& targetClassName,
                         std::vector<std::string>& vkeys,
                         bool metadata) const {
      // The results go in here
      std::set<std::string> keys;
 
      // Get list of branches from
      // the input metadata tree or input tree
      std::vector<TObjArray*> fullListOfBranches = {};
      if (metadata){
         if (m_inMetaTree){
            // No friend tree expected for metadata tree
            // Only add the list of branches of the metadata tree
            ::Info("xAOD::TEvent::getNames", "scanning input objects");
            fullListOfBranches.push_back(m_inMetaTree->GetListOfBranches());
         }
      }
      else {
         if (m_inTree){
            ::Info("xAOD::TEvent::getNames", "scanning input objects");
             // Add the list of branches of the main tree
            fullListOfBranches.push_back(m_inTree->GetListOfBranches());
            // If input tree has friend trees
            // add as well the list of friend tree branches
            if (m_inTree->GetListOfFriends()){
               // Get the list of friends
               TList *fList = m_inTree->GetListOfFriends();
               // Loop over friend elements
               for (TObject * feObj : *fList){
                  if (feObj){
                     // Get corresponding friend tree
                     auto * pElement = dynamic_cast<TFriendElement*>(feObj);
                     if (not pElement) continue;
                     TTree *friendTree = pElement->GetTree();
                     // Add list of branches of the friend tree
                     fullListOfBranches.push_back(friendTree->GetListOfBranches());
                  }
               }
            }
         }
      }
 
      // Loop over all list of branches (if any)
      for (const TObjArray * in : fullListOfBranches){
         // Loop over all branches inside the current list of branches
         for ( Int_t index = 0; index < in->GetEntriesFast(); ++index ) {
            const TObject * obj = in->At(index);
            if ( ! obj ) continue;
            const TBranch * element = dynamic_cast<const TBranch*>(obj);
            if (!element) {
               ::Error("xAOD::TEvent::getNames", "Failure inspecting input objects");
               break;
            }
            std::string objClassName = element->GetClassName();
            std::string key = obj->GetName();
            ::Info("xAOD::TEvent::getNames",
                  "Inspecting %s / %s",
                  objClassName.c_str(), key.c_str());
            if (objClassName == targetClassName) {
               ::Info("xAOD::TEvent::getNames",
                     "Matched %s to key %s",
                     targetClassName.c_str(), key.c_str());
               keys.insert(key);
            }
         }
      }
 
      const Object_t& inAux = ( metadata ?
                                m_inputMetaObjects : m_inputObjects );
 
      ::Info("xAOD::TEvent::getNames",
             "scanning input Aux objects for %s", targetClassName.c_str());
      for( const auto& object : inAux ) {
         // All metadata objects should be held by TObjectManager objects.
         // Anything else is an error.
         TObjectManager* mgr = dynamic_cast< TObjectManager* >( object.second );
         if ( ! mgr ) continue;
         const std::string& objClassName = mgr->holder()->getClass()->GetName();
         const std::string& key = object.first;
         ::Info("xAOD::TEvent::getNames",
                "Inspecting %s / %s",
                objClassName.c_str(), key.c_str());
         if (objClassName == targetClassName) {
            ::Info("xAOD::TEvent::getNames",
                   "Matched %s to key %s",
                   targetClassName.c_str(), key.c_str());
            keys.insert(key);
         }
      }
 
 
      // check output objects
      TTree *tree = ( metadata ? nullptr : m_outTree );
      if (tree) {
         const TObjArray * out = tree->GetListOfBranches();
         ::Info("xAOD::TEvent::getNames", "scanning output objects");
 
         for ( Int_t index = 0; index < out->GetEntriesFast(); ++index ) {
            const TObject * obj = out->At(index);
            if ( ! obj ) continue;
            const TBranch * element = dynamic_cast<const TBranch*>(obj);
            if (!element) {
               ::Error("xAOD::TEvent::getNames", "Failure inspecting input objects");
               break;
            }
            std::string objClassName = element->GetClassName();
            std::string key = obj->GetName();
            ::Info("xAOD::TEvent::getNames",
                   "Inspecting %s / %s",
                   objClassName.c_str(), key.c_str());
            if (objClassName == targetClassName) {
               ::Info("xAOD::TEvent::getNames",
                     "Matched %s to key %s",
                     targetClassName.c_str(), key.c_str());
               keys.insert(std::move(key));
            }
         }
      } else {
         ::Info("xAOD::TEvent::getNames", "no output tree connected");
      }
 
 
      const Object_t& outAux = ( metadata ?
                                 m_outputMetaObjects : m_outputObjects );
 
      // Search though EventFormat for entries where class matches the provided
      // typeName
      ::Info("xAOD::TEvent::getNames",
             "scanning output Aux objects for %s", targetClassName.c_str());
      for( const auto& object : outAux ) {
         // All metadata objects should be held by TObjectManager objects.
         // Anything else is an error.
         TObjectManager* mgr = dynamic_cast< TObjectManager* >( object.second );
         if ( ! mgr ) continue;
         const std::string& objClassName = mgr->holder()->getClass()->GetName();
         const std::string& key = object.first;
         ::Info("xAOD::TEvent::getNames",
                "Inspecting %s / %s",
                objClassName.c_str(), key.c_str());
         if (objClassName == targetClassName) {
            ::Info("xAOD::TEvent::getNames",
                   "Matched %s to key %s",
                   targetClassName.c_str(), key.c_str());
            keys.insert(key);
         }
      }
 
      vkeys.insert(vkeys.end(), keys.begin(), keys.end());
   }
 
   const std::string& TEvent::getName( SG::sgkey_t hash ) const {
 
      // If the branch is known from the input:
      if( m_inputEventFormat.exists( hash ) ) {
         return m_inputEventFormat.get( hash )->branchName();
      }
 
      // If the branch is known on the output:
      if( m_outputEventFormat &&
          m_outputEventFormat->exists( hash ) ) {
         return m_outputEventFormat->get( hash )->branchName();
      }
 
      // If this is an object in the active store:
      const TStore* store = TActiveStore::store();
      if( store && store->contains( hash ) ) {
         return store->getName( hash );
      }
 
      // If it is unknown:
      static const std::string dummy;
      return dummy;
   }
 
   void* TEvent::getOutputObject( SG::sgkey_t key,
                                  const std::type_info& ti ) {
 
      // Get a string name for this key:
      const std::string& name = getName( key );
      if( ! name.length() ) {
         return 0;
      }
 
      // Forward the call to the function using an std::string key:
      return getOutputObject( name, ti );
   }
 
   const void* TEvent::getInputObject( SG::sgkey_t key,
                                       const std::type_info& ti,
                                       bool silent ) {
 
      // Get a string name for this key:
      const std::string& name = getName( key );
      if( ( ! name.length() ) && ( ! silent ) ) {
         Warning( "xAOD::TEvent::getInputObject",
                  "Key 0x%08x unknown", key );
         return 0;
      }
 
      // Forward the call to the function using an std::string key:
      return getInputObject( name, ti, silent );
   }
 
   StatusCode TEvent::initStats() {
 
      // If we're dealing with an empty input file, stop here:
      if( m_inTreeMissing ) {
         return StatusCode::SUCCESS;
      }
 
      // A little sanity check:
      if( ! m_inTree ) {
         ::Error( "xAOD::TEvent::initStats",
                  XAOD_MESSAGE( "Function called on an uninitialised "
                                "object" ) );
         return StatusCode::FAILURE;
      }
 
      // Reset the number of input branches information:
      IOStats::instance().stats().setBranchNum( 0 );
 
      // Loop over the EventFormat information
      EventFormat::const_iterator itr = m_inputEventFormat.begin();
      EventFormat::const_iterator end = m_inputEventFormat.end();
      for( ; itr != end; ++itr ) {
 
         // Get the name of the branch in question:
         const std::string& branchName = itr->second.branchName();
 
         // If it's an auxiliary container, scan it using TAuxStore:
         if( branchName.find( "Aux." ) != std::string::npos ) {
 
            // But first decide whether it describes a container, or just
            // a single object. Since the file may have been written in
            // kBranchAccess mode, it's not necessarily a good idea to check
            // the type of the auxiliary class. So let's check the interface
            // class instead.
            //
            // Get the name of the interface object/container:
            const std::string intName =
               branchName.substr( 0, branchName.size() - 4 );
            if( ! m_inputEventFormat.exists( intName ) ) {
               // When this happens, it may still be that both the interface and
               // the auxiliary container is missing from the file. As we didn't
               // check yet whether the auxiliary container is in place or not.
               // So, before printing a warning, let's check for this.
               // Unfortunately the check is pretty expensive, but this should
               // not be performance critical code after all...
               ::Bool_t auxFound = kFALSE;
               const std::string dynName = Utils::dynBranchPrefix( branchName );
 
               std::vector<TObjArray*> fullListOfBranches = {};
               // Add the list of branches of the main tree
               fullListOfBranches.push_back(m_inTree->GetListOfBranches());
               // If input tree has friend trees
               // add as well the list of friend tree branches
               if (m_inTree->GetListOfFriends()){
                  // Get the list of friends
                  TList *fList = m_inTree->GetListOfFriends();
                  // Loop over friend elements
                  for (TObject * feObj : *fList){
                     if (feObj){
                        // Get corresponding friend tree
                        auto * pElement = dynamic_cast<TFriendElement*>(feObj);
                        if (not pElement) continue;
                        TTree *friendTree = pElement->GetTree();
                        // Add list of branches of the friend tree
                        fullListOfBranches.push_back(friendTree->GetListOfBranches());
                     }
                  }
               }
 
               for (TObjArray* branches : fullListOfBranches){
                  for( Int_t i = 0; i < branches->GetEntriesFast(); ++i ){
                     if (!branches->At( i )) continue ;
 
                     const TString name( branches->At( i )->GetName() );
                     if( name.BeginsWith( branchName ) ||
                        name.BeginsWith( dynName ) ) {
                        auxFound = kTRUE;
                        break;
                     }
                  }
               }
               if( auxFound ) {
                  ::Warning( "xAOD::TEvent::initStats",
                             "Couldn't find interface object/container "
                             "\"%s\" belonging to branch \"%s\"",
                             intName.c_str(), branchName.c_str() );
               }
               continue;
            }
 
            // Get the type of the interface:
            const EventFormatElement* el = m_inputEventFormat.get( intName );
            ::TClass* cl = ::TClass::GetClass( el->className().c_str() );
            if( ( ! cl ) || ( ! cl->IsLoaded() ) ) {
               ::Warning( "xAOD::TEvent::initStats",
                          "Couldn't find dictionary for type \"%s\"",
                          el->className().c_str() );
               continue;
            }
 
            // Get the dictionary for the DataVector base class:
            static const std::type_info& baseTi = typeid( SG::AuxVectorBase );
            static const std::string baseName =
               SG::normalizedTypeinfoName( baseTi );
            static ::TClass* const baseCl = ::TClass::GetClass( baseName.c_str() );
            if( ! baseCl ) {
               ::Error( "xAOD::TEvent::initStats",
                        XAOD_MESSAGE( "Couldn't get dictionary for type "
                                      "\"%s\"" ), baseName.c_str() );
               return StatusCode::FAILURE;
            }
 
            // The type of the auxiliary store is finally deduced from the
            // inheritance of the interface container.
            const TAuxStore::EStructMode mode =
               ( cl->InheritsFrom( baseCl ) ? TAuxStore::EStructMode::kContainerStore :
                 TAuxStore::EStructMode::kObjectStore );
 
            // Scan the branches using a temporary TAuxStore instance:
            static constexpr bool TOP_STORE = true;
            TAuxStore temp( branchName, TOP_STORE, mode );
            static constexpr bool PRINT_WARNINGS = false;
            RETURN_CHECK( "xAOD::TEvent::initStats",
                          temp.readFrom( *m_inTree, PRINT_WARNINGS ) );
 
            // Conveninence variable:
            ReadStats& stats = IOStats::instance().stats();
 
            // Teach the cache about all the branches:
            for (SG::auxid_t id : temp.getAuxIDs()) {
               stats.branch(branchName, id);
            }
 
            // Increment the number of known branches:
            stats.setBranchNum(stats.branchNum() + temp.getAuxIDs().size());
         }
         // If it's an interface container:
         else {
            // Try to access the branch:
            const ::TBranch* container =
               m_inTree->GetBranch( branchName.c_str() );
            // If it exists, let's remember it:
            if( container ) {
               IOStats::instance().stats().container( branchName );
            }
         }
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   void* TEvent::getOutputObject( const std::string& key,
                                  const std::type_info& ti,
                                  ::Bool_t metadata ) const {
 
      // Select which object container to use:
      const Object_t& objects = ( metadata ?
                                  m_outputMetaObjects : m_outputObjects );
 
      // Check if the object can be found:
      Object_t::const_iterator itr = objects.find( key );
      if( itr == objects.end() ) {
         // Do the following only for event data:
         if( ! metadata ) {
            // It's not in the event. Let's check if we find it in an active
            // TStore object...
            TStore* store = TActiveStore::store();
            if( ( ! store ) || ( ! store->contains( key, ti ) ) ||
                store->isConst( key, ti ) ) {
               // Nope, not there either...
               return 0;
            }
            // Let's return the object from the TStore:
            void* result = store->getObject( key, ti );
            return result;
         } else {
            // For metadata we don't use external resources.
            return 0;
         }
      }
 
      // If the object is not set in this event yet, we can't continue:
      if( ! itr->second->isSet() ) {
         return 0;
      }
 
      // If it does exist, check if it's the right kind of object:
      TObjectManager* mgr =
         dynamic_cast< TObjectManager* >( itr->second );
      if( ! mgr ) {
         ::Error( "xAOD::TEvent::getOutputObject",
                  XAOD_MESSAGE( "Object of wrong type found for key \"%s\"" ),
                  key.c_str() );
         return 0;
      }
 
      // Ask the holder object for the object of this type:
      void* result = mgr->holder()->getAs( ti );
      if( ! result ) {
         ::Warning( "xAOD::TEvent::getOutputObject",
                    "Couldn't retrieve object as \"%s\"",
                    Utils::getTypeName( ti ).c_str() );
         return 0;
      }
 
      // Return the object:
      return result;
   }
 
   const void* TEvent::getInputObject( const std::string& key,
                                       const std::type_info& ti,
                                       ::Bool_t silent,
                                       ::Bool_t metadata ) {
 
      // Check if a name remapping should be applied or not:
      std::string keyToUse = key;
      auto remap_itr = m_nameRemapping.find( key );
      if( ( remap_itr != m_nameRemapping.end() ) &&
          ( ! m_inputEventFormat.exists( key ) ) &&
          m_inputEventFormat.exists( remap_itr->second ) ) {
         keyToUse = remap_itr->second;
      }
 
      // The following catches the cases when we ask for a transient
      // ConstDataVector object to be returned as "const DataVector".
      TStore* store = TActiveStore::store();
      if( store && store->contains( keyToUse, ti ) &&
          store->isConst( keyToUse, ti ) ) {
         const void* result = store->getConstObject( keyToUse, ti );
         return result;
      }
 
      // A sanity check before checking for an object from the input file:
      if( ( ( ! m_inTree ) || ( m_entry < 0 ) ) &&
          ( ! metadata ) ) {
         return 0;
      }
      if( ( ! m_inMetaTree ) && metadata ) {
         return 0;
      }
 
      // Make sure that the requested branch is connected to:
      if( metadata ) {
         if( ! connectMetaBranch( keyToUse, silent ).isSuccess() ) {
            return 0;
         }
      } else {
         if( ! connectBranch( keyToUse, silent ).isSuccess() ) {
            return 0;
         }
      }
 
      // Select which object container to use:
      Object_t& objects = ( metadata ?
                            m_inputMetaObjects : m_inputObjects );
 
      // Access the object's manager:
      Object_t::iterator itr = objects.find( keyToUse );
      if( itr == objects.end() ) {
         ::Fatal( "xAOD::TEvent::getInputObject",
                  XAOD_MESSAGE( "There is an internal logic error in the "
                                "code..." ) );
         return 0;
      }
 
      // This has to be an ObjectManager object:
      TObjectManager* mgr =
         dynamic_cast< TObjectManager* >( itr->second );
      if( ! mgr ) {
         if( key == keyToUse ) {
            ::Error( "xAOD::TEvent::getInputObject",
                     XAOD_MESSAGE( "Object of wrong type found for key "
                                   "\"%s\"" ),
                     key.c_str() );
         } else {
            ::Error( "xAOD::TEvent::getInputObject",
                     XAOD_MESSAGE( "Object of wrong type found for key "
                                   "\"%s\"/\"%s\"" ), key.c_str(),
                     keyToUse.c_str() );
         }
         return 0;
      }
 
      // Make sure that the current entry is loaded for event data objects:
      if( ! metadata ) {
         if( mgr->getEntry() ) {
            // Connect the auxiliary store to objects needing it. This call also
            // takes care of updating the dynamic store of auxiliary containers,
            // when they are getting accessed directly.
            if( ! setAuxStore( *mgr ).isSuccess() ) {
               ::Error( "xAOD::TEvent::getInputObject",
                        XAOD_MESSAGE( "Failed to set the auxiliary store for "
                                      "%s/%s" ),
                        mgr->holder()->getClass()->GetName(),
                        keyToUse.c_str() );
               return 0;
            }
         }
      }
 
      // Ask the holder object for the object of this type:
      const void* result = mgr->holder()->getAsConst( ti, silent );
      if( ! result ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::getInputObject",
                       "Could not retrieve object with key \"%s\" "
                       "as \"%s\"", keyToUse.c_str(),
                       Utils::getTypeName( ti ).c_str() );
         }
         return 0;
      }
 
      // We succeeded:
      return result;
   }
 
   StatusCode TEvent::record( void* obj, const std::string& typeName,
                               const std::string& key,
                               ::Int_t basketSize, ::Int_t splitLevel,
                               ::Bool_t overwrite, ::Bool_t metadata,
                               ::Bool_t isOwner ) {
 
      // Check if we have an output tree when writing an event:
      if( ! m_outTree && ! metadata ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "No output tree defined. Did you forget to "
                                "call writeTo(...)?" ) );
         return StatusCode::FAILURE;
      }
      assert( m_outputEventFormat != 0 );
 
      // If this is metadata, just take ownership of it. The object will only
      // be recorded into the output file when calling finishWritingTo(...).
      if( metadata ) {
         // Check whether we already have such an object:
         if( ( ! overwrite ) &&
             ( m_outputMetaObjects.find( key ) !=
               m_outputMetaObjects.end() ) ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Meta-object %s/%s already recorded" ),
                     typeName.c_str(), key.c_str() );
            return StatusCode::FAILURE;
         }
         // Check if we have a dictionary for this object:
         TClass* cl = TClass::GetClass( typeName.c_str() );
         if( ! cl ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Didn't find dictionary for type: %s" ),
                     typeName.c_str() );
            return StatusCode::FAILURE;
         }
         // Let's create a holder for the object:
         THolder* hldr = new THolder( obj, cl, isOwner );
         TObjectManager* mgr =
            new TObjectManager( 0, hldr, m_auxMode == kAthenaAccess );
         m_outputMetaObjects[ key ] = mgr;
         // We're done. The rest will be done later on.
         return StatusCode::SUCCESS;
      }
 
      // Check if we accessed this object on the input. If yes, then this
      // key may not be used for recording.
      if( ( ! overwrite ) &&
          ( m_inputObjects.find( key ) != m_inputObjects.end() ) ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "Object %s/%s already accessed from the input, "
                                "can't be overwritten in memory" ),
                  typeName.c_str(), key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Override the default 0 split level with a split level of 1 for
      // auxiliary container objects.
      if( ( splitLevel == 0 ) &&
          ( key.find( "Aux." ) == ( key.size() - 4 ) ) ) {
         splitLevel = 1;
      }
 
      // Check if we need to add it to the event record:
      Object_t::iterator vitr = m_outputObjects.find( key );
      if( vitr == m_outputObjects.end() ) {
 
         // Check if we have a dictionary for this object:
         TClass* cl = TClass::GetClass( typeName.c_str() );
         if( ! cl ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Didn't find dictionary for type: %s" ),
                     typeName.c_str() );
            return StatusCode::FAILURE;
         }
 
         // Check if this is a new object "type" or not:
         if( ! m_outputEventFormat->exists( key ) ) {
            m_outputEventFormat->add( EventFormatElement( key, cl->GetName(),
                                                          "", getHash( key ) ) );
         }
 
         // Let's create a holder for the object:
         THolder* hldr = new THolder( obj, cl, isOwner );
         TObjectManager* mgr =
            new TObjectManager( 0, hldr, m_auxMode == kAthenaAccess );
         m_outputObjects[ key ] = mgr;
 
         // ... and let's add it to the output TTree:
         *( mgr->branchPtr() ) =
            m_outTree->Branch( key.c_str(), cl->GetName(),
                               hldr->getPtr(), basketSize, splitLevel );
         if( ! mgr->branch() ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Failed to create branch \"%s\" out of "
                                   "type \"%s\"" ),
                     key.c_str(), cl->GetName() );
            // Clean up:
            hldr->setOwner( kFALSE );
            delete mgr;
            return StatusCode::FAILURE;
         }
 
         // Set up the saving of all the dynamic auxiliary properties
         // of the object if it has any:
         RETURN_CHECK( "xAOD::TEvent::record",
                       putAux( *m_outTree, *mgr, basketSize, splitLevel,
                               kFALSE ) );
 
         // Return at this point, as we don't want to run the rest of
         // the function's code:
         return StatusCode::SUCCESS;
      }
 
      // Access the object manager:
      TObjectManager* omgr = dynamic_cast< TObjectManager* >( vitr->second );
      if( ! omgr ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "Manager object of the wrong type "
                                "encountered" ) );
         return StatusCode::FAILURE;
      }
 
      // Check that the type of the object matches that of the previous
      // object:
      if( typeName != omgr->holder()->getClass()->GetName() ) {
         // This may still be, when the ROOT dictionary name differs from the
         // "simple type name" known to C++. So let's get the ROOT name of the
         // new type:
         TClass* cl = TClass::GetClass( typeName.c_str() );
         if( ( ! cl ) || ::strcmp( cl->GetName(),
                                   omgr->holder()->getClass()->GetName() ) ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "For output key \"%s\" the previous type "
                                   "was \"%s\", the newly requested type is "
                                   "\"%s\"" ),
                     key.c_str(), omgr->holder()->getClass()->GetName(),
                     typeName.c_str() );
            return StatusCode::FAILURE;
         }
      }
 
      // Replace the managed object:
      omgr->setObject( obj );
 
      // Replace the auxiliary objects:
      return putAux( *m_outTree, *omgr, basketSize, splitLevel, kFALSE );
   }
 
   StatusCode TEvent::record( TAuxStore* store, const std::string& key,
                               ::Int_t /*basketSize*/, ::Int_t /*splitLevel*/,
                               ::Bool_t ownsStore ) {
 
      // Check if we have an output tree:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "No output tree defined. Did you forget to "
                                "call writeTo(...)?" ) );
         return StatusCode::FAILURE;
      }
 
      // Check if we have a filtering rule for this key:
      const std::set< std::string >* filter = 0;
      auto filter_itr = m_auxItemList.find( key );
      if( filter_itr != m_auxItemList.end() ) {
         filter = &( filter_itr->second );
      }
 
      // Check if we need to add it to the event record:
      Object_t::iterator vitr = m_outputObjects.find( key );
      if( vitr == m_outputObjects.end() ) {
 
         // Configure the object for variable filtering:
         if( filter ) {
            store->selectAux( *filter );
         }
         // Tell the object where to write its contents:
         RETURN_CHECK( "xAOD::TEvent::record", store->writeTo( *m_outTree ) );
         // Record it to the output list:
         TAuxManager* mgr = new TAuxManager( store, ownsStore );
         m_outputObjects[ key ] = mgr;
 
         // We're done:
         return StatusCode::SUCCESS;
      }
 
      // Check if the output has the right store:
      if( vitr->second->object() == store ) {
         // We're done already:
         return StatusCode::SUCCESS;
      }
 
      // If not, update the output manager. This can happen when we copy
      // objects from the input to the output files, and we process
      // multiple input files.
 
      // Check if the output manager is of the right type:
      TAuxManager* mgr = dynamic_cast< TAuxManager* >( vitr->second );
      if( ! mgr ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "Output object with key %s already exists, "
                                "and is not of type TAuxStore" ),
                  key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Configure the object for variable filtering:
      if( filter ) {
         store->selectAux( *filter );
      }
 
      // Connect the auxiliary store to the output tree:
      RETURN_CHECK( "xAOD::TEvent::record", store->writeTo( *m_outTree ) );
 
      // Update the manager:
      mgr->setObject( store );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::connectBranch( const std::string& key,
                                      ::Bool_t silent ) {
 
      // A little sanity check:
      if( ! m_inTree ) {
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Function called on un-initialised object" ) );
         return StatusCode::FAILURE;
      }
 
      // Increment the access counter on this container:
      IOStats::instance().stats().readContainer( key );
 
      // Check if the branch is already connected:
      if( m_inputObjects.find( key ) != m_inputObjects.end() ) {
         return StatusCode::SUCCESS;
      }
      // Check if it was already found to be missing.
      if( m_inputMissingObjects.find( key ) != m_inputMissingObjects.end() ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectBranch",
                       "Branch \"%s\" not available on input",
                       key.c_str() );
         }
         return StatusCode::RECOVERABLE;
      }
 
      // Check if we have metadata about this branch:
      const xAOD::EventFormatElement* ef = 0;
      if( ! m_inputEventFormat.exists( key ) ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectBranch",
                       "No metadata available for branch: %s",
                       key.c_str() );
         }
      } else {
         ef = m_inputEventFormat.get( key );
      }
 
      // Check if the branch exists in our input tree:
      ::TBranch* br =
         m_inTree->GetBranch( key.c_str() );
      if( ! br ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectBranch",
                       "Branch \"%s\" not available on input",
                       key.c_str() );
         }
         m_inputMissingObjects.insert( key );
         return StatusCode::RECOVERABLE;
      }
 
      // Make sure that it's not in "MakeClass mode":
      br->SetMakeClass( 0 );
 
      // Decide about the type that we need to use for the reading of this
      // branch:
      std::string className = br->GetClassName();
      if( className == "" ) {
         if( ef ) {
            // This is a fairly weird situation, but let's fall back to taking
            // the class name from the metadata object in this case.
            className = ef->className();
         } else {
            ::Error( "xAOD::TEvent::connectBranch",
                     XAOD_MESSAGE( "Couldn't find an appropriate type with a "
                                   "dictionary for branch \"%s\"" ),
                     key.c_str() );
            return StatusCode::FAILURE;
         }
      }
      ::TClass* realClass = ::TClass::GetClass( className.c_str() );
      if( ( ( ! realClass ) || ( ! realClass->IsLoaded() ) ) && ef ) {
         // We may need to do an actual schema evolution here, in which
         // case let's fall back on the class name coming from the metadata
         // object.
         className = ef->className();
         realClass = ::TClass::GetClass( className.c_str() );
      }
      if( ( ! realClass ) || ( ! realClass->IsLoaded() ) ) {
         // Now we're in trouble...
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Couldn't find an appropriate type with a "
                                "dictionary for branch \"%s\"" ),
                  key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Make sure that the current object is the "active event":
      setActive();
 
      // The data type is always "other" for us:
      static const ::EDataType dataType = kOther_t;
 
      // Check if the output already has this object. If it does, let's
      // assume that we have been copying the object to the output. Which
      // means that we need to resume filling the same memory address that
      // the output holder points to.
      void* ptr = 0;
      Object_t::const_iterator out_itr = m_outputObjects.find( key );
      if( out_itr != m_outputObjects.end() ) {
         // It needs to be an object manager...
         TObjectManager* mgr =
            dynamic_cast< TObjectManager* >( out_itr->second );
         if( ! mgr ) {
            ::Error( "xAOD::TEvent::connectBranch",
                     XAOD_MESSAGE( "Couldn't access output manager for: %s" ),
                     key.c_str() );
            return StatusCode::FAILURE;
         }
         // Get the pointer out of it:
         ptr = mgr->holder()->get();
      }
 
      // If there is no output object, then let's create one ourselves.
      // This is the only way in which we can have the memory management of
      // THolder do the right thing with this object.
      if( ! ptr ) {
         ptr = realClass->New();
      }
 
      // Create the new manager object that will hold this EDM object:
      THolder* hldr = new THolder( ptr, realClass );
      TObjectManager* mgr =
         new TObjectManager( 0, hldr, ( m_auxMode == kAthenaAccess ) );
      m_inputObjects[ key ] = mgr;
 
      // One final check. If it's not an auxiliary store, then it must have
      // a split level of 0. Otherwise read rules may not work on it. Causing
      // *very* serious silent corruption in the data read, if we don't use
      // the "Athena read mode".
      if( ( m_auxMode != kAthenaAccess ) && ( br->GetSplitLevel() != 0 ) &&
          ( ! isAuxStore( *mgr ) ) ) {
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Split level for branch \"%s\" is %i. "
                                "This can only be read in kAthenaAccess mode." ),
                  key.c_str(), br->GetSplitLevel() );
         // Clean up:
         *( hldr->getPtr() ) = 0;
         delete mgr;
         m_inputObjects.erase( key );
         return StatusCode::FAILURE;
      }
 
      // Now try to connect to the branch:
      const ::Int_t status = m_inTree->SetBranchAddress( key.c_str(),
                                                         hldr->getPtr(),
                                                         mgr->branchPtr(),
                                                         realClass, dataType,
                                                         kTRUE );
      if( status < 0 ) {
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Couldn't connect variable of type \"%s\" to "
                                "input branch \"%s\". Return code: %i" ),
                  className.c_str(), key.c_str(), status );
         // Clean up:
         *( hldr->getPtr() ) = 0;
         delete mgr;
         m_inputObjects.erase( key );
         return StatusCode::FAILURE;
      }
 
      // If it's an auxiliary store object, set it up correctly:
      if( isAuxStore( *mgr ) ) {
         RETURN_CHECK( "xAOD::TEvent::connectBranch",
                       setUpDynamicStore( *mgr, m_inTree ) );
      }
 
      // Return here if the object can't have an auxiliary store:
      if( ! hasAuxStore( *mgr ) ) return StatusCode::SUCCESS;
 
      // If there may be an auxiliary object connected to this one,
      // connect that as well:
      return connectAux( key + "Aux.", isStandalone( *mgr ) );
   }
 
   StatusCode TEvent::connectMetaBranch( const std::string& key,
                                          ::Bool_t silent ) {
 
      // A little sanity check:
      if( ! m_inMetaTree ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Function called on un-initialised object" ) );
         return StatusCode::FAILURE;
      }
 
      // Check if the branch is already connected:
      if( m_inputMetaObjects.find( key ) != m_inputMetaObjects.end() ) {
         return StatusCode::SUCCESS;
      }
 
      // Check if the branch exists in our metadata tree:
      ::TBranch* br = m_inMetaTree->GetBranch( key.c_str() );
      if( ! br ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectMetaBranch",
                       "Branch \"%s\" not available on input",
                       key.c_str() );
         }
         return StatusCode::RECOVERABLE;
      }
 
      // Check that we have an entry in the branch:
      if( ! br->GetEntries() ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectMetaBranch",
                       "Branch \"%s\" doesn't hold any data",
                       key.c_str() );
         }
         return StatusCode::RECOVERABLE;
      }
 
      // Make sure that it's not in "MakeClass mode":
      br->SetMakeClass( 0 );
 
      // Extract the type of the branch:
      ::TClass* cl = 0;
      ::EDataType dt = kOther_t;
      if( br->GetExpectedType( cl, dt ) || ( ! cl ) ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Couldn't get the type for metadata "
                                "branch %s" ), key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Create the object, and all of the managers around it:
      void* ptr = cl->New();
      THolder* hldr = new THolder( ptr, cl );
      TObjectManager* mgr =
         new TObjectManager( 0, hldr, m_auxMode == kAthenaAccess );
      m_inputMetaObjects[ key ] = mgr;
 
      // Now try to connect to the branch:
      const ::Int_t status = m_inMetaTree->SetBranchAddress( key.c_str(),
                                                             hldr->getPtr(),
                                                             mgr->branchPtr(),
                                                             cl, dt,
                                                             kTRUE );
      if( status < 0 ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Couldn't connect variable of type \"%s\" to "
                                "input branch \"%s\". Return code: %i" ),
                  cl->GetName(), key.c_str(), status );
         // Clean up:
         *( hldr->getPtr() ) = 0;
         delete mgr;
         m_inputMetaObjects.erase( key );
         return StatusCode::FAILURE;
      }
 
      // Read in the object:
      if( mgr->getEntry() < 0 ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Couldn't read in metadata object with key "
                                "\"%s\"" ), key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // If it's an auxiliary store object, set it up correctly:
      if( isAuxStore( *mgr ) ) {
         RETURN_CHECK( "xAOD::TEvent::connectBranch",
                       setUpDynamicStore( *mgr, m_inMetaTree ) );
      }
 
      // Return here if the object can't have an auxiliary store:
      if( ! hasAuxStore( *mgr ) ) return StatusCode::SUCCESS;
 
      // If there may be an auxiliary object connected to this one,
      // connect that as well:
      RETURN_CHECK( "xAOD::TEvent::connectMetaBranch",
                    connectMetaAux( key + "Aux.", isStandalone( *mgr ) ) );
 
      // And now connect the first object to its auxiliary store:
      RETURN_CHECK( "xAOD::TEvent::connectMetaBranch",
                    setAuxStore( *mgr, kTRUE ) );
 
      // We succeeded:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::connectAux( const std::string& prefix,
                                   ::Bool_t standalone ) {
 
      // A simple test...
      if( ! m_inTree ) {
         ::Error( "xAOD::TEvent::connectAux",
                  XAOD_MESSAGE( "No input tree is available" ) );
         return StatusCode::FAILURE;
      }
 
      // Check if we know anything about this auxiliary object:
      if( ( ! m_inTree->GetBranch( prefix.c_str() ) ) &&
          ( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) ) {
         // If not, then let's just return right away. Not having
         // an auxiliary object with this name is not an error per se.
         return StatusCode::SUCCESS;
      }
 
      // Check if the branch is already connected:
      if( m_inputObjects.find( prefix ) != m_inputObjects.end() ) {
         return StatusCode::SUCCESS;
      }
 
      // Do different things based on the "auxiliary mode" we are in:
      if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
 
         // In "class access mode" let's first connect the concrete auxiliary
         // object to the input:
         RETURN_CHECK( "xAOD::TEvent::connectAux", connectBranch( prefix ) );
 
         // Access the object's manager:
         Object_t::const_iterator mgr_itr = m_inputObjects.find( prefix );
         if( mgr_itr == m_inputObjects.end() ) {
            ::Fatal( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
         const TObjectManager* omgr =
            dynamic_cast< const TObjectManager* >( mgr_itr->second );
         if( ! omgr ) {
            ::Fatal( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
            return StatusCode::FAILURE;
         }
 
         // Check if we can switch out the internal store of this object:
         static const TClass* const holderClass =
            TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
         if( ! omgr->holder()->getClass()->InheritsFrom( holderClass ) ) {
            // Nope... So let's just end the journey here.
            return StatusCode::SUCCESS;
         }
 
         // Try to get the object as an IAuxStoreHolder:
         SG::IAuxStoreHolder* storeHolder =
            reinterpret_cast< SG::IAuxStoreHolder* >(
               omgr->holder()->getAs( typeid( SG::IAuxStoreHolder ) ) );
         if( ! storeHolder ) {
            ::Fatal( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
 
         // A sanity check to see whether the store's type is in sync with the
         // object's type that it will be connected to:
         if( ( standalone && ( storeHolder->getStoreType() !=
                               SG::IAuxStoreHolder::AST_ObjectStore ) ) ||
             ( ( ! standalone ) &&
               ( storeHolder->getStoreType() !=
                 SG::IAuxStoreHolder::AST_ContainerStore ) ) ) {
            ::Error( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "Requested store types inconsistent "
                                   "for: %s" ), prefix.c_str() );
            ::Error( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "standalone = %s, getStoreType() = %i" ),
                     ( standalone ? "kTRUE" : "kFALSE" ),
                     static_cast< int >( storeHolder->getStoreType() ) );
            return StatusCode::FAILURE;
         }
 
         // Return gracefully:
         return StatusCode::SUCCESS;
 
      } else if( m_auxMode == kBranchAccess ) {
 
         // In "branch access mode" let's create a TAuxStore object, and let
         // that take care of the auxiliary store access:
         TAuxStore* store =
            new TAuxStore( prefix, kTRUE,
                           ( standalone ? TAuxStore::EStructMode::kObjectStore :
                             TAuxStore::EStructMode::kContainerStore ) );
         // We're using this object to read from the input, it needs to be
         // locked:
         store->lock();
         TAuxManager* mgr = new TAuxManager( store );
         m_inputObjects[ prefix ] = mgr;
 
         // Now connect the object to the input tree:
         RETURN_CHECK( "xAOD::TEvent::connectAux",
                       store->readFrom( *m_inTree ) );
 
         // Return gracefully:
         return StatusCode::SUCCESS;
      }
 
      // There was some problem:
      ::Error( "xAOD::TEvent::connectAux",
               XAOD_MESSAGE( "Unknown auxiliary access mode set (%i)" ),
               static_cast< int >( m_auxMode ) );
      return StatusCode::FAILURE;
   }
 
   StatusCode TEvent::connectMetaAux( const std::string& prefix,
                                       ::Bool_t standalone ) {
 
      // Check if the branch is already connected:
      if( m_inputMetaObjects.find( prefix ) != m_inputMetaObjects.end() ) {
         return StatusCode::SUCCESS;
      }
 
      // A sanity check:
      if( ! m_inMetaTree ) {
         ::Fatal( "xAOD::TEvent::connectMetaAux",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
 
      // Do different things based on the "auxiliary mode" we are in:
      if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
 
         // In "class access mode" let's first connect the concrete auxiliary
         // object to the input:
         RETURN_CHECK( "xAOD::TEvent::connectMetaAux",
                       connectMetaBranch( prefix ) );
 
         // Access the object's manager:
         Object_t::const_iterator mgr_itr = m_inputMetaObjects.find( prefix );
         if( mgr_itr == m_inputMetaObjects.end() ) {
            ::Fatal( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
         const TObjectManager* omgr =
            dynamic_cast< const TObjectManager* >( mgr_itr->second );
         if( ! omgr ) {
            ::Fatal( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
            return StatusCode::FAILURE;
         }
 
         // Check if we can switch out the internal store of this object:
         static const TClass* const holderClass =
            TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
         if( ! omgr->holder()->getClass()->InheritsFrom( holderClass ) ) {
            // Nope... So let's just end the journey here.
            return StatusCode::SUCCESS;
         }
 
         // Try to get the object as an IAuxStoreHolder:
         SG::IAuxStoreHolder* storeHolder =
            reinterpret_cast< SG::IAuxStoreHolder* >(
               omgr->holder()->getAs( typeid( SG::IAuxStoreHolder ) ) );
         if( ! storeHolder ) {
            ::Fatal( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
 
         // A sanity check to see whether the store's type is in sync with the
         // object's type that it will be connected to:
         if( ( standalone && ( storeHolder->getStoreType() !=
                               SG::IAuxStoreHolder::AST_ObjectStore ) ) ||
             ( ( ! standalone ) &&
               ( storeHolder->getStoreType() !=
                 SG::IAuxStoreHolder::AST_ContainerStore ) ) ) {
            ::Error( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "Requested store types inconsistent" ) );
            ::Error( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "standalone = %s, getStoreType() = %i" ),
                     ( standalone ? "kTRUE" : "kFALSE" ),
                     static_cast< int >( storeHolder->getStoreType() ) );
            return StatusCode::FAILURE;
         }
 
         // Return gracefully:
         return StatusCode::SUCCESS;
 
      } else if( m_auxMode == kBranchAccess ) {
 
         // In "branch access mode" let's create a TAuxStore object, and let
         // that take care of the auxiliary store access:
         TAuxStore* store =
            new TAuxStore( prefix, kTRUE,
                           ( standalone ? TAuxStore::EStructMode::kObjectStore :
                             TAuxStore::EStructMode::kContainerStore ) );
         // We use this object to read data from the input, it needs to be
         // locked:
         store->lock();
         TAuxManager* mgr = new TAuxManager( store );
         m_inputMetaObjects[ prefix ] = mgr;
 
         // Now connect the object to the input tree:
         RETURN_CHECK( "xAOD::TEvent::connectMetaAux",
                       store->readFrom( *m_inMetaTree ) );
 
         // Tell the auxiliary store which entry to use:
         store->getEntry( 0 );
 
         // Return gracefully:
         return StatusCode::SUCCESS;
      }
 
      // There was some problem:
      ::Error( "xAOD::TEvent::connectMetaAux",
               XAOD_MESSAGE( "Unknown auxiliary access mode set (%i)" ),
               static_cast< int >( m_auxMode ) );
      return StatusCode::FAILURE;
   }
 
   StatusCode TEvent::setUpDynamicStore( TObjectManager& mgr, ::TTree* tree ) {
 
      // Check if we can call setName(...) on the object:
      ::TMethodCall setNameCall;
      // Don't use this code in Athena access mode. And just accept that access
      // monitoring is disabled in this case...
      if( m_auxMode != kAthenaAccess ) {
         setNameCall.InitWithPrototype( mgr.holder()->getClass(),
                                        "setName", "const char*" );
         if( setNameCall.IsValid() ) {
            // Yes, there is such a function. Let's call it with the branch
            // name:
            const ::TString params =
               ::TString::Format( "\"%s\"", mgr.branch()->GetName() );
            const char* charParams = params.Data();
            setNameCall.Execute( mgr.holder()->get(), charParams );
         } else {
            // This is weird. What sort of auxiliary container is this? :-/
            ::Warning( "xAOD::TEvent::setUpDynamicStore",
                       "Couldn't find setName(...) function for container %s "
                       " (type: %s)",
                       mgr.branch()->GetName(),
                       mgr.holder()->getClass()->GetName() );
         }
      }
 
      // Check if we can switch out the internal store of this object:
      static const TClass* const holderClass =
         TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
      if( ! mgr.holder()->getClass()->InheritsFrom( holderClass ) ) {
         // Nope... So let's just end the journey here.
         return StatusCode::SUCCESS;
      }
 
      // Try to get the object as an IAuxStoreHolder:
      SG::IAuxStoreHolder* storeHolder =
         reinterpret_cast< SG::IAuxStoreHolder* >(
                         mgr.holder()->getAs( typeid( SG::IAuxStoreHolder ) ) );
      if( ! storeHolder ) {
         ::Fatal( "xAOD::TEvent::setUpDynamicStore",
                  XAOD_MESSAGE( "There's a logic error in the code" ) );
         return StatusCode::FAILURE;
      }
 
      // Create a TAuxStore instance that will read the dynamic variables
      // of this container. Notice that the TAuxManager doesn't own the
      // TAuxStore object. It will be owned by the SG::IAuxStoreHolder
      // object.
      TAuxStore* store =
         new TAuxStore( mgr.branch()->GetName(), kFALSE,
                        ( storeHolder->getStoreType() ==
                          SG::IAuxStoreHolder::AST_ObjectStore ?
                          TAuxStore::EStructMode::kObjectStore :
                          TAuxStore::EStructMode::kContainerStore ) );
      // This object is used to read data from the input, it needs to be
      // locked:
      store->lock();
      TAuxManager* amgr = new TAuxManager( store, kFALSE );
      m_inputObjects[ std::string( mgr.branch()->GetName() ) +
                      "Dynamic" ] = amgr;
      RETURN_CHECK( "xAOD::TEvent::setUpDynamicStore",
                    store->readFrom( *tree ) );
      // Tell the auxiliary store which entry to use. This is essential for
      // metadata objects, and non-important for event data objects, which will
      // get a possibly different entry loaded in setAuxStore(...).
      store->getEntry( 0 );
 
      // Give this object to the store holder:
      storeHolder->setStore( store );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::setAuxStore( TObjectManager& mgr,
                                    ::Bool_t metadata ) {
 
      // Check if we need to do anything:
      if( ( ! hasAuxStore( mgr ) ) && ( ! isAuxStore( mgr ) ) ) {
         return StatusCode::SUCCESS;
      }
 
      // Get the branch name of the object in question:
      const std::string key = mgr.branch()->GetName();
 
      // Select which object container to use:
      Object_t& objects = ( metadata ?
                            m_inputMetaObjects : m_inputObjects );
 
 
      // Look up the auxiliary object's manager:
      TVirtualManager* auxMgr = nullptr;
      std::string auxKey;
      if( isAuxStore( mgr ) ) {
         auxMgr = &mgr;
         auxKey = std::move(key);
      } else {
         auto itr = objects.find( key + "Aux." );
         if( itr == objects.end() ) {
            // Apparently there's no auxiliary object for this DV, so let's
            // give up:
            return StatusCode::SUCCESS;
         }
         auxMgr = itr->second;
         auxKey = key + "Aux.";
      }
 
      if( ! metadata ) {
         // Make sure the auxiliary object is up to date:
         ::Int_t readBytes = auxMgr->getEntry();
 
         // Check if there is a separate auxiliary object for the dynamic
         // variables:
         const std::string dynAuxKey = auxKey + "Dynamic";
         auto dynAuxMgr = objects.find( dynAuxKey );
 
         if( ( dynAuxMgr != objects.end() ) &&
             ( readBytes || ( m_auxMode == kAthenaAccess ) ||
               ( auxMgr == &mgr ) ) ) {
            // Do different things based on the access mode:
            if( m_auxMode != kAthenaAccess ) {
               // In "normal" access modes just tell the dynamic store object
               // to switch to a new event.
               dynAuxMgr->second->getEntry();
            } else {
               // In "Athena mode" this object has already been deleted when
               // the main auxiliary store object was switched to the new
               // event. So let's re-create it:
               xAOD::TObjectManager& auxMgrRef =
                  dynamic_cast< xAOD::TObjectManager& >( *auxMgr );
               RETURN_CHECK( "xAOD::TEvent::setAuxStore",
                             setUpDynamicStore( auxMgrRef,
                                                ( metadata ?
                                                  m_inMetaTree :
                                                  m_inTree ) ) );
               // Now tell the newly created dynamic store object which event
               // it should be looking at:
               auto dynAuxMgr = objects.find( dynAuxKey );
               if( dynAuxMgr == objects.end() ) {
                  ::Error( "xAOD::TEvent::setAuxStore",
                           XAOD_MESSAGE( "Internal logic error detected" ) );
                  return StatusCode::FAILURE;
               }
               dynAuxMgr->second->getEntry();
            }
         }
      }
 
      // Stop here if we've set up an auxiliary store.
      if( auxMgr == &mgr ) {
         return StatusCode::SUCCESS;
      }
 
      // Access the auxiliary base class of the object/vector:
      SG::AuxVectorBase* vec = 0;
      SG::AuxElement* aux = 0;
      switch( mgr.holder()->typeKind() ) {
      case THolder::DATAVECTOR:
         {
            void* vvec = mgr.holder()->getAs( typeid( SG::AuxVectorBase ) );
            vec = reinterpret_cast< SG::AuxVectorBase* >( vvec );
         }
         break;
      case THolder::AUXELEMENT:
         {
            void* vaux = mgr.holder()->getAs( typeid( SG::AuxElement ) );
            aux = reinterpret_cast< SG::AuxElement* >( vaux );
         }
         break;
      default:
         break;
      }
 
      // Check whether index tracking is enabled for the type. If not, then
      // we need to fix it...
      if( vec && ( ! vec->trackIndices() ) ) {
         forceTrackIndices( *vec );
      }
 
      // Check if we were successful:
      if( ( ! vec ) && ( ! aux ) ) {
         ::Fatal( "xAOD::TEvent::setAuxStore",
                  XAOD_MESSAGE( "Couldn't access class \"%s\" as "
                                "SG::AuxVectorBase or SG::AuxElement" ),
                  mgr.holder()->getClass()->GetName() );
      }
 
      // Get the auxiliary store object:
      const SG::IConstAuxStore* store = 0;
      if( m_auxMode == kBranchAccess ) {
         // Get the concrete auxiliary manager:
         TAuxManager* amgr = dynamic_cast< TAuxManager* >( auxMgr );
         if( ! amgr ) {
            ::Fatal( "xAOD::TEvent::setAuxStore",
                     XAOD_MESSAGE( "Auxiliary manager for \"%s\" is not of the "
                                   "right type" ), auxKey.c_str() );
            return StatusCode::FAILURE;
         }
         store = amgr->getConstStore();
         // If the store still doesn't know its type, help it now:
         if( amgr->getStore()->structMode() == TAuxStore::EStructMode::kUndefinedStore ) {
            const TAuxStore::EStructMode mode = ( vec ?
                                                  TAuxStore::EStructMode::kContainerStore :
                                                  TAuxStore::EStructMode::kObjectStore );
            amgr->getStore()->setStructMode( mode );
         }
      } else if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
         // Get the concrete auxiliary manager:
         TObjectManager* omgr =
            dynamic_cast< TObjectManager* >( auxMgr );
         if( ! omgr ) {
            ::Fatal( "xAOD::TEvent::setAuxStore",
                     XAOD_MESSAGE( "Auxiliary manager for \"%s\" is not of the "
                                   "right type" ), auxKey.c_str() );
            return StatusCode::FAILURE;
         }
         void* p = omgr->holder()->getAs( typeid( SG::IConstAuxStore ) );
         store = reinterpret_cast< const SG::IConstAuxStore* >( p );
      }
      if( ! store ) {
         ::Fatal( "xAOD::TEvent::setAuxStore",
                  XAOD_MESSAGE( "Logic error detected in the code" ) );
      }
 
      // Connect the two:
      if( vec ) {
         vec->setStore( store );
      } else if( aux ) {
         aux->setStore( store );
      } else {
         ::Fatal( "xAOD::TEvent::setAuxStore",
                  XAOD_MESSAGE( "Logic error detected in the code" ) );
      }
 
      // We succeeded:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TEvent::putAux( ::TTree& outTree, TVirtualManager& vmgr,
                               ::Int_t basketSize, ::Int_t splitLevel,
                               ::Bool_t metadata ) {
 
      // A little sanity check:
      assert( m_outputEventFormat != 0 );
 
      // Do the conversion:
      TObjectManager* mgr = dynamic_cast< TObjectManager* >( &vmgr );
      if( ! mgr ) {
         // It's not an error any more when we don't get a TObjectManager.
         return StatusCode::SUCCESS;
      }
 
      // Check if we need to do anything here:
      if( ! mgr->holder()->getClass()->InheritsFrom( "SG::IAuxStoreIO" ) ) {
         return StatusCode::SUCCESS;
      }
 
      // Get a pointer to the auxiliary store I/O interface:
      SG::IAuxStoreIO* aux =
         reinterpret_cast< SG::IAuxStoreIO* >(
            mgr->holder()->getAs( typeid( SG::IAuxStoreIO ) ) );
      if( ! aux ) {
         ::Fatal( "xAOD::TEvent::putAux",
                  XAOD_MESSAGE( "There is a logic error in the code!" ) );
      }
 
      // Check if we have rules defined for which auxiliary properties
      // to write out:
      xAOD::AuxSelection sel;
      if( ! metadata ) {
         auto item_itr = m_auxItemList.find( mgr->branch()->GetName() );
         if( item_itr != m_auxItemList.end() ) {
            sel.selectAux( item_itr->second );
         }
      }
 
      // Get the dynamic auxiliary variables held by this object, which
      // were selected to be written:
      const SG::auxid_set_t auxids = sel.getSelectedAuxIDs (aux->getSelectedAuxIDs());
 
      // If there are no dynamic auxiliary variables in the object, return
      // right away:
      if( auxids.empty() ) {
         return StatusCode::SUCCESS;
      }
 
      // Decide what should be the prefix of all the dynamic branches:
      const std::string dynNamePrefix =
         Utils::dynBranchPrefix( mgr->branch()->GetName() );
 
      // Select which container to add the variables to:
      Object_t& objects = ( metadata ? m_outputMetaObjects : m_outputObjects );
 
      // This iteration will determine the ordering of branches within
      // the tree, so sort auxids by name.
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      typedef std::pair< std::string, SG::auxid_t > AuxVarSort_t;
      std::vector< AuxVarSort_t > varsort;
      varsort.reserve( auxids.size() );
      for( SG::auxid_t id : auxids ) {
         varsort.emplace_back( r.getName( id ), id );
      }
      std::sort( varsort.begin(), varsort.end() );
 
      // Extract all the dynamic variables from the object:
      for( const auto& p : varsort ) {
 
         // The auxiliary ID:
         const SG::auxid_t id = p.second;
 
         // Construct a name for the branch that we will write:
         const std::string brName = dynNamePrefix + p.first;
 
         // Try to find the branch:
         Object_t::iterator bmgr = objects.find( brName );
 
         // Check if we already know about this variable:
         if( bmgr == objects.end() ) {
 
            // Construct the full type name of the variable:
            const std::type_info* brType = aux->getIOType( id );
            if( ! brType ) {
               ::Error( "xAOD::TEvent::putAux",
                        XAOD_MESSAGE( "No I/O type found for variable %s" ),
                        brName.c_str() );
               return StatusCode::FAILURE;
            }
            const std::string brTypeName =
               Utils::getTypeName( *brType );
            std::string brProperTypeName = "<unknown>";
 
            // The branch that will hopefully be created:
            ::TBranch* br = 0;
 
            // Check if it's a primitive type or not:
            if( strlen( brType->name() ) == 1 ) {
 
               // Making the "proper" type name is simple in this case:
               brProperTypeName = brTypeName;
 
               // Get the character describing this type for ROOT:
               const char rootType = Utils::rootType( brType->name()[ 0 ] );
               if( rootType == '\0' ) {
                  ::Error( "xAOD::TEvent::putAux",
                           XAOD_MESSAGE( "Type not known for variable \"%s\" "
                                         "of type \"%s\"" ),
                           brName.c_str(), brTypeName.c_str() );
                  return StatusCode::FAILURE;
               }
 
               // Create the full description of the variable for ROOT:
               std::ostringstream leaflist;
               leaflist << brName << "/" << rootType;
 
               // Let's create a holder for this property:
               THolder* hldr = new THolder( aux->getIOData( id ),
                                            0, kFALSE );
               TPrimitiveAuxBranchManager* auxmgr =
                  new TPrimitiveAuxBranchManager( id, 0, hldr );
               objects[ brName ] = auxmgr;
 
               // ... and let's add it to the output TTree:
               *( auxmgr->branchPtr() ) =
                  outTree.Branch( brName.c_str(), hldr->get(),
                                  leaflist.str().c_str(),
                                  basketSize );
               if( ! auxmgr->branch() ) {
                  ::Error( "xAOD::TEvent::putAux",
                           XAOD_MESSAGE( "Failed to create branch \"%s\" out "
                                         "of type \"%s\"" ),
                           brName.c_str(), brProperTypeName.c_str() );
                  // Clean up:
                  *( auxmgr->holder()->getPtr() ) = 0;
                  delete auxmgr;
                  objects.erase( brName );
                  return StatusCode::FAILURE;
               }
               br = auxmgr->branch();
 
            } else {
 
               // Check if we have a dictionary for this type:
               TClass* cl = TClass::GetClass( *brType, kTRUE, kTRUE );
               if( ! cl ) {
                  // The dictionary needs to be loaded now. This could be an
                  // issue. But let's hope for the best...
                  cl = TClass::GetClass( brTypeName.c_str() );
                  // If still not found...
                  if( ! cl ) {
                     ::Error( "xAOD::TEvent::putAux",
                              XAOD_MESSAGE( "Dictionary not available for "
                                            "variable \"%s\" of type \"%s\"" ),
                              brName.c_str(), brTypeName.c_str() );
                     return StatusCode::FAILURE;
                  }
               }
 
               // The proper type name comes from the dictionary in this case:
               brProperTypeName = cl->GetName();
 
               // Let's create a holder for this property:
               THolder* hldr = new THolder( aux->getIOData( id ),
                                            cl, kFALSE );
               TAuxBranchManager* auxmgr =
                  new TAuxBranchManager( id, 0, hldr );
               objects[ brName ] = auxmgr;
 
               if (!cl->CanSplit() && strncmp (cl->GetName(), "SG::PackedContainer<", 20) == 0)
                 splitLevel = 0;
 
               // ... and let's add it to the output TTree:
               *( auxmgr->branchPtr() ) =
                  outTree.Branch( brName.c_str(),
                                  cl->GetName(),
                                  hldr->getPtr(), basketSize, splitLevel );
               if( ! auxmgr->branch() ) {
                  ::Error( "xAOD::TEvent::putAux",
                           XAOD_MESSAGE( "Failed to create branch \"%s\" out "
                                         "of type \"%s\"" ),
                           brName.c_str(), brProperTypeName.c_str() );
                  // Clean up:
                  *( auxmgr->holder()->getPtr() ) = 0;
                  delete auxmgr;
                  objects.erase( brName );
                  return StatusCode::FAILURE;
               }
               br = auxmgr->branch();
 
            }
 
            // If this is not the first event, fill up the already filled
            // events with (empty) content:
            if( outTree.GetEntries() ) {
               void* ptr = br->GetAddress();
               br->SetAddress( 0 );
               for( ::Long64_t i = 0; i < outTree.GetEntries(); ++i ) {
                  br->Fill();
               }
               br->SetAddress( ptr );
            }
 
            // If all went fine, let's add this branch to the event format
            // metadata:
            if( ! m_outputEventFormat->exists( brName ) ) {
               m_outputEventFormat->add(
                      EventFormatElement( brName,
                                          brProperTypeName,
                                          mgr->branch()->GetName(),
                                          getHash( brName ) ) );
            }
 
            // We don't need to do the rest:
            continue;
         }
 
         // Access the object manager:
         bmgr = objects.find( brName );
         if( bmgr == objects.end() ) {
            ::Fatal( "xAOD::TEvent::putAux",
                     XAOD_MESSAGE( "There is an internal logic error in the "
                                   "code..." ) );
         }
 
         // Replace the managed object:
         void* nc_data ATLAS_THREAD_SAFE = // we hold non-const pointers but check on retrieve
           const_cast< void* >( static_cast< const void* >( aux->getIOData( id ) ) );
         bmgr->second->setObject( nc_data );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   ::Bool_t TEvent::hasAuxStore( const TObjectManager& mgr ) {
 
      // The classes whose children can have an auxiliary store attached
      // to them:
      static const TClass* const dvClass =
         ::TClass::GetClass( typeid( SG::AuxVectorBase ) );
      static const TClass* const aeClass =
         ::TClass::GetClass( typeid( SG::AuxElement ) );
 
      // Do the check:
      return ( mgr.holder()->getClass()->InheritsFrom( dvClass ) ||
               mgr.holder()->getClass()->InheritsFrom( aeClass ) );
   }
 
   ::Bool_t TEvent::isAuxStore( const TObjectManager& mgr ) {
 
      // The classes whose children are considered auxiliary stores:
      static const TClass* const storeClass =
         ::TClass::GetClass( typeid( SG::IConstAuxStore ) );
      static const TClass* const storeHolderClass =
         ::TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
 
      // Do the check:
      return ( mgr.holder()->getClass()->InheritsFrom( storeClass ) ||
               mgr.holder()->getClass()->InheritsFrom( storeHolderClass ) );
   }
 
   ::Bool_t TEvent::isStandalone( const TObjectManager& mgr ) {
 
      // The classes whose children can have an auxiliary store attached
      // to them:
      static const TClass* const dvClass =
         TClass::GetClass( typeid( SG::AuxVectorBase ) );
      static const TClass* const aeClass =
         TClass::GetClass( typeid( SG::AuxElement ) );
 
      // Do the check:
      if( mgr.holder()->getClass()->InheritsFrom( aeClass ) ) {
         return kTRUE;
      } else if( mgr.holder()->getClass()->InheritsFrom( dvClass ) ) {
         return kFALSE;
      }
 
      // Some logic error happened:
      ::Error( "xAOD::TEvent::isStandalone",
               XAOD_MESSAGE( "Received type (%s) that can't have an "
                             "auxiliary store" ),
               mgr.holder()->getClass()->GetName() );
      return kFALSE;
   }
 
   ::Bool_t TEvent::contains( const std::string& key,
                              const std::type_info& ti,
                              ::Bool_t metadata ) {
 
      return ( getOutputObject( key, ti, metadata ) ||
               getInputObject( key, ti, kTRUE, metadata ) );
   }
 
   ::Bool_t TEvent::transientContains( const std::string& key,
                                       const std::type_info& ti,
                                       ::Bool_t metadata ) const {
 
      return getOutputObject( key, ti, metadata );
   }
 
   void TEvent::setPrintEventProxyWarnings(bool print) {
      m_printEventProxyWarnings = print;
   }
 
} // namespace xAOD