#include <RootTree.h>

Public Types
typedef roottree::BranchMap	BranchMap

typedef roottree::EntryNumber	EntryNumber

Public Member Functions
void	addBranch (BranchKey const &key, BranchDescription const &prod, std::string const &oldBranchName)

TBranch *	branchEntryInfoBranch () const

BranchMap const &	branches () const

std::vector< std::string > const &	branchNames () const

BranchType	branchType () const

TTreeCache *	checkTriggerCache (TBranch *branch, EntryNumber entryNumber) const

TTreeCache *	checkTriggerCacheImpl (TBranch *branch, EntryNumber entryNumber) const

void	close ()

bool	current () const

bool	current (EntryNumber entry) const

void	dropBranch (std::string const &oldBranchName)

EntryNumber const &	entries () const

EntryNumber const &	entryNumber () const

EntryNumber const &	entryNumberForIndex (unsigned int index) const

template<typename T >
void	fillAux (T *&pAux)

template<typename T >
void	fillBranchEntry (TBranch branch, T &pbuf)

template<typename T >
void	fillBranchEntry (TBranch branch, EntryNumber entryNumber, T &pbuf)

template<typename T >
void	fillBranchEntryMeta (TBranch branch, T &pbuf)

template<typename T >
void	fillBranchEntryMeta (TBranch branch, EntryNumber entryNumber, T &pbuf)

void	getEntry (TBranch *branch, EntryNumber entry) const

void	insertEntryForIndex (unsigned int index)

bool	isValid () const

TTree const *	metaTree () const

bool	next ()

RootTree &	operator= (RootTree const &)=delete

bool	previous ()

void	resetTraining ()

void	rewind ()

DelayedReader *	rootDelayedReader () const

	RootTree (std::shared_ptr< InputFile > filePtr, BranchType const &branchType, unsigned int nIndexes, unsigned int maxVirtualSize, unsigned int cacheSize, unsigned int learningEntries, bool enablePrefetching, InputType inputType)

	RootTree (RootTree const &)=delete

TTreeCache *	selectCache (TBranch *branch, EntryNumber entryNumber) const

void	setEntryNumber (EntryNumber theEntryNumber)

void	setPresence (BranchDescription &prod, std::string const &oldBranchName)

bool	skipEntries (unsigned int &offset)

void	trainCache (char const *branchNames)

TTree const *	tree () const

TTree *	tree ()

	~RootTree ()

Private Member Functions
void	setCacheSize (unsigned int cacheSize)

void	setTreeMaxVirtualSize (int treeMaxVirtualSize)

void	startTraining ()

void	stopTraining ()

Private Attributes
TBranch *	auxBranch_

TBranch *	branchEntryInfoBranch_

std::shared_ptr< BranchMap >	branches_

std::vector< std::string >	branchNames_

BranchType	branchType_

unsigned int	cacheSize_

bool	enablePrefetching_

bool	enableTriggerCache_

EntryNumber	entries_

EntryNumber	entryNumber_

std::unique_ptr< std::vector < EntryNumber > >	entryNumberForIndex_

std::shared_ptr< InputFile >	filePtr_

TTree *	infoTree_

unsigned int	learningEntries_

TTree *	metaTree_

bool	performedSwitchOver_

std::shared_ptr< TTreeCache >	rawTreeCache_

EntryNumber	rawTriggerSwitchOverEntry_

std::shared_ptr< TTreeCache >	rawTriggerTreeCache_

std::unique_ptr< DelayedReader >	rootDelayedReader_

TBranch *	statusBranch_

EntryNumber	switchOverEntry_

std::unordered_set< TBranch * >	trainedSet_

bool	trainNow_

TTree *	tree_

unsigned long	treeAutoFlush_

std::shared_ptr< TTreeCache >	treeCache_

std::unordered_set< TBranch * >	triggerSet_

std::shared_ptr< TTreeCache >	triggerTreeCache_

Detailed Description

Definition at line 61 of file RootTree.h.

Member Typedef Documentation

typedef roottree::BranchMap edm::RootTree::BranchMap

Definition at line 63 of file RootTree.h.

typedef roottree::EntryNumber edm::RootTree::EntryNumber

Definition at line 64 of file RootTree.h.

Constructor & Destructor Documentation

edm::RootTree::RootTree	(	std::shared_ptr< InputFile >	filePtr,
		BranchType const &	branchType,
		unsigned int	nIndexes,
		unsigned int	maxVirtualSize,
		unsigned int	cacheSize,
		unsigned int	learningEntries,
		bool	enablePrefetching,
		InputType	inputType
	)

Definition at line 28 of file RootTree.cc.

