#include <RootTree.h>

Public Types
using	BranchMap = roottree::BranchMap

using	EntryNumber = roottree::EntryNumber

Public Member Functions
void	addBranch (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, EntryNumber entryNumber, T &pbuf)

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

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

void	getEntry (TBranch *branch, EntryNumber entry) const

void	init (std::string const &productTreeName, unsigned int maxVirtualSize, unsigned int cacheSize)

void	insertEntryForIndex (unsigned int index)

bool	isValid () const

TTree *	metaTree ()

TTree const *	metaTree () const

bool	next ()

bool	nextWithCache ()

void	numberOfBranchesToAdd (BranchMap::Map::size_type iSize)

RootTree &	operator= (RootTree const &)=delete

std::string const &	processName () const

DelayedReader *	resetAndGetRootDelayedReader () const

void	resetTraining ()

void	rewind ()

void	rewindToInvalid ()

DelayedReader *	rootDelayedReader () const

	RootTree (RootTree const &)=delete

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

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

	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)

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

void	setEntryNumber (EntryNumber theEntryNumber)

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

void	setSignals (signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const preEventReadSource, signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const postEventReadSource)

bool	skipEntries (unsigned int &offset)

void	trainCache (char const *branchNames)

TTree *	tree ()

TTree const *	tree () const

	~RootTree ()

Private Member Functions
void	setCacheSize (unsigned int cacheSize)

void	setTreeMaxVirtualSize (int treeMaxVirtualSize)

void	startTraining ()

void	stopTraining ()

Private Attributes
TBranch *	auxBranch_ = nullptr

TBranch *	branchEntryInfoBranch_ = nullptr

BranchMap	branches_

std::vector< std::string >	branchNames_

BranchType	branchType_

unsigned int	cacheSize_ = 0

bool	enablePrefetching_

bool	enableTriggerCache_

EntryNumber	entries_ = 0

EntryNumber	entryNumber_ = IndexIntoFile::invalidEntry

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

std::shared_ptr< InputFile >	filePtr_

TTree *	infoTree_ = nullptr

unsigned int	learningEntries_

TTree *	metaTree_ = nullptr

bool	performedSwitchOver_ = false

std::string	processName_

std::shared_ptr< TTreeCache >	rawTreeCache_

EntryNumber	rawTriggerSwitchOverEntry_ = -1

std::shared_ptr< TTreeCache >	rawTriggerTreeCache_

std::unique_ptr< RootDelayedReader >	rootDelayedReader_

EntryNumber	switchOverEntry_ = -1

std::unordered_set< TBranch * >	trainedSet_

bool	trainNow_ = false

TTree *	tree_ = nullptr

unsigned long	treeAutoFlush_ = 0

std::shared_ptr< TTreeCache >	treeCache_

std::unordered_set< TBranch * >	triggerSet_

std::shared_ptr< TTreeCache >	triggerTreeCache_

Detailed Description

Definition at line 79 of file RootTree.h.

Member Typedef Documentation

◆ BranchMap

using edm::RootTree::BranchMap = roottree::BranchMap

Definition at line 81 of file RootTree.h.

◆ EntryNumber

using edm::RootTree::EntryNumber = roottree::EntryNumber

Definition at line 82 of file RootTree.h.

Constructor & Destructor Documentation

◆ RootTree() [1/4]

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

Definition at line 30 of file RootTree.cc.

       : filePtr_(filePtr),
         branchType_(branchType),
         entryNumberForIndex_(std::make_unique<std::vector<EntryNumber>>(nIndexes, IndexIntoFile::invalidEntry)),
         learningEntries_(learningEntries),
         enablePrefetching_(enablePrefetching),
         enableTriggerCache_(branchType_ == InEvent),
         rootDelayedReader_(std::make_unique<RootDelayedReader>(*this, filePtr, inputType)) {}

◆ RootTree() [2/4]

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 45 of file RootTree.cc.

       : RootTree(filePtr, branchType, nIndexes, learningEntries, enablePrefetching, inputType) {
     init(BranchTypeToProductTreeName(branchType), maxVirtualSize, cacheSize);
     metaTree_ = dynamic_cast<TTree*>(filePtr_->Get(BranchTypeToMetaDataTreeName(branchType).c_str()));
     auxBranch_ = getAuxiliaryBranch(tree_, branchType_);
     branchEntryInfoBranch_ =
         metaTree_ ? getProductProvenanceBranch(metaTree_, branchType_) : getProductProvenanceBranch(tree_, branchType_);
     infoTree_ =
         dynamic_cast<TTree*>(filePtr->Get(BranchTypeToInfoTreeName(branchType).c_str()));  // backward compatibility
   }

