#include <RootOutputTree.h>

Public Member Functions
template<typename T >
void	addAuxiliary (std::string const &branchName, T const *&pAux, int bufSize, bool allowCloning=true)

template<typename T >
void	addAuxiliary (std::string const &branchName, T *&pAux, int bufSize, bool allowCloning=true)

void	addBranch (std::string const &branchName, std::string const &className, void const *&pProd, int splitLevel, int basketSize, bool produced)

bool	checkEntriesInReadBranches (Long64_t expectedNumberOfEntries) const

bool	checkIfFastClonable (TTree *inputTree) const

bool	checkSplitLevelsAndBasketSizes (TTree *inputTree) const

void	close ()

void	fastCloneTTree (TTree *in, std::string const &option)

void	fillTree ()

bool	isValid () const

void	maybeFastCloneTree (bool canFastClone, bool canFastCloneAux, TTree *tree, std::string const &option)

RootOutputTree &	operator= (RootOutputTree const &)=delete

void	optimizeBaskets (ULong64_t size)

	RootOutputTree (std::shared_ptr< TFile > filePtr, BranchType const &branchType, int splitLevel, int treeMaxVirtualSize)

	RootOutputTree (RootOutputTree const &)=delete

void	setAutoFlush (Long64_t size)

void	setEntries ()

TTree const *	tree () const

TTree *	tree ()

bool	uncloned (std::string const &branchName) const

void	writeTree ()

	~RootOutputTree ()

Static Public Member Functions
static TTree *	assignTTree (TFile file, TTree tree)

static TTree *	makeTTree (TFile *filePtr, std::string const &name, int splitLevel)

static void	writeTTree (TTree *tree)

Static Private Member Functions
static void	fillTTree (std::vector< TBranch * > const &branches)

Private Attributes
std::vector< TBranch * >	auxBranches_

std::set< std::string >	clonedReadBranchNames_

bool	currentlyFastCloning_

bool	fastCloneAuxBranches_

edm::propagate_const< std::shared_ptr< TFile > >	filePtr_

std::vector< TBranch * >	producedBranches_

std::vector< TBranch * >	readBranches_

edm::propagate_const< TTree * >	tree_

std::vector< TBranch * >	unclonedAuxBranches_

std::vector< TBranch * >	unclonedReadBranches_

Detailed Description

Definition at line 24 of file RootOutputTree.h.

Constructor & Destructor Documentation

edm::RootOutputTree::RootOutputTree	(	std::shared_ptr< TFile >	filePtr,
		BranchType const &	branchType,
		int	splitLevel,
		int	treeMaxVirtualSize
	)

Definition at line 87 of file RootOutputTree.cc.

References tree_.

Referenced by ~RootOutputTree().

                                            :
       filePtr_(filePtr),
       tree_(makeTTree(filePtr.get(), BranchTypeToProductTreeName(branchType), splitLevel)),
       producedBranches_(),
       readBranches_(),
       auxBranches_(),
       unclonedReadBranches_(),
       clonedReadBranchNames_(),
       currentlyFastCloning_(),
       fastCloneAuxBranches_(false) {
 
     if(treeMaxVirtualSize >= 0) tree_->SetMaxVirtualSize(treeMaxVirtualSize);
   }

edm::RootOutputTree::~RootOutputTree ( )

inline

Definition at line 31 of file RootOutputTree.h.

References operator=(), and RootOutputTree().

31 {}

edm::RootOutputTree::RootOutputTree ( RootOutputTree const & )

delete

Member Function Documentation

template<typename T >

void edm::RootOutputTree::addAuxiliary	(	std::string const &	branchName,
		T const *&	pAux,
		int	bufSize,
		bool	allowCloning = `true`
	)

inline

Definition at line 38 of file RootOutputTree.h.

References auxBranches_, edm::bufSize, tree_, and unclonedAuxBranches_.

Referenced by edm::RootOutputFile::RootOutputFile().

                                                                                                    {
       if(allowCloning) {
         auxBranches_.push_back(tree_->Branch(branchName.c_str(), &pAux, bufSize, 0));
       } else {
         unclonedAuxBranches_.push_back(tree_->Branch(branchName.c_str(), &pAux, bufSize, 0));    
       }
     }