References assert(), cacheSize_, learningEntries_, setCacheSize(), setTreeMaxVirtualSize(), trainedSet_, tree_, treeAutoFlush_, and triggerSet_.

                                           :
     filePtr_(filePtr),
     tree_(dynamic_cast<TTree*>(filePtr_.get() != nullptr ? filePtr_->Get(BranchTypeToProductTreeName(branchType).c_str()) : nullptr)),
     metaTree_(dynamic_cast<TTree*>(filePtr_.get() != nullptr ? filePtr_->Get(BranchTypeToMetaDataTreeName(branchType).c_str()) : nullptr)),
     branchType_(branchType),
     auxBranch_(tree_ ? getAuxiliaryBranch(tree_, branchType_) : nullptr),
     treeCache_(),
     rawTreeCache_(),
     triggerTreeCache_(),
     rawTriggerTreeCache_(),
     trainedSet_(),
     triggerSet_(),
     entries_(tree_ ? tree_->GetEntries() : 0),
     entryNumber_(-1),
     entryNumberForIndex_(new std::vector<EntryNumber>(nIndexes, IndexIntoFile::invalidEntry)),
     branchNames_(),
     branches_(new BranchMap),
     trainNow_(false),
     switchOverEntry_(-1),
     rawTriggerSwitchOverEntry_(-1),
     learningEntries_(learningEntries),
     cacheSize_(cacheSize),
     treeAutoFlush_(0),
     enablePrefetching_(enablePrefetching),
     //enableTriggerCache_(branchType_ == InEvent),
     enableTriggerCache_(false), // Disable, for now. Using the trigger cache in the multithreaded environment causes the assert on line 331 to fire occasionally.
     rootDelayedReader_(new RootDelayedReader(*this, filePtr, inputType)),
     branchEntryInfoBranch_(metaTree_ ? getProductProvenanceBranch(metaTree_, branchType_) : (tree_ ? getProductProvenanceBranch(tree_, branchType_) : 0)),
     infoTree_(dynamic_cast<TTree*>(filePtr_.get() != nullptr ? filePtr->Get(BranchTypeToInfoTreeName(branchType).c_str()) : nullptr)) // backward compatibility
     {
       assert(tree_);
       // On merged files in older releases of ROOT, the autoFlush setting is always negative; we must guess.
       // TODO: On newer merged files, we should be able to get this from the cluster iterator.
       long treeAutoFlush = (tree_ ? tree_->GetAutoFlush() : 0);
       if (treeAutoFlush < 0) {
         // The "+1" is here to avoid divide-by-zero in degenerate cases.
         Long64_t averageEventSizeBytes = tree_->GetZipBytes() / (tree_->GetEntries()+1) + 1;
         treeAutoFlush_ = cacheSize_/averageEventSizeBytes+1;
       } else {
         treeAutoFlush_ = treeAutoFlush;
       }
       if (treeAutoFlush_ < learningEntries_) {
         learningEntries_ = treeAutoFlush_;
       }
       setTreeMaxVirtualSize(maxVirtualSize);
       setCacheSize(cacheSize);
       if (tree_) {
          Int_t branchCount = tree_->GetListOfBranches()->GetEntriesFast();
          trainedSet_.reserve(branchCount);
          triggerSet_.reserve(branchCount);
       }
   }

edm::RootTree::~RootTree ( )

Definition at line 88 of file RootTree.cc.

88 {

89 }

edm::RootTree::RootTree ( RootTree const & )

delete

Member Function Documentation

void edm::RootTree::addBranch	(	BranchKey const &	key,
		BranchDescription const &	prod,
		std::string const &	oldBranchName
	)

Definition at line 130 of file RootTree.cc.

References assert(), branches_, edm::BranchDescription::branchName(), branchNames_, info(), isValid(), metaTree_, edm::BranchDescription::present(), edm::roottree::BranchInfo::productBranch_, edm::roottree::BranchInfo::provenanceBranch_, and tree_.

                                                       {
       assert(isValid());
       //use the translated branch name
       TBranch* branch = tree_->GetBranch(oldBranchName.c_str());
       roottree::BranchInfo info = roottree::BranchInfo(BranchDescription(prod));
       info.productBranch_ = nullptr;
       if (prod.present()) {
         info.productBranch_ = branch;
         //we want the new branch name for the JobReport
         branchNames_.push_back(prod.branchName());
       }
       TTree* provTree = (metaTree_ != nullptr ? metaTree_ : tree_);
       info.provenanceBranch_ = provTree->GetBranch(oldBranchName.c_str());
       branches_->insert(std::make_pair(key, info));
   }

TBranch* edm::RootTree::branchEntryInfoBranch ( ) const

inline

Definition at line 146 of file RootTree.h.

References branchEntryInfoBranch_.

Referenced by edm::FullProvenanceReader::readProvenance(), and edm::OldProvenanceReader::readProvenance().