References auxBranch_, branchEntryInfoBranch_, branchType(), branchType_, edm::BranchTypeToInfoTreeName(), edm::BranchTypeToMetaDataTreeName(), edm::BranchTypeToProductTreeName(), filePtr_, infoTree_, init(), metaTree_, and tree_.

◆ RootTree() [3/4]

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

Definition at line 64 of file RootTree.cc.

       : RootTree(filePtr, branchType, nIndexes, learningEntries, enablePrefetching, inputType) {
     processName_ = processName;
     init(BranchTypeToProductTreeName(branchType, processName), maxVirtualSize, cacheSize);
   }

References branchType(), edm::BranchTypeToProductTreeName(), init(), processName(), and processName_.

◆ ~RootTree()

edm::RootTree::~RootTree ( )

Definition at line 111 of file RootTree.cc.

111 {}

◆ RootTree() [4/4]

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

delete

Member Function Documentation

◆ addBranch()

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

Definition at line 156 of file RootTree.cc.

                                                                                         {
     assert(isValid());
     //use the translated branch name
     TBranch* branch = tree_->GetBranch(oldBranchName.c_str());
     roottree::BranchInfo info = roottree::BranchInfo(prod);
     info.productBranch_ = nullptr;
     if (prod.present()) {
       info.productBranch_ = branch;
       //we want the new branch name for the JobReport
       branchNames_.push_back(prod.branchName());
     }
     branches_.insert(prod.branchID(), info);
   }

References cms::cuda::assert(), MicroEventContent_cff::branch, branches_, branchNames_, info(), edm::roottree::BranchMap::insert(), isValid(), dumpMFGeometry_cfg::prod, and tree_.

◆ branchEntryInfoBranch()

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

inline

Definition at line 176 of file RootTree.h.

176 { return branchEntryInfoBranch_; }

References branchEntryInfoBranch_.

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

◆ branches()

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

Definition at line 194 of file RootTree.cc.

194 { return branches_; }

References branches_.

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

◆ branchNames()

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

inline

Definition at line 137 of file RootTree.h.

137 { return branchNames_; }

References branchNames_.

Referenced by edm::RootFile::reportOpened(), and trainCache().

◆ branchType()

BranchType edm::RootTree::branchType ( ) const

inline

Definition at line 184 of file RootTree.h.

184 { return branchType_; }

References branchType_.

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

◆ checkTriggerCache()

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

inline

Definition at line 273 of file RootTree.cc.

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

References MicroEventContent_cff::branch, checkTriggerCacheImpl(), enableTriggerCache_, entryNumber(), trainedSet_, and treeCache_.

Referenced by selectCache().

◆ checkTriggerCacheImpl()

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

Definition at line 283 of file RootTree.cc.

                                                                                             {
     // 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.
       //
       // Guarantee that rawTriggerSwitchOverEntry_ is positive (non-zero) after completion
       // of this if-block.
       TTree::TClusterIterator clusterIter = tree_->GetClusterIterator(entryNumber);
       while ((rawTriggerSwitchOverEntry_ < entryNumber) || (rawTriggerSwitchOverEntry_ <= 0)) {
         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(nullptr);
  
       return rawTriggerTreeCache_.get();
     } else if (!performedSwitchOver_ and 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(nullptr);
       }
       return triggerTreeCache_.get();
     }
  
     // By construction, this case should be impossible.
     assert(false);
     return nullptr;
   }

References cms::cuda::assert(), MicroEventContent_cff::branch, branches(), entryNumber(), entryNumber_, filePtr_, mps_fire::i, performedSwitchOver_, rawTriggerSwitchOverEntry_, rawTriggerTreeCache_, trainedSet_, tree_, triggerSet_, and triggerTreeCache_.

Referenced by checkTriggerCache().

◆ close()

void edm::RootTree::close ( void )

Definition at line 457 of file RootTree.cc.

                        {
     // 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(nullptr);
     // 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();
   }

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

