edm::RootTree Class Reference

#include <RootTree.h>

Public Types
typedef roottree::BranchMap	BranchMap
typedef roottree::EntryNumber	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, 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 ()
bool	nextWithCache ()
void	numberOfBranchesToAdd (size_t iSize)
RootTree &	operator= (RootTree const &)=delete
bool	previous ()
DelayedReader *	resetAndGetRootDelayedReader () const
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)
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 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_
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< RootDelayedReader >	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 101 of file RootTree.h.

Member Typedef Documentation

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

Definition at line 103 of file RootTree.h.

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

Definition at line 104 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 branchEntryInfoBranch_, branchType_, edm::BranchTypeToInfoTreeName(), edm::BranchTypeToProductTreeName(), cacheSize_, enablePrefetching_, enableTriggerCache_, Exception, filePtr_, edm::InEvent, infoTree_, learningEntries_, metaTree_, performedSwitchOver_, rawTriggerSwitchOverEntry_, rootDelayedReader_, setCacheSize(), setTreeMaxVirtualSize(), switchOverEntry_, trainedSet_, trainNow_, 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_{},
        trainNow_(false),
        switchOverEntry_(-1),
        rawTriggerSwitchOverEntry_(-1),
        performedSwitchOver_{false},
        learningEntries_(learningEntries),
        cacheSize_(cacheSize),
        treeAutoFlush_(0),
        enablePrefetching_(enablePrefetching),
        enableTriggerCache_(branchType_ == InEvent),
        rootDelayedReader_(new RootDelayedReader(*this, filePtr, inputType)),
        branchEntryInfoBranch_(metaTree_ ? getProductProvenanceBranch(metaTree_, branchType_)
                                         : (tree_ ? getProductProvenanceBranch(tree_, branchType_) : nullptr)),
        infoTree_(dynamic_cast<TTree*>(filePtr_.get() != nullptr
                                           ? filePtr->Get(BranchTypeToInfoTreeName(branchType).c_str())
                                           : nullptr))  // backward compatibility
  {
    if (not tree_) {
      throw cms::Exception("WrongFileFormat")
          << "The ROOT file does not contain a TTree named " << BranchTypeToProductTreeName(branchType)
          << "\n This is either not an edm ROOT file or is one that has been corrupted.";
    }
    // 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 97 of file RootTree.cc.

{}

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

delete

Member Function Documentation

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

Definition at line 136 of file RootTree.cc.

References MicroEventContent_cff::branch, branches_, edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), branchNames_, info(), edm::roottree::BranchMap::insert(), 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(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(prod.branchID(), info);
  }

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

inline

Definition at line 186 of file RootTree.h.

References edm::roottree::trainCache().

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

{ return branchEntryInfoBranch_; }

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

(

)

const

Definition at line 176 of file RootTree.cc.

References branches_.

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

{ return branches_; }

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

inline

Definition at line 138 of file RootTree.h.

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

{ return branchNames_; }

BranchType edm::RootTree::branchType ( ) const

inline

Definition at line 194 of file RootTree.h.

Referenced by edm::RootDelayedReader::getProduct_().

{ return branchType_; }

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

inline

Definition at line 255 of file RootTree.cc.

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

Referenced by selectCache().

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

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

Definition at line 265 of file RootTree.cc.

References branches(), entryNumber_, filePtr_, mps_fire::i, 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.
      //
      // 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;
  }

void edm::RootTree::close

(

void

)

Definition at line 439 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(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();
  }

bool edm::RootTree::current ( ) const

inline

Definition at line 128 of file RootTree.h.

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

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

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

inline

Definition at line 129 of file RootTree.h.

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

void edm::RootTree::dropBranch

(

std::string const &

oldBranchName

)

Definition at line 152 of file RootTree.cc.

References beamvalidation::br, MicroEventContent_cff::branch, entries(), mps_fire::i, 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 135 of file RootTree.h.

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

{ return entries_; }

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

inline