146 {return branchEntryInfoBranch_;}

edm::RootTree::branchEntryInfoBranch_

TBranch * branchEntryInfoBranch_

Definition: RootTree.h:196

roottree::BranchMap const & edm::RootTree::branches ( ) const

Definition at line 172 of file RootTree.cc.

References branches_.

Referenced by edm::RootDelayedReader::branches(), checkTriggerCacheImpl(), and trainCache().

172 {return *branches_;}

edm::RootTree::branches_

std::shared_ptr< BranchMap > branches_

Definition: RootTree.h:182

std::vector<std::string> const& edm::RootTree::branchNames ( ) const

inline

Definition at line 99 of file RootTree.h.

References branchNames_.

Referenced by edm::RootFile::reportOpened().

99 {return branchNames_;}

edm::RootTree::branchNames_

std::vector< std::string > branchNames_

Definition: RootTree.h:181

BranchType edm::RootTree::branchType ( ) const

inline

Definition at line 154 of file RootTree.h.

References branchType_.

Referenced by edm::RootDelayedReader::getProduct_(), and edm::ReducedProvenanceReader::ReducedProvenanceReader().

154 {return branchType_;}

edm::RootTree::branchType_

BranchType branchType_

Definition: RootTree.h:167

TTreeCache * edm::RootTree::checkTriggerCache	(	TBranch *	branch,
		EntryNumber	entryNumber
	)		const

inline

Definition at line 222 of file RootTree.cc.

References checkTriggerCacheImpl(), enableTriggerCache_, NULL, trainedSet_, and treeCache_.

Referenced by selectCache().

                                                                             {
     if (!treeCache_->IsAsyncReading() && enableTriggerCache_ && (trainedSet_.find(branch) == trainedSet_.end())) {
       return checkTriggerCacheImpl(branch, entryNumber);
     } else {
       return NULL;
     }
   }

TTreeCache * edm::RootTree::checkTriggerCacheImpl	(	TBranch *	branch,
		EntryNumber	entryNumber
	)		const

Definition at line 233 of file RootTree.cc.

References assert(), branches(), entryNumber_, filePtr_, i, NULL, performedSwitchOver_, rawTriggerSwitchOverEntry_, rawTriggerTreeCache_, trainedSet_, tree_, triggerSet_, and triggerTreeCache_.