Referenced by esMonitoring.AsyncLineReaderMixin::handle_close(), and esMonitoring.FDJsonServer::handle_close().

◆ current() [1/2]

bool edm::RootTree::current ( ) const

inline

Definition at line 126 of file RootTree.h.

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

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

◆ current() [2/2]

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

inline

Definition at line 127 of file RootTree.h.

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

◆ dropBranch()

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

Definition at line 170 of file RootTree.cc.

                                                           {
     //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;
     }
   }

References beamvalidation::br, MicroEventContent_cff::branch, entries(), mps_fire::i, and tree_.

◆ entries()

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

inline

Definition at line 134 of file RootTree.h.

134 { return entries_; }

References entries_.

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

◆ entryNumber()

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

inline

Definition at line 132 of file RootTree.h.

132 { return entryNumber_; }

References entryNumber_.

Referenced by checkTriggerCache(), checkTriggerCacheImpl(), fillBranchEntry(), fillBranchEntryMeta(), edm::RootFile::fillEventHistory(), edm::RootFile::fillIndexIntoFile(), edm::RootFile::fillThisEventAuxiliary(), getEntry(), edm::RootFileEventFinder::getEventNumberOfEntry(), insertEntryForIndex(), edm::RootFile::readRun_(), and selectCache().

◆ entryNumberForIndex()

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

Definition at line 113 of file RootTree.cc.

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

References cms::cuda::assert(), entryNumberForIndex_, and findQualityFiles::size.

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

◆ fillAux()

template<typename T >

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

inline

Definition at line 141 of file RootTree.h.

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

References auxBranch_, entryNumber_, and getEntry().

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

◆ fillBranchEntry() [1/2]

template<typename T >

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

inline

Definition at line 164 of file RootTree.h.

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

References MicroEventContent_cff::branch, entryNumber(), and getEntry().

◆ fillBranchEntry() [2/2]

template<typename T >

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

inline

Definition at line 147 of file RootTree.h.

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

References MicroEventContent_cff::branch, entryNumber_, and getEntry().

Referenced by edm::RootFile::fillEventHistory(), and edm::RootFile::fillEventToProcessBlockIndexes().

◆ fillBranchEntryMeta()

template<typename T >

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

inline

Definition at line 153 of file RootTree.h.

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

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

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

◆ getEntry()

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

Definition at line 382 of file RootTree.cc.

                                                                         {
     try {
       TTreeCache* cache = selectCache(branch, entryNumber);
       filePtr_->SetCacheRead(cache);
       branch->GetEntry(entryNumber);
       filePtr_->SetCacheRead(nullptr);
     } 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(nullptr);
       Exception t(errors::FileReadError, "", e);
       t.addContext(std::string("Reading branch ") + branch->GetName());
       throw t;
     }
   }

References MicroEventContent_cff::branch, utilities::cache(), MillePedeFileConverter_cfg::e, entryNumber(), filePtr_, edm::errors::FileReadError, selectCache(), AlCaHLTBitMon_QueryRunRegistry::string, and submitPVValidationJobs::t.

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

◆ init()

void edm::RootTree::init	(	std::string const &	productTreeName,
		unsigned int	maxVirtualSize,
		unsigned int	cacheSize
	)

Definition at line 78 of file RootTree.cc.

                                                                                                            {
     if (filePtr_.get() != nullptr) {
       tree_ = dynamic_cast<TTree*>(filePtr_->Get(productTreeName.c_str()));
     }
     if (not tree_) {
       throw cms::Exception("WrongFileFormat")
           << "The ROOT file does not contain a TTree named " << productTreeName
           << "\n This is either not an edm ROOT file or is one that has been corrupted.";
     }
     entries_ = tree_->GetEntries();
  
     // 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_->GetAutoFlush();
     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 (branchType_ == InEvent) {
       Int_t branchCount = tree_->GetListOfBranches()->GetEntriesFast();
       trainedSet_.reserve(branchCount);
       triggerSet_.reserve(branchCount);
     }
   }

References branchType_, entries_, Exception, filePtr_, edm::InEvent, learningEntries_, setCacheSize(), setTreeMaxVirtualSize(), trainedSet_, tree_, treeAutoFlush_, and triggerSet_.