template<typename T >

void edm::RootOutputTree::addAuxiliary	(	std::string const &	branchName,
		T *&	pAux,
		int	bufSize,
		bool	allowCloning = `true`
	)

inline

Definition at line 48 of file RootOutputTree.h.

References addBranch(), assignTTree(), auxBranches_, edm::bufSize, checkEntriesInReadBranches(), checkIfFastClonable(), checkSplitLevelsAndBasketSizes(), className(), fastCloneTTree(), FrontierConditions_GlobalTag_cff::file, fillTree(), recoMuon::in, isValid(), makeTTree(), maybeFastCloneTree(), dataset::name, TSGForRoadSearch_cfi::option, edm::es::produced, AlCaHLTBitMon_QueryRunRegistry::string, tree_, unclonedAuxBranches_, writeTree(), and writeTTree().

                                                                                             {
       if(allowCloning) {
         auxBranches_.push_back(tree_->Branch(branchName.c_str(), &pAux, bufSize, 0));
       } else {
         unclonedAuxBranches_.push_back(tree_->Branch(branchName.c_str(), &pAux, bufSize, 0));    
       }
     }

void edm::RootOutputTree::addBranch	(	std::string const &	branchName,
		std::string const &	className,
		void const *&	pProd,
		int	splitLevel,
		int	basketSize,
		bool	produced
	)

Definition at line 325 of file RootOutputTree.cc.

References edm::BranchDescription::invalidBasketSize, edm::BranchDescription::invalidSplitLevel, producedBranches_, readBranches_, JustL1Validation_cff::splitLevel, and tree_.

Referenced by addAuxiliary(), and edm::RootOutputFile::RootOutputFile().

                                            {
       assert(splitLevel != BranchDescription::invalidSplitLevel);
       assert(basketSize != BranchDescription::invalidBasketSize);
       TBranch* branch = tree_->Branch(branchName.c_str(),
                  className.c_str(),
                  &pProd,
                  basketSize,
                  splitLevel);
       assert(branch != nullptr);
 /*
       if(pProd != nullptr) {
         // Delete the product that ROOT has allocated.
         WrapperBase const* edp = static_cast<WrapperBase const *>(pProd);
         delete edp;
         pProd = nullptr;
       }
 */
       if(produced) {
         producedBranches_.push_back(branch);
       } else {
         readBranches_.push_back(branch);
       }
   }

TTree * edm::RootOutputTree::assignTTree	(	TFile *	file,
		TTree *	tree
	)

static

Definition at line 106 of file RootOutputTree.cc.

References hpstanc_transforms::max, and tree().

Referenced by addAuxiliary(), and makeTTree().

                                                          {
     tree->SetDirectory(filePtr);
     // Turn off autosaving because it is such a memory hog and we are not using
     // this check-pointing feature anyway.
     tree->SetAutoSave(std::numeric_limits<Long64_t>::max());
     return tree;
   }

bool edm::RootOutputTree::checkEntriesInReadBranches ( Long64_t expectedNumberOfEntries ) const

Definition at line 198 of file RootOutputTree.cc.

References readBranches_.

Referenced by addAuxiliary(), and edm::RootOutputFile::writeIndexIntoFile().

                                                                                         {
     for(auto const& readBranch : readBranches_) {
       if(readBranch->GetEntries() != expectedNumberOfEntries) {
         return false;
       }
     }
     return true;
   }

bool edm::RootOutputTree::checkIfFastClonable ( TTree * inputTree ) const

Definition at line 176 of file RootOutputTree.cc.

References readBranches_.