Referenced by checkTriggerCache().

                                                                                 {
     // This branch is not going to be in the cache.
     // Assume this is a "trigger pattern".
     // Always make sure the branch is added to the trigger set.
     if (triggerSet_.find(branch) == triggerSet_.end()) {
       triggerSet_.insert(branch);
       if (triggerTreeCache_.get()) { triggerTreeCache_->AddBranch(branch, kTRUE); }
     }
 
     if (rawTriggerSwitchOverEntry_ < 0) {
       // The trigger has never fired before.  Take everything not in the
       // trainedSet and load it from disk
 
       // Calculate the end of the next cluster; triggers in the next cluster
       // will use the triggerCache, not the rawTriggerCache.
       TTree::TClusterIterator clusterIter = tree_->GetClusterIterator(entryNumber);
       while (rawTriggerSwitchOverEntry_ < entryNumber) {
         rawTriggerSwitchOverEntry_ = clusterIter();
       }
 
       // ROOT will automatically expand the cache to fit one cluster; hence, we use
       // 5 MB as the cache size below
       tree_->SetCacheSize(static_cast<Long64_t>(5*1024*1024));
       rawTriggerTreeCache_.reset(dynamic_cast<TTreeCache*>(filePtr_->GetCacheRead()));
       if(rawTriggerTreeCache_) rawTriggerTreeCache_->SetEnablePrefetching(false);
       TObjArray *branches = tree_->GetListOfBranches();
       int branchCount = branches->GetEntriesFast();
 
       // Train the rawTriggerCache to have everything not in the regular cache.
       rawTriggerTreeCache_->SetLearnEntries(0);
       rawTriggerTreeCache_->SetEntryRange(entryNumber, rawTriggerSwitchOverEntry_);
       for (int i=0;i<branchCount;i++) {
         TBranch *tmp_branch = (TBranch*)branches->UncheckedAt(i);
         if (trainedSet_.find(tmp_branch) != trainedSet_.end()) {
           continue;
         }
         rawTriggerTreeCache_->AddBranch(tmp_branch, kTRUE);
       }
       performedSwitchOver_ = false;
       rawTriggerTreeCache_->StopLearningPhase();
       filePtr_->SetCacheRead(0);
 
       return rawTriggerTreeCache_.get();
     } else if (entryNumber_ < rawTriggerSwitchOverEntry_) {
       // The raw trigger has fired and it contents are valid.
       return rawTriggerTreeCache_.get();
     } else if (rawTriggerSwitchOverEntry_ > 0) {
       // The raw trigger has fired, but we are out of the cache.  Use the
       // triggerCache instead.
       if (!performedSwitchOver_) {
         rawTriggerTreeCache_.reset();
         performedSwitchOver_ = true;
 
         // Train the triggerCache
         tree_->SetCacheSize(static_cast<Long64_t>(5*1024*1024));
         triggerTreeCache_.reset(dynamic_cast<TTreeCache*>(filePtr_->GetCacheRead()));
         triggerTreeCache_->SetEnablePrefetching(false);
         triggerTreeCache_->SetLearnEntries(0);
         triggerTreeCache_->SetEntryRange(entryNumber, tree_->GetEntries());
         for(std::unordered_set<TBranch*>::const_iterator it = triggerSet_.begin(), itEnd = triggerSet_.end();
             it != itEnd;
             it++)
         {
           triggerTreeCache_->AddBranch(*it, kTRUE);
         }
         triggerTreeCache_->StopLearningPhase();
         filePtr_->SetCacheRead(0);
       }
       return triggerTreeCache_.get();
     } else if (entryNumber_ < rawTriggerSwitchOverEntry_) {
       // The raw trigger has fired and it contents are valid.
       return rawTriggerTreeCache_.get();
     } else if (rawTriggerSwitchOverEntry_ > 0) {
       // The raw trigger has fired, but we are out of the cache.  Use the
       // triggerCache instead.
       if (!performedSwitchOver_) {
         rawTriggerTreeCache_.reset();
         performedSwitchOver_ = true; 
         
         // Train the triggerCache
         tree_->SetCacheSize(static_cast<Long64_t>(5*1024*1024));
         triggerTreeCache_.reset(dynamic_cast<TTreeCache*>(filePtr_->GetCacheRead()));
         triggerTreeCache_->SetEnablePrefetching(false);
         triggerTreeCache_->SetLearnEntries(0);
         triggerTreeCache_->SetEntryRange(entryNumber, tree_->GetEntries());
         for(std::unordered_set<TBranch*>::const_iterator it = triggerSet_.begin(), itEnd = triggerSet_.end();
               it != itEnd;
               it++)
         { 
           triggerTreeCache_->AddBranch(*it, kTRUE);
         }
         triggerTreeCache_->StopLearningPhase();
         filePtr_->SetCacheRead(0);
       }
       return triggerTreeCache_.get();
     }
 
     // By construction, this case should be impossible.
     assert (false);
     return NULL;
   }

void edm::RootTree::close ( void )

Definition at line 427 of file RootTree.cc.

References auxBranch_, branchEntryInfoBranch_, filePtr_, infoTree_, metaTree_, rawTreeCache_, rawTriggerTreeCache_, tree_, treeCache_, and triggerTreeCache_.

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

                    {
     // The TFile is about to be closed, and destructed.
     // Just to play it safe, zero all pointers to quantities that are owned by the TFile.
     auxBranch_  = branchEntryInfoBranch_ = nullptr;
     tree_ = metaTree_ = infoTree_ = nullptr;
     // We own the treeCache_.
     // We make sure the treeCache_ is detached from the file,
     // so that ROOT does not also delete it.
     filePtr_->SetCacheRead(0);
     // We *must* delete the TTreeCache here because the TFilePrefetch object
     // references the TFile.  If TFile is closed, before the TTreeCache is
     // deleted, the TFilePrefetch may continue to do TFile operations, causing
     // deadlocks or exceptions.
     treeCache_.reset();
     rawTreeCache_.reset();
     triggerTreeCache_.reset();
     rawTriggerTreeCache_.reset();
     // We give up our shared ownership of the TFile itself.
     filePtr_.reset();
   }

bool edm::RootTree::current ( ) const

inline

Definition at line 89 of file RootTree.h.

Referenced by edm::RootFile::fillEventAuxiliary(), edm::RootFile::readCurrentEvent(), edm::RootFile::readLuminosityBlockAuxiliary_(), and edm::RootFile::readRunAuxiliary_().

89 {return entryNumber_ < entries_ && entryNumber_ >= 0;}

bool edm::RootTree::current ( EntryNumber entry ) const

inline

Definition at line 90 of file RootTree.h.

90 {return entry < entries_ && entry >= 0;}

void edm::RootTree::dropBranch ( std::string const & oldBranchName )

Definition at line 149 of file RootTree.cc.