Referenced by RootTree().

◆ insertEntryForIndex()

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

Definition at line 118 of file RootTree.cc.

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

References cms::cuda::assert(), entryNumber(), and findQualityFiles::size.

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

◆ isValid()

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

Definition at line 123 of file RootTree.cc.

                                {
     // ProcessBlock
     if (branchType_ == InProcess) {
       return tree_ != nullptr;
     }
     // Run/Lumi/Event
     if (metaTree_ == nullptr || metaTree_->GetNbranches() == 0) {
       return tree_ != nullptr && auxBranch_ != nullptr;
     }
     // Backward compatibility for Run/Lumi/Event
     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;
   }

References auxBranch_, branchEntryInfoBranch_, branchType_, entries_, infoTree_, edm::InProcess, metaTree_, and tree_.

Referenced by ntupleDataFormat._Object::_checkIsValid(), 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().

◆ metaTree() [1/2]

TTree* edm::RootTree::metaTree ( )

inline

Definition at line 172 of file RootTree.h.

172 { return metaTree_; }

References metaTree_.

◆ metaTree() [2/2]

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

inline

Definition at line 171 of file RootTree.h.

171 { return metaTree_; }

References metaTree_.

Referenced by edm::RootFile::createFileBlock(), and edm::RootFile::updateFileBlock().

◆ next()

bool edm::RootTree::next ( void )

inline

Definition at line 124 of file RootTree.h.

124 { return ++entryNumber_ < entries_; }

References entries_, and entryNumber_.

Referenced by edm::RootFile::fillIndexIntoFile(), and edm::RootFile::initializeDuplicateChecker().

◆ nextWithCache()

bool edm::RootTree::nextWithCache ( )

Definition at line 211 of file RootTree.cc.

                                {
     bool returnValue = ++entryNumber_ < entries_;
     if (returnValue) {
       setEntryNumber(entryNumber_);
     }
     return returnValue;
   }

References entries_, entryNumber_, and setEntryNumber().

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

◆ numberOfBranchesToAdd()

void edm::RootTree::numberOfBranchesToAdd ( BranchMap::Map::size_type iSize )

inline

Definition at line 118 of file RootTree.h.

118 { branches_.reserve(iSize); }

References branches_, and edm::roottree::BranchMap::reserve().

◆ operator=()

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

delete

◆ processName()

std::string const& edm::RootTree::processName ( ) const

inline

Definition at line 185 of file RootTree.h.

185 { return processName_; }

References processName_.

Referenced by edm::RootFile::readProcessBlock_(), and RootTree().

◆ resetAndGetRootDelayedReader()

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

Definition at line 142 of file RootTree.cc.

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

References rootDelayedReader_.

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

◆ resetTraining()

void edm::RootTree::resetTraining ( )

inline

Definition at line 182 of file RootTree.h.

182 { trainNow_ = true; }

References trainNow_.

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

◆ rewind()

void edm::RootTree::rewind ( )

inline

Definition at line 128 of file RootTree.h.

128 { entryNumber_ = 0; }

References entryNumber_.

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

◆ rewindToInvalid()

void edm::RootTree::rewindToInvalid ( )

inline

Definition at line 129 of file RootTree.h.

129 { entryNumber_ = IndexIntoFile::invalidEntry; }

References entryNumber_, and edm::IndexIntoFile::invalidEntry.

◆ rootDelayedReader()

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

Definition at line 147 of file RootTree.cc.

147 { return rootDelayedReader_.get(); }

References rootDelayedReader_.

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

◆ selectCache()

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

inline

Definition at line 364 of file RootTree.cc.

                                                                                          {
     TTreeCache* triggerCache = nullptr;
     if (!treeCache_) {
       return nullptr;
     } 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();
     }
   }

References MicroEventContent_cff::branch, checkTriggerCache(), entryNumber(), rawTreeCache_, trainedSet_, and treeCache_.

Referenced by getEntry().

◆ setCacheSize()

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

private

Definition at line 196 of file RootTree.cc.

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

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

Referenced by init().

◆ setEntryNumber()

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

