ParallelFileMerger Struct Reference

Inheritance diagram for ParallelFileMerger:

Collaboration diagram for ParallelFileMerger:

Public Member Functions
	ParallelFileMerger (const char *filename, std::unordered_map< TClass *, void * > *cache, int compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault)
	~ParallelFileMerger ()
ULong_t	Hash () const
const char *	GetName () const
bool	syncBranches (TTree *fromTree, TTree *toTree)
Bool_t	MergeTrees (TFile *input)

Public Attributes
TString	fFilename
TFileMerger	fMerger
std::unordered_map< TClass *, void * > *	m_cache

Detailed Description

Definition at line 44 of file AthenaRootSharedWriterSvc.cxx.

Constructor & Destructor Documentation

ParallelFileMerger()

ParallelFileMerger::ParallelFileMerger ( const char * filename, std::unordered_map< TClass *, void * > * cache, int compress = ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault )

inline

Definition at line 50 of file AthenaRootSharedWriterSvc.cxx.

           : fFilename(filename), fMerger(kFALSE, kTRUE), m_cache(cache)
   {
      fMerger.OutputFile(filename, "RECREATE", compress);
   }

~ParallelFileMerger()

ParallelFileMerger::~ParallelFileMerger ( )

inline

Definition at line 56 of file AthenaRootSharedWriterSvc.cxx.

   {
   }

Member Function Documentation

GetName()

const char * ParallelFileMerger::GetName ( ) const

inline

Definition at line 65 of file AthenaRootSharedWriterSvc.cxx.

   {
      return fFilename;
   }

Hash()

ULong_t ParallelFileMerger::Hash ( ) const

inline

Definition at line 60 of file AthenaRootSharedWriterSvc.cxx.

   {
      return fFilename.Hash();
   }

MergeTrees()

Bool_t ParallelFileMerger::MergeTrees ( TFile * input )

inline

Definition at line 117 of file AthenaRootSharedWriterSvc.cxx.

   {
      fMerger.AddFile(input);
      TIter nextKey(input->GetListOfKeys());
      while (TKey* key = static_cast<TKey*>(nextKey())) {
         TClass* cl = TClass::GetClass(key->GetClassName());
         if (cl != nullptr && cl->InheritsFrom("TTree")) {
            TTree* outCollTree = static_cast<TTree*>(fMerger.GetOutputFile()->Get(key->GetName()));
            TTree* inCollTree = static_cast<TTree*>(input->Get(key->GetName()));
            if (inCollTree != nullptr && outCollTree != nullptr) {
               if (syncBranches(outCollTree, inCollTree)) {
                  input->Write();
               }
               syncBranches(inCollTree, outCollTree);
            }
         }
      }
 
      Bool_t result = fMerger.PartialMerge(TFileMerger::kIncremental | TFileMerger::kResetable | TFileMerger::kKeepCompression);
      nextKey = input->GetListOfKeys();
      while (TKey* key = static_cast<TKey*>(nextKey())) {
         TClass* cl = TClass::GetClass(key->GetClassName());
         if (cl != nullptr && 0 != cl->GetResetAfterMerge()) {
            key->Delete();
            input->GetListOfKeys()->Remove(key);
            delete key;
         }
      }
      return result;
   }

syncBranches()

bool ParallelFileMerger::syncBranches ( TTree * fromTree, TTree * toTree )

inline

Definition at line 71 of file AthenaRootSharedWriterSvc.cxx.

   {
      bool updated = false;
      const TObjArray* fromBranches = fromTree->GetListOfBranches();
      const TObjArray* toBranches = toTree->GetListOfBranches();
      int nBranches = fromBranches->GetEntriesFast();
      int nEntries = toTree->GetEntries();
      for (int k = 0; k < nBranches; ++k) {
         TBranch* branch = static_cast<TBranch*>(fromBranches->UncheckedAt(k));
         if (toBranches->FindObject(branch->GetName()) == nullptr) {
            TBranch* newBranch = nullptr;
            TClass* cl = TClass::GetClass(branch->GetClassName());
            if (cl != nullptr) {
               newBranch = toTree->Branch(branch->GetName(), branch->GetClassName(), nullptr, branch->GetBasketSize(), branch->GetSplitLevel());
               void* empty = getCachedDummyAddress(cl, *m_cache);
               newBranch->SetAddress(empty);
            } else {
               TObjArray* outLeaves = branch->GetListOfLeaves();
               TLeaf* leaf = static_cast<TLeaf*>(outLeaves->UncheckedAt(0));
               std::string_view attr = leaf->GetName();
               std::string_view type = leaf->GetTypeName();
               std::string branchSpec(attr);
               branchSpec += '/';
               if (type == "Int_t")        branchSpec += 'I';
               else if (type == "Short_t") branchSpec += 'S';
               else if (type == "Long_t")  branchSpec += 'L';
               else if (type == "UInt_t")  branchSpec +='i';
               else if (type == "UShort_t") branchSpec+='s';
               else if (type == "ULong_t") branchSpec +='l';
               else if (type == "Float_t") branchSpec +='F';
               else if (type == "Double_t") branchSpec+='D';
               else if (type == "Char_t")  branchSpec +='B';
               else if (type == "UChar_t") branchSpec +='b';
               else if (type == "Bool_t")  branchSpec +='O';
               else                       { branchSpec += type; }// fallback
               newBranch = toTree->Branch(branch->GetName(), static_cast<void*>(nullptr), branchSpec.c_str(), 2048);
            }
            for (int m = 0; m < nEntries; ++m) {
               newBranch->BackFill();
            }
            updated = true;
         }
      }
      return updated;
   }

Member Data Documentation

fFilename

TString ParallelFileMerger::fFilename

Definition at line 46 of file AthenaRootSharedWriterSvc.cxx.

fMerger

TFileMerger ParallelFileMerger::fMerger

Definition at line 47 of file AthenaRootSharedWriterSvc.cxx.

m_cache

std::unordered_map<TClass*, void*>* ParallelFileMerger::m_cache

Definition at line 48 of file AthenaRootSharedWriterSvc.cxx.

---

The documentation for this struct was generated from the following file:

• AthenaRootSharedWriterSvc.cxx