References beamvalidation::br, entries(), i, python.Node::leaf, and tree_.

                                                      {
       //use the translated branch name
       TBranch* branch = tree_->GetBranch(oldBranchName.c_str());
       if (branch != nullptr) {
         TObjArray* leaves = tree_->GetListOfLeaves();
         int entries = leaves->GetEntries();
         for (int i = 0; i < entries; ++i) {
           TLeaf* leaf = (TLeaf*)(*leaves)[i];
           if (leaf == nullptr) continue;
           TBranch* br = leaf->GetBranch();
           if (br == nullptr) continue;
           if (br->GetMother() == branch) {
             leaves->Remove(leaf);
           }
         }
         leaves->Compress();
         tree_->GetListOfBranches()->Remove(branch);
         tree_->GetListOfBranches()->Compress();
         delete branch;
       }
   }

EntryNumber const& edm::RootTree::entries ( ) const

inline

Definition at line 96 of file RootTree.h.

References entries_.

Referenced by dropBranch(), edm::RootFile::fillIndexIntoFile(), edm::RootFile::setIfFastClonable(), and edm::RootFile::validateFile().

96 {return entries_;}

edm::RootTree::entries_

EntryNumber entries_

Definition: RootTree.h:178

EntryNumber const& edm::RootTree::entryNumber ( ) const

inline

Definition at line 94 of file RootTree.h.

References entryNumber_.

Referenced by fillBranchEntryMeta(), edm::RootFile::fillEventHistory(), edm::RootFile::fillIndexIntoFile(), edm::RootFile::fillThisEventAuxiliary(), edm::RootFileEventFinder::getEventNumberOfEntry(), and insertEntryForIndex().

94 {return entryNumber_;}

edm::RootTree::entryNumber_

EntryNumber entryNumber_

Definition: RootTree.h:179

RootTree::EntryNumber const & edm::RootTree::entryNumberForIndex ( unsigned int index ) const

Definition at line 92 of file RootTree.cc.

References assert(), entryNumberForIndex_, cmsHarvester::index, and findQualityFiles::size.

Referenced by edm::RootDelayedReader::getProduct_(), edm::ReducedProvenanceReader::readProvenance(), edm::FullProvenanceReader::readProvenance(), and edm::OldProvenanceReader::readProvenance().

                                                         {
     assert(index < entryNumberForIndex_->size());
     return (*entryNumberForIndex_)[index];
   }

template<typename T >

void edm::RootTree::fillAux ( T *& pAux )

inline

Definition at line 102 of file RootTree.h.

References auxBranch_, entryNumber_, and getEntry().

Referenced by edm::RootFile::fillLumiAuxiliary(), edm::RootFile::fillRunAuxiliary(), edm::RootFile::fillThisEventAuxiliary(), and edm::RootFileEventFinder::getEventNumberOfEntry().

                            {
       auxBranch_->SetAddress(&pAux);
       getEntry(auxBranch_, entryNumber_);
     }

template<typename T >

void edm::RootTree::fillBranchEntry	(	TBranch *	branch,
		T *&	pbuf
	)

inline

Definition at line 118 of file RootTree.h.

References entryNumber_, and getEntry().

Referenced by edm::RootFile::fillEventHistory(), and edm::ReducedProvenanceReader::readProvenance().

                                                     {
       branch->SetAddress(&pbuf);
       getEntry(branch, entryNumber_);
     }

template<typename T >

void edm::RootTree::fillBranchEntry	(	TBranch *	branch,
		EntryNumber	entryNumber,
		T *&	pbuf
	)

inline

Definition at line 135 of file RootTree.h.

References getEntry().

                                                                              {
       branch->SetAddress(&pbuf);
       getEntry(branch, entryNumber);
     }

template<typename T >

void edm::RootTree::fillBranchEntryMeta	(	TBranch *	branch,
		T *&	pbuf
	)

inline

Definition at line 107 of file RootTree.h.

References entryNumber_, edm::roottree::getEntry(), and metaTree_.

Referenced by edm::FullProvenanceReader::readProvenance().

                                                         {
       if (metaTree_ != nullptr) {
         // Metadata was in separate tree.  Not cached.
         branch->SetAddress(&pbuf);
         roottree::getEntry(branch, entryNumber_);
       } else {
         fillBranchEntry<T>(branch, pbuf);
       }
     }

template<typename T >

void edm::RootTree::fillBranchEntryMeta	(	TBranch *	branch,
		EntryNumber	entryNumber,
		T *&	pbuf
	)

inline

Definition at line 124 of file RootTree.h.

References entryNumber(), edm::roottree::getEntry(), and metaTree_.

                                                                                  {
       if (metaTree_ != nullptr) {
         // Metadata was in separate tree.  Not cached.
         branch->SetAddress(&pbuf);
         roottree::getEntry(branch, entryNumber);
       } else {
         fillBranchEntry<T>(branch, entryNumber, pbuf);
       }
     }