Definition at line 219 of file RootTree.cc.

                                                           {
     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 < entryNumber_ and theEntryNumber >= 0) {
       //We started reading the file near the end, now we need to correct for the learning length
       if (switchOverEntry_ > tree_->GetEntries()) {
         switchOverEntry_ = switchOverEntry_ - tree_->GetEntries();
         if (rawTreeCache_) {
           rawTreeCache_->SetEntryRange(theEntryNumber, switchOverEntry_);
           rawTreeCache_->FillBuffer();
         }
       }
       if (performedSwitchOver_ and triggerTreeCache_) {
         //We are using the triggerTreeCache_ not the rawTriggerTreeCache_.
         //The triggerTreeCache was originally told to start from an entry further in the file.
         triggerTreeCache_->SetEntryRange(theEntryNumber, tree_->GetEntries());
       } else if (rawTriggerTreeCache_) {
         //move the switch point to the end of the cluster holding theEntryNumber
         rawTriggerSwitchOverEntry_ = -1;
         TTree::TClusterIterator clusterIter = tree_->GetClusterIterator(theEntryNumber);
         while ((rawTriggerSwitchOverEntry_ < theEntryNumber) || (rawTriggerSwitchOverEntry_ <= 0)) {
           rawTriggerSwitchOverEntry_ = clusterIter();
         }
         rawTriggerTreeCache_->SetEntryRange(theEntryNumber, rawTriggerSwitchOverEntry_);
       }
     }
     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(nullptr);
     if (treeCache_ && trainNow_ && entryNumber_ >= 0) {
       startTraining();
       trainNow_ = false;
       trainedSet_.clear();
       triggerSet_.clear();
       rawTriggerSwitchOverEntry_ = -1;
     }
     if (treeCache_ && treeCache_->IsLearning() && switchOverEntry_ >= 0 && entryNumber_ >= switchOverEntry_) {
       stopTraining();
     }
   }

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

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

◆ setPresence()

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

Definition at line 149 of file RootTree.cc.

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

References cms::cuda::assert(), isValid(), dumpMFGeometry_cfg::prod, and tree_.

◆ setSignals()

void edm::RootTree::setSignals	(	signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const *	preEventReadSource,
		signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const *	postEventReadSource
	)

Definition at line 508 of file RootTree.cc.

                                                                                                             {
     rootDelayedReader_->setSignals(preEventReadSource, postEventReadSource);
   }

References rootDelayedReader_.

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

◆ setTreeMaxVirtualSize()

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

private

Definition at line 206 of file RootTree.cc.

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

References tree_.

Referenced by init().

◆ skipEntries()

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

Definition at line 398 of file RootTree.cc.

                                                  {
     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;
   }

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

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

◆ startTraining()

void edm::RootTree::startTraining ( )

private

Definition at line 413 of file RootTree.cc.

                                {
     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(nullptr);
     rawTreeCache_->SetLearnEntries(0);
     switchOverEntry_ = entryNumber_ + learningEntries_;
     auto rawStart = entryNumber_;
     auto rawEnd = switchOverEntry_;
     auto treeStart = switchOverEntry_;
     if (switchOverEntry_ >= tree_->GetEntries()) {
       treeStart = switchOverEntry_ - tree_->GetEntries();
       rawEnd = tree_->GetEntries();
     }
     rawTreeCache_->StartLearningPhase();
     rawTreeCache_->SetEntryRange(rawStart, rawEnd);
     rawTreeCache_->AddBranch("*", kTRUE);
     rawTreeCache_->StopLearningPhase();
     treeCache_->StartLearningPhase();
     treeCache_->SetEntryRange(treeStart, 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_);
   }

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

Referenced by setEntryNumber().

◆ stopTraining()

void edm::RootTree::stopTraining ( )

private

Definition at line 450 of file RootTree.cc.

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

References filePtr_, rawTreeCache_, and treeCache_.

Referenced by setEntryNumber().

◆ trainCache()

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

Definition at line 478 of file RootTree.cc.

                                                    {
     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(nullptr);
  
     if (branchType_ == InEvent) {
       // 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);
         }
       }
     }
   }

References cms::cuda::assert(), MicroEventContent_cff::branch, branches(), branchNames(), branchType_, cacheSize_, filePtr_, mps_fire::i, edm::InEvent, trainedSet_, tree_, and treeCache_.

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

◆ tree() [1/2]

TTree* edm::RootTree::tree ( )

inline

Definition at line 170 of file RootTree.h.

170 { return tree_; }

