#include <RootOutputTree.h>

Inheritance diagram for edm::RootOutputTree:

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

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

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

bool	checkIfFastClonable (TTree *inputTree) const

bool	checkSplitLevelsAndBasketSizes (TTree *inputTree) const

void	close ()

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

void	fillTree () const

bool	isValid () const

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

void	optimizeBaskets (ULong64_t size)

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

void	setAutoFlush (Long64_t size)

void	setEntries ()

TTree *const	tree () const

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

void	writeTree () const

	~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 (TTree tree, std::vector< TBranch > const &branches)

Private Attributes
std::vector< TBranch * >	auxBranches_

bool	currentlyFastCloning_

bool	fastCloneAuxBranches_

boost::shared_ptr< TFile >	filePtr_

std::vector< TBranch * >	producedBranches_

std::vector< TBranch * >	readBranches_

TTree *	tree_

std::vector< TBranch * >	unclonedReadBranches_

std::set< std::string >	unclonedReadBranchNames_

Detailed Description

Definition at line 25 of file RootOutputTree.h.

Constructor & Destructor Documentation

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

Definition at line 25 of file RootOutputTree.cc.

References tree_.

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

edm::RootOutputTree::~RootOutputTree ( )

inline

Definition at line 33 of file RootOutputTree.h.

33 {}

Member Function Documentation

template<typename T >

void edm::RootOutputTree::addAuxiliary	(	std::string const &	branchName,
		T const *&	pAux,
		int	bufSize
	)

inline

Definition at line 37 of file RootOutputTree.h.

References auxBranches_, and tree_.

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

                                                                            {
       auxBranches_.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
	)

inline

Definition at line 43 of file RootOutputTree.h.

References auxBranches_, and tree_.

                                                                      {
       auxBranches_.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 250 of file RootOutputTree.cc.

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

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

                                            {
       assert(splitLevel != BranchDescription::invalidSplitLevel);
       assert(basketSize != BranchDescription::invalidBasketSize);
       TBranch* branch = tree_->Branch(branchName.c_str(),
                  className.c_str(),
                  &pProd,
                  basketSize,
                  splitLevel);
       if(produced) {
         producedBranches_.push_back(branch);
       } else {
         readBranches_.push_back(branch);
       }
   }

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

static

Definition at line 45 of file RootOutputTree.cc.

References max(), and tree().

Referenced by 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::checkIfFastClonable ( TTree * inputTree ) const

Definition at line 118 of file RootOutputTree.cc.

References readBranches_.

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

                                                                  {
 
     if(inputTree == 0) 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(std::vector<TBranch*>::const_iterator it = readBranches_.begin(), itEnd = readBranches_.end(); it != itEnd; ++it) {
       TBranchElement* outputBranch = dynamic_cast<TBranchElement*>(*it);
       if(outputBranch != 0) {
         TBranchElement* inputBranch = dynamic_cast<TBranchElement*>(inputTree->GetBranch(outputBranch->GetName()));
         if(inputBranch != 0) {
           // 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 true;
   }

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

Definition at line 66 of file RootOutputTree.cc.

References readBranches_.

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

                                                                        {
 
     assert (inputTree != 0);
 
     // Do the split level and basket size match in the input and output?
     for(std::vector<TBranch*>::const_iterator it = readBranches_.begin(), itEnd = readBranches_.end();
       it != itEnd; ++it) {
 
       TBranch* outputBranch = *it;
       if(outputBranch != 0) {
         TBranch* inputBranch = inputTree->GetBranch(outputBranch->GetName());
 
         if(inputBranch != 0) {
           if(inputBranch->GetSplitLevel() != outputBranch->GetSplitLevel() ||
               inputBranch->GetBasketSize() != outputBranch->GetBasketSize()) {
             return false;
           }
         }
       }
     }
     return true;
   }

void edm::RootOutputTree::close ( void )

Definition at line 271 of file RootOutputTree.cc.

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

Referenced by python.Vispa.Gui.BoxContentDialog.BoxContentDialog::keyPressEvent(), and python.Vispa.Gui.FindDialog.FindDialog::keyPressEvent().

                         {
     // The TFile was just closed.
     // Just to play it safe, zero all pointers to quantities in the file.
     auxBranches_.clear();
     producedBranches_.clear();
     readBranches_.clear();
     unclonedReadBranches_.clear();
     tree_ = 0;
     filePtr_.reset();
   }

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

Definition at line 140 of file RootOutputTree.cc.

References auxBranches_, edm::hlt::Exception, fastCloneAuxBranches_, edm::errors::FatalRootError, prof2calltree::last, and tree_.

Referenced by 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;
       if (!fastCloneAuxBranches_) {
         for (std::vector<TBranch *>::const_iterator it = auxBranches_.begin(), itEnd = auxBranches_.end();
              it != itEnd; ++it) {
           int auxIndex = branches->IndexOf(*it);
           assert (auxIndex >= 0);
           auxIndexes.insert(std::make_pair(auxIndex, *it));
           branches->RemoveAt(auxIndex);
         }
         branches->Compress();
       }
 
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,26,0)
       TTreeCloner cloner(in, tree_, option.c_str(), TTreeCloner::kNoWarnings|TTreeCloner::kIgnoreMissingTopLevel);
 #else
       TTreeCloner cloner(in, tree_, option.c_str());
 #endif
 
       if(!cloner.IsValid()) {
 
 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,26,0)
         // 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\n";
         }
 #else
         throw edm::Exception(errors::FatalRootError)
           << "invalid TTreeCloner\n";
 #endif
       }
       tree_->SetEntries(tree_->GetEntries() + in->GetEntries());
       cloner.Exec();
       if (!fastCloneAuxBranches_) {
         for (std::map<Int_t, TBranch *>::const_iterator it = auxIndexes.begin(), itEnd = auxIndexes.end();
              it != itEnd; ++it) {
           // 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 >= it->first; --ind) {
               branches->AddAt(branches->At(ind), ind+1);
             };
             branches->AddAt(it->second, it->first);
           } else {
             branches->Add(it->second);
           }
         }
       }
     }
   }