void edm::RootTree::getEntry	(	TBranch *	branch,
		EntryNumber	entry
	)		const

Definition at line 355 of file RootTree.cc.

References cms::Exception::addContext(), alignCSCRings::e, filePtr_, edm::errors::FileReadError, selectCache(), AlCaHLTBitMon_QueryRunRegistry::string, and tree::t.

Referenced by fillAux(), fillBranchEntry(), and edm::RootDelayedReader::getProduct_().

                                                                    {
     try {
       TTreeCache * cache = selectCache(branch, entryNumber);
       filePtr_->SetCacheRead(cache);
       branch->GetEntry(entryNumber);
       filePtr_->SetCacheRead(0);
     } catch(cms::Exception const& e) {
       // We make sure the treeCache_ is detached from the file,
       // so that ROOT does not also delete it.
       filePtr_->SetCacheRead(0);
       Exception t(errors::FileReadError, "", e);
       t.addContext(std::string("Reading branch ")+branch->GetName());
       throw t;
     }
   }

void edm::RootTree::insertEntryForIndex ( unsigned int index )

Definition at line 98 of file RootTree.cc.

References assert(), entryNumber(), cmsHarvester::index, and findQualityFiles::size.

Referenced by edm::RootFile::readCurrentEvent(), edm::RootFile::readLuminosityBlock_(), and edm::RootFile::readRun_().

                                                   {
     assert(index < entryNumberForIndex_->size());
     (*entryNumberForIndex_)[index] = entryNumber();
   }

bool edm::RootTree::isValid ( void ) const

Definition at line 104 of file RootTree.cc.

References auxBranch_, branchEntryInfoBranch_, entries_, infoTree_, metaTree_, and tree_.

Referenced by addBranch(), edm::RootFile::fillIndexIntoFile(), edm::RootFile::readLuminosityBlock_(), edm::RootFile::readLuminosityBlockAuxiliary_(), edm::RootFile::readRun_(), edm::RootFile::readRunAuxiliary_(), core.AutoHandle.AutoHandle::ReallyLoad(), setPresence(), and edm::RootFile::validateFile().

                           {
     if (metaTree_ == nullptr || metaTree_->GetNbranches() == 0) {
       return tree_ != nullptr && auxBranch_ != nullptr;
     }
     if (tree_ != nullptr && auxBranch_ != nullptr && metaTree_ != nullptr) { // backward compatibility
       if (branchEntryInfoBranch_ != nullptr || infoTree_ != nullptr) return true; // backward compatibility
       return (entries_ == metaTree_->GetEntries() && tree_->GetNbranches() <= metaTree_->GetNbranches() + 1);  // backward compatibility
     } // backward compatibility
     return false;
   }

TTree const* edm::RootTree::metaTree ( ) const

inline

Definition at line 142 of file RootTree.h.

References metaTree_.

Referenced by edm::RootFile::createFileBlock().

142 {return metaTree_;}

edm::RootTree::metaTree_

TTree * metaTree_

Definition: RootTree.h:166

bool edm::RootTree::next ( void )

inline

Definition at line 87 of file RootTree.h.

References entries_, and entryNumber_.

Referenced by BeautifulSoup.PageElement::_invert(), edm::RootFile::fillIndexIntoFile(), edm::RootFile::initializeDuplicateChecker(), and edm::RootFile::nextEventEntry().

87 {return ++entryNumber_ < entries_;}

edm::RootTree::entryNumber_

EntryNumber entryNumber_

Definition: RootTree.h:179

edm::RootTree::entries_

EntryNumber entries_

Definition: RootTree.h:178

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

delete

bool edm::RootTree::previous ( )

inline

Definition at line 88 of file RootTree.h.

References entryNumber_.

Referenced by BeautifulSoup.PageElement::_invert().

88 {return --entryNumber_ >= 0;}

edm::RootTree::entryNumber_

EntryNumber entryNumber_

Definition: RootTree.h:179

void edm::RootTree::resetTraining ( )

inline

Definition at line 152 of file RootTree.h.

References trainNow_.

Referenced by edm::RootFile::RootFile().

152 {trainNow_ = true;}

edm::RootTree::trainNow_

bool trainNow_

Definition: RootTree.h:183

void edm::RootTree::rewind ( )

inline

Definition at line 91 of file RootTree.h.

References entryNumber_.

Referenced by edm::RootFile::rewind().

91 {entryNumber_ = 0;}

edm::RootTree::entryNumber_

EntryNumber entryNumber_

Definition: RootTree.h:179

DelayedReader * edm::RootTree::rootDelayedReader ( ) const

Definition at line 116 of file RootTree.cc.

References rootDelayedReader_.