Referenced by addAuxiliary(), and edm::RootOutputFile::beginInputFile().

                                                                  {
 
     if(inputTree == nullptr) return false;
 
     // Do the sub-branches match in the input and output. Extra sub-branches in the input are OK for fast cloning, but not in the output.
     for(auto const& outputBr : readBranches_) {
       TBranchElement* outputBranch = dynamic_cast<TBranchElement*>(outputBr);
       if(outputBranch != nullptr) {
         TBranchElement* inputBranch = dynamic_cast<TBranchElement*>(inputTree->GetBranch(outputBranch->GetName()));
         if(inputBranch != nullptr) {
           // We have a matching top level branch. Do the recursive check on subbranches.
           if(!checkMatchingBranches(inputBranch, outputBranch)) {
             LogInfo("FastCloning")
               << "Fast Cloning disabled because a data member has been added to split branch: " << inputBranch->GetName() << "\n.";
             return false;
           }
         }
       }
     }
     return true;
   }

bool edm::RootOutputTree::checkSplitLevelsAndBasketSizes ( TTree * inputTree ) const

Definition at line 127 of file RootOutputTree.cc.

References MuonAssociatorByHits_cfi::obj, and readBranches_.

Referenced by addAuxiliary(), and edm::RootOutputFile::beginInputFile().

                                                                        {
 
     assert(inputTree != nullptr);
 
     // Do the split level and basket size match in the input and output?
     for(auto const& outputBranch : readBranches_) {
       if(outputBranch != nullptr) {
         TBranch* inputBranch = inputTree->GetBranch(outputBranch->GetName());
 
         if(inputBranch != nullptr) {
           if(inputBranch->GetSplitLevel() != outputBranch->GetSplitLevel() ||
               inputBranch->GetBasketSize() != outputBranch->GetBasketSize()) {
             return false;
           }
         }
       }
     }
     return true;
   }

void edm::RootOutputTree::close ( void )

Definition at line 355 of file RootOutputTree.cc.

References auxBranches_, filePtr_, producedBranches_, readBranches_, tree_, unclonedAuxBranches_, and unclonedReadBranches_.

Referenced by lumiQTWidget.ApplicationWindow::fileQuit(), esMonitoring.AsyncLineReaderMixin::handle_close(), esMonitoring.FDJsonServer::handle_close(), Vispa.Gui.BoxContentDialog.BoxContentDialog::keyPressEvent(), Vispa.Gui.FindDialog.FindDialog::keyPressEvent(), and uncloned().

                         {
     // The TFile was just closed.
     // Just to play it safe, zero all pointers to quantities in the file.
     auxBranches_.clear();
     unclonedAuxBranches_.clear();
     producedBranches_.clear();
     readBranches_.clear();
     unclonedReadBranches_.clear();
     tree_ = nullptr; // propagate_const<T> has no reset() function
     filePtr_ = nullptr; // propagate_const<T> has no reset() function
   }

void edm::RootOutputTree::fastCloneTTree	(	TTree *	in,
		std::string const &	option
	)

Definition at line 208 of file RootOutputTree.cc.

References auxBranches_, Exception, fastCloneAuxBranches_, edm::errors::FatalRootError, plotBeamSpotDB::last, edm::DuplicateTreeSentry::tree(), tree_, and unclonedAuxBranches_.

