Control/xAODRootAccess/xAODRootAccess/TEvent.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
//
#ifndef XAODROOTACCESS_TEVENT_H
#define XAODROOTACCESS_TEVENT_H
 
// Local include(s).
#include "xAODRootAccess/Event.h"
 
// Project include(s).
#include "AthContainersInterfaces/IAuxStoreHolder.h"
 
// ROOT include(s).
#include <Rtypes.h>
 
// System include(s).
#include <memory>
#include <regex>
#include <string>
#include <string_view>
 
// Forward declaration(s).
class TFile;
class TChain;
class TTree;
namespace CP {
class xAODWriterAlg;
}
class xAODTEventBranch;
class xAODTMetaBranch;
namespace SG {
class IAuxStore;
}
 
namespace xAOD {
 
// Forward declaration(s).
class TAuxStore;
class TObjectManager;
class TChainStateTracker;
class TFileMerger;
class TEvent;
class TTreeMgr;
::TTree* MakeTransientTree ATLAS_NOT_THREAD_SAFE(TEvent &, const char* );

class TEvent : public Event {
 
  // Declare the friend functions/classes:
  friend ::TTree* MakeTransientTree(TEvent &, const char* );
  friend class ::xAODTEventBranch;
  friend class ::xAODTMetaBranch;
  friend class xAOD::TFileMerger;
  friend class xAOD::TTreeMgr;
  friend class CP::xAODWriterAlg;
 
public:
  enum EAuxMode {
    kBranchAccess = 0, 
    kClassAccess = 1,  
    kAthenaAccess = 2  
  };

  TEvent(EAuxMode mode = kClassAccess);
  TEvent(::TFile* file, EAuxMode mode = kClassAccess);
  TEvent(::TTree* tree, EAuxMode mode = kClassAccess);
  virtual ~TEvent();

  void setOtherMetaDataTreeNamePattern(const std::string &pattern);

  EAuxMode auxMode() const;

 

  StatusCode readFrom(::TFile& inFile) override;

  StatusCode readFrom(::TFile* file, bool useTreeCache = true,
                      std::string_view treeName = EVENT_TREE_NAME);
  StatusCode readFrom(::TTree* tree, bool useTreeCache = true);
  StatusCode writeTo(::TFile* file, int autoFlush = 200,
                     std::string_view treeName = EVENT_TREE_NAME);
  StatusCode finishWritingTo(::TFile* file);


 
  // Bring the definition of Event::record into scope
  using Event::record;

  SG::IAuxStore* recordAux(const std::string& key,
                           SG::IAuxStoreHolder::AuxStoreType type =
                               SG::IAuxStoreHolder::AST_ContainerStore);



  ::Long64_t getEntries() const override;
  ::Int_t getEntry(::Long64_t entry, ::Int_t getall = 0) override;

  ::Long64_t getFiles() const;
  ::Int_t getFile(::Long64_t file, ::Int_t getall = 0);

  ::Int_t fill();

 
protected:

  bool hasInput() const override;
  bool hasOutput() const override;

  StatusCode getNames(const std::string& targetClassName,
                      std::vector<std::string>& vkeys,
                      bool metadata) const override;

  StatusCode connectObject(const std::string& key, bool silent) override;
  StatusCode connectMetaObject(const std::string& key, bool silent) override;
  StatusCode connectAux(const std::string& prefix, bool standalone) override;
  StatusCode connectMetaAux(const std::string& prefix,
                            bool standalone) override;

  StatusCode setAuxStore(const std::string& key, Details::IObjectManager& mgr,
                         bool metadata) override;

  StatusCode record(void* obj, const std::string& typeName,
                    const std::string& key, bool overwrite, bool metadata,
                    bool isOwner) override;
  StatusCode recordAux(TVirtualManager& mgr, const std::string& key,
                       bool metadata) override;


  StatusCode initStats();

  StatusCode record(std::unique_ptr<TAuxStore> store, const std::string& key);
  StatusCode setUpDynamicStore(TObjectManager& mgr, ::TTree* tree);
  StatusCode putAux(::TTree& outTree, TVirtualManager& mgr, bool metadata);
  StatusCode recordAux(TAuxStore* store, const std::string& key);

  EAuxMode m_auxMode;

  ::TTree* m_inTree = nullptr;
  bool m_inTreeMissing = false;
  ::TChain* m_inChain = nullptr;
  std::unique_ptr<TChainStateTracker> m_inChainTracker;
  ::Int_t m_inTreeNumber = -1;
  ::TTree* m_inMetaTree = nullptr;
  ::Long64_t m_entry = -1;

  std::unique_ptr<::TTree> m_outTree;
 
  // Regular expression to match other MetaData trees in augmented files
  // Other MetaData trees should be called MetaData_* but not named
  // MetaDataHdr_* Those additional trees are only expected for augmented files
  std::regex m_otherMetaDataTreeNamePattern =
      std::regex("^MetaData(?!Hdr)_.*$");
}; // class TEvent
 
} // namespace xAOD
 
#endif // XAODROOTACCESS_TEVENT_H