Referenced by edm::RootFile::readCurrentEvent(), edm::RootFile::readLuminosityBlock_(), and edm::RootFile::readRun_().

                                     {
     rootDelayedReader_->reset();
     return rootDelayedReader_.get();
   }  

TTreeCache * edm::RootTree::selectCache	(	TBranch *	branch,
		EntryNumber	entryNumber
	)		const

inline

Definition at line 336 of file RootTree.cc.

References checkTriggerCache(), NULL, rawTreeCache_, trainedSet_, and treeCache_.

Referenced by getEntry().

                                                                       {
     TTreeCache *triggerCache = NULL;
     if (!treeCache_) {
       return NULL;
     } else if (treeCache_->IsLearning() && rawTreeCache_) {
       treeCache_->AddBranch(branch, kTRUE);
       trainedSet_.insert(branch);
       return rawTreeCache_.get();
     } else if ((triggerCache = checkTriggerCache(branch, entryNumber))) {
       // A NULL return value from checkTriggerCache indicates the trigger cache case
       // does not apply, and we should continue below.
       return triggerCache;
     } else {
       // The "normal" TTreeCache case.
       return treeCache_.get();
     }
   }

void edm::RootTree::setCacheSize ( unsigned int cacheSize )

private

Definition at line 175 of file RootTree.cc.

References cacheSize_, enablePrefetching_, filePtr_, rawTreeCache_, tree_, and treeCache_.

Referenced by RootTree().

                                                {
     cacheSize_ = cacheSize;
     tree_->SetCacheSize(static_cast<Long64_t>(cacheSize));
     treeCache_.reset(dynamic_cast<TTreeCache*>(filePtr_->GetCacheRead()));
     if(treeCache_) treeCache_->SetEnablePrefetching(enablePrefetching_);
     filePtr_->SetCacheRead(0);
     rawTreeCache_.reset();
   }

void edm::RootTree::setEntryNumber ( EntryNumber theEntryNumber )

Definition at line 190 of file RootTree.cc.

References entries_, entryNumber_, filePtr_, rawTriggerSwitchOverEntry_, startTraining(), stopTraining(), switchOverEntry_, trainedSet_, trainNow_, tree_, treeAutoFlush_, treeCache_, and triggerSet_.

Referenced by edm::RootFile::fillEventAuxiliary(), edm::RootFile::fillIndexIntoFile(), edm::RootFileEventFinder::getEventNumberOfEntry(), edm::RootFile::initializeDuplicateChecker(), edm::RootFile::readLuminosityBlock_(), edm::RootFile::readLuminosityBlockAuxiliary_(), edm::RootFile::readRunAuxiliary_(), edm::RootFile::setAtEventEntry(), edm::RootFile::setEntryAtEvent(), edm::RootFile::setEntryAtLumi(), and edm::RootFile::setEntryAtRun().

                                                      {
     filePtr_->SetCacheRead(treeCache_.get());
 
     // Detect a backward skip.  If the skip is sufficiently large, we roll the dice and reset the treeCache.
     // This will cause some amount of over-reading: we pre-fetch all the events in some prior cluster.
     // However, because reading one event in the cluster is supposed to be equivalent to reading all events in the cluster,
     // we're not incurring additional over-reading - we're just doing it more efficiently.
     // NOTE: Constructor guarantees treeAutoFlush_ is positive, even if TTree->GetAutoFlush() is negative.
     if ((theEntryNumber < static_cast<EntryNumber>(entryNumber_-treeAutoFlush_)) &&
         (treeCache_) && (!treeCache_->IsLearning()) && (entries_ > 0) && (switchOverEntry_ >= 0)) {
       treeCache_->SetEntryRange(theEntryNumber, entries_);
       treeCache_->FillBuffer();
     }
 
     entryNumber_ = theEntryNumber;
     tree_->LoadTree(entryNumber_);
     filePtr_->SetCacheRead(0);
     if(treeCache_ && trainNow_ && entryNumber_ >= 0) {
       startTraining();
       trainNow_ = false;
       trainedSet_.clear();
       triggerSet_.clear();
       rawTriggerSwitchOverEntry_ = -1;
     }
     if (treeCache_ && treeCache_->IsLearning() && switchOverEntry_ >= 0 && entryNumber_ >= switchOverEntry_) {
       stopTraining();
     }
   }

void edm::RootTree::setPresence	(	BranchDescription &	prod,
		std::string const &	oldBranchName
	)

Definition at line 122 of file RootTree.cc.

References assert(), isValid(), edm::BranchDescription::setDropped(), and tree_.

                                                                                {
       assert(isValid());
       if(tree_->GetBranch(oldBranchName.c_str()) == nullptr){
         prod.setDropped(true);
       }
   }

void edm::RootTree::setTreeMaxVirtualSize ( int treeMaxVirtualSize )

private