References 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().

◆ tree() [2/2]

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

inline

Definition at line 169 of file RootTree.h.

169 { return tree_; }

References tree_.

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

Member Data Documentation

◆ auxBranch_

TBranch* edm::RootTree::auxBranch_ = nullptr

private

Definition at line 205 of file RootTree.h.

Referenced by close(), fillAux(), isValid(), and RootTree().

◆ branchEntryInfoBranch_

TBranch* edm::RootTree::branchEntryInfoBranch_ = nullptr

private

Definition at line 234 of file RootTree.h.

Referenced by branchEntryInfoBranch(), close(), isValid(), and RootTree().

◆ branches_

BranchMap edm::RootTree::branches_

private

Definition at line 220 of file RootTree.h.

Referenced by addBranch(), branches(), and numberOfBranchesToAdd().

◆ branchNames_

std::vector<std::string> edm::RootTree::branchNames_

private

Definition at line 219 of file RootTree.h.

Referenced by addBranch(), and branchNames().

◆ branchType_

BranchType edm::RootTree::branchType_

private

Definition at line 203 of file RootTree.h.

Referenced by branchType(), init(), isValid(), RootTree(), startTraining(), and trainCache().

◆ cacheSize_

unsigned int edm::RootTree::cacheSize_ = 0

private

Definition at line 226 of file RootTree.h.

Referenced by setCacheSize(), startTraining(), and trainCache().

◆ enablePrefetching_

bool edm::RootTree::enablePrefetching_

private

Definition at line 230 of file RootTree.h.

Referenced by setCacheSize().

◆ enableTriggerCache_

bool edm::RootTree::enableTriggerCache_

private

Definition at line 231 of file RootTree.h.

Referenced by checkTriggerCache().

◆ entries_

EntryNumber edm::RootTree::entries_ = 0

private

Definition at line 216 of file RootTree.h.

Referenced by entries(), init(), isValid(), next(), nextWithCache(), setEntryNumber(), and skipEntries().

◆ entryNumber_

EntryNumber edm::RootTree::entryNumber_ = IndexIntoFile::invalidEntry

private

Definition at line 217 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), entryNumber(), fillAux(), fillBranchEntry(), next(), nextWithCache(), rewind(), rewindToInvalid(), setEntryNumber(), skipEntries(), and startTraining().

◆ entryNumberForIndex_

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

private

Definition at line 218 of file RootTree.h.

Referenced by entryNumberForIndex().

◆ filePtr_

std::shared_ptr<InputFile> edm::RootTree::filePtr_

private

Definition at line 197 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), close(), getEntry(), init(), RootTree(), setCacheSize(), setEntryNumber(), startTraining(), stopTraining(), and trainCache().

◆ infoTree_

TTree* edm::RootTree::infoTree_ = nullptr

private

Definition at line 236 of file RootTree.h.

Referenced by close(), isValid(), and RootTree().

◆ learningEntries_

unsigned int edm::RootTree::learningEntries_

private

Definition at line 225 of file RootTree.h.

Referenced by init(), and startTraining().

◆ metaTree_

TTree* edm::RootTree::metaTree_ = nullptr

private

Definition at line 202 of file RootTree.h.

Referenced by close(), fillBranchEntryMeta(), isValid(), metaTree(), and RootTree().

◆ performedSwitchOver_

bool edm::RootTree::performedSwitchOver_ = false

mutableprivate

Definition at line 224 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), and setEntryNumber().

◆ processName_

std::string edm::RootTree::processName_

private

Definition at line 204 of file RootTree.h.

Referenced by processName(), and RootTree().

◆ rawTreeCache_

std::shared_ptr<TTreeCache> edm::RootTree::rawTreeCache_

private

Definition at line 210 of file RootTree.h.

Referenced by close(), selectCache(), setCacheSize(), setEntryNumber(), startTraining(), and stopTraining().

◆ rawTriggerSwitchOverEntry_

EntryNumber edm::RootTree::rawTriggerSwitchOverEntry_ = -1

mutableprivate

Definition at line 223 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), and setEntryNumber().

◆ rawTriggerTreeCache_

std::shared_ptr<TTreeCache> edm::RootTree::rawTriggerTreeCache_

mutableprivate

Definition at line 213 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), close(), and setEntryNumber().