Definition at line 133 of file RootTree.h.

Referenced by edm::RootFile::fillEventHistory(), edm::RootFile::fillIndexIntoFile(), edm::RootFile::fillThisEventAuxiliary(), insertEntryForIndex(), and edm::RootFile::readRun_().

{ return entryNumber_; }

RootTree::EntryNumber const & edm::RootTree::entryNumberForIndex

(

unsigned int

index

)

const

Definition at line 99 of file RootTree.cc.

References entryNumberForIndex_, and findQualityFiles::size.

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

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

template<typename T >

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

inline

Definition at line 142 of file RootTree.h.

References edm::roottree::getEntry().

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

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

template<typename T >

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

inline

Definition at line 158 of file RootTree.h.

References edm::roottree::getEntry().

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

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

template<typename T >

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

inline

Definition at line 175 of file RootTree.h.

References edm::roottree::getEntry().

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

template<typename T >

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

inline

Definition at line 147 of file RootTree.h.

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

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 164 of file RootTree.h.

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

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

References cms::Exception::addContext(), utilities::cache(), MillePedeFileConverter_cfg::e, filePtr_, edm::errors::FileReadError, selectCache(), AlCaHLTBitMon_QueryRunRegistry::string, and lumiQTWidget::t.

Referenced by edm::RootDelayedReader::getProduct_().

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

void edm::RootTree::insertEntryForIndex

(

unsigned int

index

)

Definition at line 104 of file RootTree.cc.

References entryNumber(), 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 109 of file RootTree.cc.

References auxBranch_, branchEntryInfoBranch_, entries_, infoTree_, 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().

                               {
    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 182 of file RootTree.h.

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

{ return metaTree_; }

bool edm::RootTree::next ( void  )

inline

Definition at line 125 of file RootTree.h.

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

{ return ++entryNumber_ < entries_; }

bool edm::RootTree::nextWithCache

(

)

Definition at line 193 of file RootTree.cc.

References entries_, entryNumber_, and setEntryNumber().

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

void edm::RootTree::numberOfBranchesToAdd ( size_t  iSize )

inline

Definition at line 119 of file RootTree.h.

References MicroEventContent_cff::branch, mps_splice::entry, edm::roottree::getEntry(), parseEventContent::prod, and AlCaHLTBitMon_QueryRunRegistry::string.

{ branches_.reserve(iSize); }

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

delete

bool edm::RootTree::previous ( )

inline

Definition at line 127 of file RootTree.h.

{ return --entryNumber_ >= 0; }

DelayedReader * edm::RootTree::resetAndGetRootDelayedReader

(

)

const

Definition at line 122 of file RootTree.cc.

References rootDelayedReader_.

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

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

void edm::RootTree::resetTraining ( )

inline

Definition at line 192 of file RootTree.h.

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

{ trainNow_ = true; }

void edm::RootTree::rewind ( )

inline

Definition at line 130 of file RootTree.h.

References PFRecoTauDiscriminationByIsolation_cfi::offset.

{ entryNumber_ = 0; }

DelayedReader * edm::RootTree::rootDelayedReader

(

)

const

Definition at line 127 of file RootTree.cc.

References rootDelayedReader_.

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

{ return rootDelayedReader_.get(); }

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

inline

Definition at line 346 of file RootTree.cc.

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

Referenced by getEntry().

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

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

private

Definition at line 178 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(nullptr);
    rawTreeCache_.reset();
  }

void edm::RootTree::setEntryNumber

(

EntryNumber

theEntryNumber

)

Definition at line 201 of file RootTree.cc.

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

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

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

Definition at line 129 of file RootTree.cc.

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

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

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

References rootDelayedReader_.

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

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

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

private

Definition at line 188 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 380 of file RootTree.cc.

References entries_, entryNumber_, and PFRecoTauDiscriminationByIsolation_cfi::offset.

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

References 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(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_);
  }

void edm::RootTree::stopTraining ( )

private

Definition at line 432 of file RootTree.cc.