Referenced by addAuxiliary(), and maybeFastCloneTree().

                                                                    {
     if(in->GetEntries() != 0) {
       TObjArray* branches = tree_->GetListOfBranches();
       // If any products were produced (not just event products), the EventAuxiliary will be modified.
       // In that case, don't fast copy auxiliary branches. Remove them, and add back after fast copying.
       std::map<Int_t, TBranch *> auxIndexes;
       bool mustRemoveSomeAuxs = false;
       if(!fastCloneAuxBranches_) {
         for(auto const& auxBranch : auxBranches_) {
           int auxIndex = branches->IndexOf(auxBranch);
           assert (auxIndex >= 0);
           auxIndexes.insert(std::make_pair(auxIndex, auxBranch));
           branches->RemoveAt(auxIndex);
         }
         mustRemoveSomeAuxs = true;
       }
 
       //Deal with any aux branches which can never be cloned
       for(auto const& auxBranch : unclonedAuxBranches_) {
         int auxIndex = branches->IndexOf(auxBranch);
         assert (auxIndex >= 0);
         auxIndexes.insert(std::make_pair(auxIndex, auxBranch));
         branches->RemoveAt(auxIndex);
         mustRemoveSomeAuxs = true;
       }
 
       if(mustRemoveSomeAuxs) {
         branches->Compress();
       }
 
       DuplicateTreeSentry dupTree(in);
       TTreeCloner cloner(dupTree.tree(), tree_, option.c_str(), TTreeCloner::kNoWarnings|TTreeCloner::kIgnoreMissingTopLevel);
 
       if(!cloner.IsValid()) {
         // Let's check why
         static const char* okerror = "One of the export branch";
         if(strncmp(cloner.GetWarning(), okerror, strlen(okerror)) == 0) {
           // That's fine we will handle it;
         } else {
           throw edm::Exception(errors::FatalRootError)
             << "invalid TTreeCloner (" << cloner.GetWarning() << ")\n";
         }
       }
       tree_->SetEntries(tree_->GetEntries() + in->GetEntries());
       Service<RootHandlers> rootHandler;
       rootHandler->ignoreWarningsWhileDoing([&cloner] { cloner.Exec(); });
 
       if(mustRemoveSomeAuxs) {
         for(auto const& auxIndex : auxIndexes) {
           // Add the auxiliary branches back after fast copying the rest of the tree.
           Int_t last = branches->GetLast();
           if(last >= 0) {
             branches->AddAtAndExpand(branches->At(last), last+1);
             for(Int_t ind = last-1; ind >= auxIndex.first; --ind) {
               branches->AddAt(branches->At(ind), ind+1);
             };
             branches->AddAt(auxIndex.second, auxIndex.first);
           } else {
             branches->Add(auxIndex.second);
           }
         }
       }
     }
   }

void edm::RootOutputTree::fillTree ( )

Definition at line 313 of file RootOutputTree.cc.

References auxBranches_, currentlyFastCloning_, fastCloneAuxBranches_, fillTTree(), producedBranches_, tree_, unclonedAuxBranches_, and unclonedReadBranches_.

Referenced by addAuxiliary(), and core.AutoFillTreeProducer.AutoFillTreeProducer::process().

                            {
     if(currentlyFastCloning_) {
       if(!fastCloneAuxBranches_)fillTTree(auxBranches_);
       fillTTree(unclonedAuxBranches_);
       fillTTree(producedBranches_);
       fillTTree(unclonedReadBranches_);
     } else {
       tree_->Fill();
     }
   }

void edm::RootOutputTree::fillTTree ( std::vector< TBranch * > const & branches )

staticprivate

Definition at line 283 of file RootOutputTree.cc.

References HcalObjRepresent::Fill(), and edm::for_all().

Referenced by fillTree(), and setAutoFlush().

                                                                {
     for_all(branches, std::bind(&TBranch::Fill, std::placeholders::_1));
   }

bool edm::RootOutputTree::isValid ( ) const

Referenced by ntupleDataFormat._Object::_checkIsValid(), addAuxiliary(), and core.AutoHandle.AutoHandle::ReallyLoad().

TTree * edm::RootOutputTree::makeTTree	(	TFile *	filePtr,
		std::string const &	name,
		int	splitLevel
	)

static

Definition at line 115 of file RootOutputTree.cc.

References assignTTree(), Exception, edm::errors::FatalRootError, and JustL1Validation_cff::splitLevel.

Referenced by addAuxiliary(), and edm::RootOutputFile::RootOutputFile().

                                                                                  {
     TTree* tree = new TTree(name.c_str(), "", splitLevel);
     if(!tree) throw edm::Exception(errors::FatalRootError)
       << "Failed to create the tree: " << name << "\n";
     if(tree->IsZombie())
       throw edm::Exception(errors::FatalRootError)
         << "Tree: " << name << " is a zombie." << "\n";
 
     return assignTTree(filePtr, tree);
   }

void edm::RootOutputTree::maybeFastCloneTree	(	bool	canFastClone,
		bool	canFastCloneAux,
		TTree *	tree,
		std::string const &	option
	)

