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.

66 {

67 }

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 125 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();
             char buff[32];
             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 == "UShort_t") type = attr + "/s";
                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(), buff, type.c_str(), 2048);
             }
             int nEntries = toTree->GetEntries();
             for (int m = 0; m < nEntries; ++m) {
                newBranch->BackFill();
             }
             updated = true;
          }
       }
       return updated;
    }