References filePtr_, rawTreeCache_, and treeCache_.

Referenced by setEntryNumber().

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

void edm::RootTree::trainCache

(

char const *

branchNames

)

Definition at line 460 of file RootTree.cc.

References branches(), cacheSize_, filePtr_, mps_fire::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(nullptr);

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

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

inline

Definition at line 180 of file RootTree.h.

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(), and python.cmstools.EventTree::SetAlias().

{ return tree_; }

TTree* edm::RootTree::tree ( )

inline

Definition at line 181 of file RootTree.h.

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

{ return tree_; }

Member Data Documentation

TBranch* edm::RootTree::auxBranch_

private

Definition at line 213 of file RootTree.h.

Referenced by close(), and isValid().

TBranch* edm::RootTree::branchEntryInfoBranch_

private

Definition at line 241 of file RootTree.h.

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

BranchMap edm::RootTree::branches_

private

Definition at line 227 of file RootTree.h.

Referenced by addBranch(), and branches().

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

private

Definition at line 226 of file RootTree.h.

Referenced by addBranch().

BranchType edm::RootTree::branchType_

private

Definition at line 212 of file RootTree.h.

Referenced by RootTree(), and startTraining().

unsigned int edm::RootTree::cacheSize_

private

Definition at line 233 of file RootTree.h.

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

bool edm::RootTree::enablePrefetching_

private

Definition at line 237 of file RootTree.h.

Referenced by RootTree(), and setCacheSize().

bool edm::RootTree::enableTriggerCache_

private

Definition at line 238 of file RootTree.h.

Referenced by checkTriggerCache(), and RootTree().

EntryNumber edm::RootTree::entries_

private

Definition at line 223 of file RootTree.h.

Referenced by isValid(), nextWithCache(), setEntryNumber(), and skipEntries().

EntryNumber edm::RootTree::entryNumber_

private

Definition at line 224 of file RootTree.h.

Referenced by checkTriggerCacheImpl(), nextWithCache(), setEntryNumber(), skipEntries(), and startTraining().

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

private

Definition at line 225 of file RootTree.h.

Referenced by entryNumberForIndex().

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

private

Definition at line 206 of file RootTree.h.

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

TTree* edm::RootTree::infoTree_

private

Definition at line 243 of file RootTree.h.

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

unsigned int edm::RootTree::learningEntries_

private

Definition at line 232 of file RootTree.h.

Referenced by RootTree(), and startTraining().

TTree* edm::RootTree::metaTree_

private

Definition at line 211 of file RootTree.h.

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

bool edm::RootTree::performedSwitchOver_

mutableprivate

Definition at line 231 of file RootTree.h.

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

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

private

Definition at line 218 of file RootTree.h.

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

EntryNumber edm::RootTree::rawTriggerSwitchOverEntry_

mutableprivate

Definition at line 230 of file RootTree.h.

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

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

mutableprivate

Definition at line 220 of file RootTree.h.

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

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

private

Definition at line 239 of file RootTree.h.

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

TBranch* edm::RootTree::statusBranch_

private

Definition at line 244 of file RootTree.h.

EntryNumber edm::RootTree::switchOverEntry_

private

Definition at line 229 of file RootTree.h.

Referenced by RootTree(), setEntryNumber(), and startTraining().

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

mutableprivate

Definition at line 221 of file RootTree.h.

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

bool edm::RootTree::trainNow_

private

Definition at line 228 of file RootTree.h.

Referenced by RootTree(), and setEntryNumber().

TTree* edm::RootTree::tree_

private

Definition at line 210 of file RootTree.h.

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

unsigned long edm::RootTree::treeAutoFlush_

private

Definition at line 234 of file RootTree.h.

Referenced by RootTree(), and setEntryNumber().

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

private

Definition at line 217 of file RootTree.h.

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

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

mutableprivate

Definition at line 222 of file RootTree.h.

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

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

mutableprivate

Definition at line 219 of file RootTree.h.

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