Definition at line 293 of file RootOutputTree.cc.

References clonedReadBranchNames_, currentlyFastCloning_, fastCloneAuxBranches_, fastCloneTTree(), readBranches_, AlCaHLTBitMon_QueryRunRegistry::string, tree_, and unclonedReadBranches_.

Referenced by addAuxiliary(), and edm::RootOutputFile::beginInputFile().

                                                                                                                   {
     unclonedReadBranches_.clear();
     clonedReadBranchNames_.clear();
     currentlyFastCloning_ = canFastClone && !readBranches_.empty();
     if(currentlyFastCloning_) {
       fastCloneAuxBranches_ = canFastCloneAux;
       fastCloneTTree(tree, option);
       for(auto const& branch : readBranches_) {
         if(branch->GetEntries() == tree_->GetEntries()) {
           clonedReadBranchNames_.insert(std::string(branch->GetName()));
         } else {
           unclonedReadBranches_.push_back(branch);
         }
       }
       Service<JobReport> reportSvc;
       reportSvc->reportFastClonedBranches(clonedReadBranchNames_, tree_->GetEntries());
     }
   }

RootOutputTree& edm::RootOutputTree::operator= ( RootOutputTree const & )

delete

Referenced by ~RootOutputTree().

void edm::RootOutputTree::optimizeBaskets ( ULong64_t size )

inline

Definition at line 104 of file RootOutputTree.h.

References tree_.

Referenced by edm::RootOutputFile::writeLuminosityBlock(), and edm::RootOutputFile::writeRun().

                                          {
       tree_->OptimizeBaskets(size);
     }

void edm::RootOutputTree::setAutoFlush ( Long64_t size )

inline

Definition at line 108 of file RootOutputTree.h.

References fillTTree(), and tree_.

Referenced by edm::RootOutputFile::RootOutputFile().

                                      {
       tree_->SetAutoFlush(size);
     }

void edm::RootOutputTree::setEntries ( )

inline

Definition at line 93 of file RootOutputTree.h.

References tree_.

Referenced by edm::RootOutputFile::respondToCloseInputFile().

                       {
       if(tree_->GetNbranches() != 0) tree_->SetEntries(-1);
     }

TTree const* edm::RootOutputTree::tree ( ) const

inline

Definition at line 85 of file RootOutputTree.h.

References edm::propagate_const< T >::get(), and tree_.

Referenced by assignTTree(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::beginLoop(), MetTreeProducer.MetTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::fillTree(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::process(), MetTreeProducer.MetTreeProducer::process(), python.cmstools.EventTree::SetAlias(), and writeTree().

                               {
       return tree_.get();
     }

TTree* edm::RootOutputTree::tree ( )

inline

Definition at line 89 of file RootOutputTree.h.

References edm::propagate_const< T >::get(), and tree_.

Referenced by ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::beginLoop(), MetTreeProducer.MetTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::fillTree(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::process(), MetTreeProducer.MetTreeProducer::process(), and python.cmstools.EventTree::SetAlias().

                   {
       return tree_.get();
     }

bool edm::RootOutputTree::uncloned ( std::string const & branchName ) const

inline

Definition at line 98 of file RootOutputTree.h.

References clonedReadBranchNames_, and close().

                                                 {
       return clonedReadBranchNames_.find(branchName) == clonedReadBranchNames_.end();
     }

void edm::RootOutputTree::writeTree ( )

Definition at line 288 of file RootOutputTree.cc.

References tree(), and writeTTree().

Referenced by addAuxiliary().

                             {
     writeTTree(tree());
   }

void edm::RootOutputTree::writeTTree ( TTree * tree )

static

Definition at line 274 of file RootOutputTree.cc.

References edm::setRefCoreStreamer().

Referenced by addAuxiliary(), edm::RootOutputFile::finishEndFile(), and writeTree().

                                         {
     if(tree->GetNbranches() != 0) {
       tree->SetEntries(-1);
     }
     setRefCoreStreamer(true);
     tree->AutoSave("FlushBaskets");
   }