Definition at line 185 of file RootTree.cc.

References tree_.

Referenced by RootTree().

                                                         {
     if (treeMaxVirtualSize >= 0) tree_->SetMaxVirtualSize(static_cast<Long64_t>(treeMaxVirtualSize));
   }

bool edm::RootTree::skipEntries ( unsigned int & offset )

Definition at line 372 of file RootTree.cc.

References entries_, entryNumber_, and hltrates_dqm_sourceclient-live_cfg::offset.

Referenced by edm::RootFile::skipEntries().

                                             {
     entryNumber_ += offset;
     bool retval = (entryNumber_ < entries_);
     if(retval) {
       offset = 0;
     } else {
       // Not enough entries in the file to skip.
       // The +1 is needed because entryNumber_ is -1 at the initialization of the tree, not 0.
       long long overshoot = entryNumber_ + 1 - entries_;
       entryNumber_ = entries_;
       offset = overshoot;
     }
     return retval;
   }

void edm::RootTree::startTraining ( )

private

Definition at line 388 of file RootTree.cc.

References assert(), edm::poolNames::branchListIndexesBranchName(), branchType_, edm::BranchTypeToAuxiliaryBranchName(), cacheSize_, entryNumber_, filePtr_, edm::InEvent, learningEntries_, rawTreeCache_, switchOverEntry_, trainedSet_, tree_, treeCache_, and triggerSet_.

Referenced by setEntryNumber().

                           {
     if (cacheSize_ == 0) {
       return;
     }
     assert(treeCache_);
     assert(branchType_ == InEvent);
     assert(!rawTreeCache_);
     treeCache_->SetLearnEntries(learningEntries_);
     tree_->SetCacheSize(static_cast<Long64_t>(cacheSize_));
     rawTreeCache_.reset(dynamic_cast<TTreeCache *>(filePtr_->GetCacheRead()));
     rawTreeCache_->SetEnablePrefetching(false);
     filePtr_->SetCacheRead(0);
     rawTreeCache_->SetLearnEntries(0);
     switchOverEntry_ = entryNumber_ + learningEntries_;
     rawTreeCache_->StartLearningPhase();
     rawTreeCache_->SetEntryRange(entryNumber_, switchOverEntry_);
     rawTreeCache_->AddBranch("*", kTRUE);
     rawTreeCache_->StopLearningPhase();
     treeCache_->StartLearningPhase();
     treeCache_->SetEntryRange(switchOverEntry_, tree_->GetEntries());
     // Make sure that 'branchListIndexes' branch exist in input file
     if (filePtr_->Get(poolNames::branchListIndexesBranchName().c_str()) != nullptr) {
       treeCache_->AddBranch(poolNames::branchListIndexesBranchName().c_str(), kTRUE);
     }
     treeCache_->AddBranch(BranchTypeToAuxiliaryBranchName(branchType_).c_str(), kTRUE);
     trainedSet_.clear();
     triggerSet_.clear();
     assert(treeCache_->GetTree() == tree_);
   }

void edm::RootTree::stopTraining ( )

private

Definition at line 419 of file RootTree.cc.

References filePtr_, rawTreeCache_, and treeCache_.

Referenced by setEntryNumber().

                          {
     filePtr_->SetCacheRead(treeCache_.get());
     treeCache_->StopLearningPhase();
     filePtr_->SetCacheRead(0);
     rawTreeCache_.reset();
   }

void edm::RootTree::trainCache ( char const * branchNames )

Definition at line 449 of file RootTree.cc.

References assert(), branches(), cacheSize_, filePtr_, i, trainedSet_, tree_, and treeCache_.

Referenced by edm::RootFile::RootFile().

                                               {
     if (cacheSize_ == 0) {
       return;
     }
     tree_->LoadTree(0);
     assert(treeCache_);
     filePtr_->SetCacheRead(treeCache_.get());
     treeCache_->StartLearningPhase();
     treeCache_->SetEntryRange(0, tree_->GetEntries());
     treeCache_->AddBranch(branchNames, kTRUE);
     treeCache_->StopLearningPhase();
     assert(treeCache_->GetTree() == tree_);
     // We own the treeCache_.
     // We make sure the treeCache_ is detached from the file,
     // so that ROOT does not also delete it.
     filePtr_->SetCacheRead(0);
 
     // Must also manually add things to the trained set.
     TObjArray *branches = tree_->GetListOfBranches();
     int branchCount = branches->GetEntriesFast();
     for (int i=0;i<branchCount;i++) {
        TBranch *branch = (TBranch*)branches->UncheckedAt(i);
        if ((branchNames[0] == '*') || (strcmp(branchNames, branch->GetName()) == 0)) {
           trainedSet_.insert(branch);
        } 
     } 
  
   }