void edm::RootOutputTree::fillTree ( ) const

Definition at line 239 of file RootOutputTree.cc.

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

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

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

staticprivate

Definition at line 211 of file RootOutputTree.cc.

References edm::for_all().

Referenced by fillTree().

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

bool edm::RootOutputTree::isValid ( ) const

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

static

Definition at line 54 of file RootOutputTree.cc.

References assignTTree(), edm::hlt::Exception, edm::errors::FatalRootError, ExpressReco_HICollisions_FallBack::splitLevel, and tree().

Referenced by 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 221 of file RootOutputTree.cc.

References currentlyFastCloning_, fastCloneAuxBranches_, fastCloneTTree(), readBranches_, tree_, unclonedReadBranches_, and unclonedReadBranchNames_.

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

                                                                                                                   {
     unclonedReadBranches_.clear();
     unclonedReadBranchNames_.clear();
     currentlyFastCloning_ = canFastClone && !readBranches_.empty();
     if(currentlyFastCloning_) {
       fastCloneAuxBranches_ = canFastCloneAux;
       fastCloneTTree(tree, option);
       for(std::vector<TBranch*>::const_iterator it = readBranches_.begin(), itEnd = readBranches_.end();
           it != itEnd; ++it) {
         if((*it)->GetEntries() != tree_->GetEntries()) {
           unclonedReadBranches_.push_back(*it);
           unclonedReadBranchNames_.insert(std::string((*it)->GetName()));
         }
       }
     }
   }

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

inline

Definition at line 89 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 93 of file RootOutputTree.h.

References tree_.

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

                                      {
       tree_->SetAutoFlush(size);
     }

void edm::RootOutputTree::setEntries ( )

inline

Definition at line 78 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 74 of file RootOutputTree.h.

References tree_.

Referenced by assignTTree(), makeTTree(), and python.cmstools.EventTree::SetAlias().

                               {
       return tree_;
     }

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

inline

Definition at line 83 of file RootOutputTree.h.

References unclonedReadBranchNames_.

                                                 {
       return unclonedReadBranchNames_.find(branchName) != unclonedReadBranchNames_.end();
     }

void edm::RootOutputTree::writeTree ( ) const

Definition at line 216 of file RootOutputTree.cc.

References tree_, and writeTTree().

                                   {
     writeTTree(tree_);
   }

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

static

Definition at line 202 of file RootOutputTree.cc.

References edm::setRefCoreStreamer().

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

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