◆ rootDelayedReader_

std::unique_ptr<RootDelayedReader> edm::RootTree::rootDelayedReader_

private

Definition at line 232 of file RootTree.h.

Referenced by resetAndGetRootDelayedReader(), rootDelayedReader(), and setSignals().

◆ switchOverEntry_

EntryNumber edm::RootTree::switchOverEntry_ = -1

private

Definition at line 222 of file RootTree.h.

Referenced by setEntryNumber(), and startTraining().

◆ trainedSet_

std::unordered_set<TBranch*> edm::RootTree::trainedSet_

mutableprivate

Definition at line 214 of file RootTree.h.

Referenced by checkTriggerCache(), checkTriggerCacheImpl(), init(), selectCache(), setEntryNumber(), startTraining(), and trainCache().

◆ trainNow_

bool edm::RootTree::trainNow_ = false

private

Definition at line 221 of file RootTree.h.

Referenced by resetTraining(), and setEntryNumber().

◆ tree_

TTree* edm::RootTree::tree_ = nullptr

private

Definition at line 201 of file RootTree.h.

Referenced by addBranch(), checkTriggerCacheImpl(), close(), dropBranch(), init(), isValid(), RootTree(), setCacheSize(), setEntryNumber(), setPresence(), setTreeMaxVirtualSize(), startTraining(), trainCache(), and tree().

◆ treeAutoFlush_

unsigned long edm::RootTree::treeAutoFlush_ = 0

private

Definition at line 227 of file RootTree.h.

Referenced by init(), and setEntryNumber().

◆ treeCache_

std::shared_ptr<TTreeCache> edm::RootTree::treeCache_

private

Definition at line 209 of file RootTree.h.

Referenced by checkTriggerCache(), close(), selectCache(), setCacheSize(), setEntryNumber(), startTraining(), stopTraining(), and trainCache().

◆ triggerSet_

std::unordered_set<TBranch*> edm::RootTree::triggerSet_

mutableprivate

Definition at line 215 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), init(), setEntryNumber(), and startTraining().

◆ triggerTreeCache_

std::shared_ptr<TTreeCache> edm::RootTree::triggerTreeCache_

mutableprivate

Definition at line 212 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), close(), and setEntryNumber().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ BranchMap

◆ EntryNumber

Constructor & Destructor Documentation

◆ RootTree() [1/4]

◆ RootTree() [2/4]

◆ RootTree() [3/4]

◆ ~RootTree()

◆ RootTree() [4/4]

Member Function Documentation

◆ addBranch()

◆ branchEntryInfoBranch()

◆ branches()

◆ branchNames()

◆ branchType()

◆ checkTriggerCache()

◆ checkTriggerCacheImpl()

◆ close()

◆ current() [1/2]

◆ current() [2/2]

◆ dropBranch()

◆ entries()

◆ entryNumber()

◆ entryNumberForIndex()

◆ fillAux()

◆ fillBranchEntry() [1/2]

◆ fillBranchEntry() [2/2]

◆ fillBranchEntryMeta()

◆ getEntry()

◆ init()

◆ insertEntryForIndex()

◆ isValid()

◆ metaTree() [1/2]

◆ metaTree() [2/2]

◆ next()

◆ nextWithCache()

◆ numberOfBranchesToAdd()

◆ operator=()

◆ processName()

◆ resetAndGetRootDelayedReader()

◆ resetTraining()

◆ rewind()

◆ rewindToInvalid()

◆ rootDelayedReader()

◆ selectCache()

◆ setCacheSize()

◆ setEntryNumber()

◆ setPresence()

◆ setSignals()

◆ setTreeMaxVirtualSize()

◆ skipEntries()

◆ startTraining()

◆ stopTraining()

◆ trainCache()

◆ tree() [1/2]

◆ tree() [2/2]

Member Data Documentation

◆ auxBranch_

◆ branchEntryInfoBranch_

◆ branches_

◆ branchNames_

◆ branchType_

◆ cacheSize_

◆ enablePrefetching_

◆ enableTriggerCache_

◆ entries_

◆ entryNumber_

◆ entryNumberForIndex_

◆ filePtr_

◆ infoTree_

◆ learningEntries_

◆ metaTree_

◆ performedSwitchOver_

◆ processName_

◆ rawTreeCache_