ParallelFileMerger Struct Reference

Inheritance diagram for ParallelFileMerger:

Collaboration diagram for ParallelFileMerger:

Public Member Functions
	ParallelFileMerger (const char *filename, 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

Detailed Description

Definition at line 55 of file AthenaRootSharedWriterSvc.cxx.

Constructor & Destructor Documentation

ParallelFileMerger()

ParallelFileMerger::ParallelFileMerger ( const char * filename, int compress = ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault )

inline

Definition at line 60 of file AthenaRootSharedWriterSvc.cxx.

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

~ParallelFileMerger()

ParallelFileMerger::~ParallelFileMerger ( )

inline

Definition at line 65 of file AthenaRootSharedWriterSvc.cxx.

   {
   }

Member Function Documentation

GetName()

const char * ParallelFileMerger::GetName ( ) const

inline

Definition at line 74 of file AthenaRootSharedWriterSvc.cxx.

   {
      return fFilename;
   }

Hash()

ULong_t ParallelFileMerger::Hash ( ) const

inline

Definition at line 69 of file AthenaRootSharedWriterSvc.cxx.

   {
      return fFilename.Hash();
   }

MergeTrees()

Bool_t ParallelFileMerger::MergeTrees ( TFile * input )

inline

Definition at line 124 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 80 of file AthenaRootSharedWriterSvc.cxx.

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

Member Data Documentation

fFilename

TString ParallelFileMerger::fFilename

Definition at line 57 of file AthenaRootSharedWriterSvc.cxx.

fMerger

TFileMerger ParallelFileMerger::fMerger

Definition at line 58 of file AthenaRootSharedWriterSvc.cxx.

---

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

• AthenaRootSharedWriterSvc.cxx