#include <IndexIntoFile.h>

Inheritance diagram for edm::IndexIntoFile::IndexIntoFileItrEntryOrder:

Classes
class	EntryOrderInitializationInfo

struct	TTreeEntryAndIndex

Public Member Functions
IndexIntoFileItrImpl *	clone () const override

EntryNumber_t	entry () const override

int	indexedSize () const override

	IndexIntoFileItrEntryOrder (IndexIntoFile const *indexIntoFile, EntryType entryType, int indexToRun, int indexToLumi, int indexToEventRange, long long indexToEvent, long long nEvents)

LuminosityBlockNumber_t	lumi () const override

bool	lumiIterationStartingIndex (int index) const override

EntryNumber_t	peekAheadAtEventEntry () const override

LuminosityBlockNumber_t	peekAheadAtLumi () const override

int	processHistoryIDIndex () const override

RunNumber_t	run () const override

bool	shouldProcessLumi () const final

bool	shouldProcessRun () const final

bool	skipLumiInRun () override

Public Member Functions inherited from edm::IndexIntoFile::IndexIntoFileItrImpl
void	advanceToNextLumiOrRun ()

void	advanceToNextRun ()

void	copyPosition (IndexIntoFileItrImpl const &position)

EntryNumber_t	firstEventEntryThisLumi ()

EntryNumber_t	firstEventEntryThisRun ()

EntryType	getEntryType () const

void	getLumisInRun (std::vector< LuminosityBlockNumber_t > &lumis) const

IndexIntoFile const *	indexIntoFile () const

	IndexIntoFileItrImpl (IndexIntoFile const *indexIntoFile, EntryType entryType, int indexToRun, int indexToLumi, int indexToEventRange, long long indexToEvent, long long nEvents)

long long	indexToEvent () const

int	indexToEventRange () const

int	indexToLumi () const

int	indexToRun () const

void	initializeLumi ()

void	initializeRun ()

long long	nEvents () const

void	next ()

bool	operator== (IndexIntoFileItrImpl const &right) const

int	size () const

void	skipEventBackward (int &phIndexOfEvent, RunNumber_t &runOfEvent, LuminosityBlockNumber_t &lumiOfEvent, EntryNumber_t &eventEntry)

void	skipEventForward (int &phIndexOfSkippedEvent, RunNumber_t &runOfSkippedEvent, LuminosityBlockNumber_t &lumiOfSkippedEvent, EntryNumber_t &skippedEventEntry)

bool	skipToNextEventInLumi ()

EntryType	type () const

virtual	~IndexIntoFileItrImpl ()

Private Member Functions
void	addRunsWithNoEvents (EntryOrderInitializationInfo &, EntryNumber_t maxRunTTreeEntry=invalidEntry)

void	addToFileOrder (int index, bool processRunOrLumi, bool processEvents)

void	fillLumisWithNoRemainingEvents (std::vector< TTreeEntryAndIndex > &lumisWithNoRemainingEvents, int startingIndex, EntryNumber_t currentRun, RunOrLumiEntry const *eventSequenceRunOrLumiEntry) const

EntryType	getRunOrLumiEntryType (int index) const override

void	handleLumiEntriesNoRemainingEvents (EntryOrderInitializationInfo &info, int &iLumiIndex, int currentLumi, EntryNumber_t firstBeginEventsContiguousLumi, bool completeAll=false)

void	handleLumisWithNoEvents (std::vector< TTreeEntryAndIndex >::const_iterator &nextLumiWithNoEvents, std::vector< TTreeEntryAndIndex >::const_iterator &endLumisWithNoEvents, EntryNumber_t lumiTTreeEntryNumber, bool completeAll=false)

void	handleLumiWithEvents (EntryOrderInitializationInfo &info, int currentLumi, EntryNumber_t firstBeginEventsContiguousLumi)

void	handleToEndOfContiguousEventsInLumis (EntryOrderInitializationInfo &info, EntryNumber_t currentRun, int endOfRunEntries)

void	handleToEndOfContiguousEventsInRun (EntryOrderInitializationInfo &info, EntryNumber_t currentRun)

void	initializeLumi_ () override

bool	isSameLumi (int index1, int index2) const override

bool	isSameRun (int index1, int index2) const override

EntryNumber_t	lowestInLumi (EntryOrderInitializationInfo &info, int currentLumi) const

LuminosityBlockNumber_t	lumi (int index) const override

bool	nextEventRange () override

bool	previousEventRange () override

void	reserveSpaceInVectors (std::vector< EntryNumber_t >::size_type)

RunOrLumiEntry const &	runOrLumisEntry (EntryNumber_t iEntry) const

bool	setToLastEventInRange (int index) override

bool	shouldProcessEvents (EntryNumber_t iEntry) const

bool	shouldProcessRunOrLumi (EntryNumber_t iEntry) const

Private Attributes
std::vector< EntryNumber_t >	fileOrderRunOrLumiEntry_

int	indexedSize_ = 0

std::vector< bool >	shouldProcessEvents_

std::vector< bool >	shouldProcessRunOrLumi_

Additional Inherited Members
Protected Member Functions inherited from edm::IndexIntoFile::IndexIntoFileItrImpl
void	setIndexToEvent (long long value)

void	setIndexToEventRange (int value)

void	setIndexToLumi (int value)

void	setInvalid ()

void	setNEvents (long long value)

Detailed Description

Definition at line 765 of file IndexIntoFile.h.

Constructor & Destructor Documentation

◆ IndexIntoFileItrEntryOrder()

edm::IndexIntoFile::IndexIntoFileItrEntryOrder::IndexIntoFileItrEntryOrder	(	IndexIntoFile const *	indexIntoFile,
		EntryType	entryType,
		int	indexToRun,
		int	indexToLumi,
		int	indexToEventRange,
		long long	indexToEvent,
		long long	nEvents
	)

Definition at line 1784 of file IndexIntoFile.cc.

References addRunsWithNoEvents(), cms::cuda::assert(), edm::IndexIntoFile::currentRun(), fileOrderRunOrLumiEntry_, handleToEndOfContiguousEventsInRun(), indexedSize_, edm::IndexIntoFile::IndexIntoFileItrImpl::indexIntoFile(), info(), edm::IndexIntoFile::invalidEntry, reserveSpaceInVectors(), edm::IndexIntoFile::runOrLumiEntries(), and edm::IndexIntoFile::IndexIntoFileItrImpl::size().

       : IndexIntoFileItrImpl(
             iIndexIntoFile, entryType, indexToRun, indexToLumi, indexToEventRange, indexToEvent, nEvents) {
     EntryOrderInitializationInfo info;
     info.resizeVectors(indexIntoFile()->runOrLumiEntries());
     reserveSpaceInVectors(indexIntoFile()->runOrLumiEntries().size());
 
     // fill firstIndexOfLumi, firstIndexOfRun, runsWithNoEvents
     info.gatherNeededInfo(indexIntoFile()->runOrLumiEntries());
 
     info.fillIndexesSortedByEventEntry(indexIntoFile()->runOrLumiEntries());
     info.fillIndexesToLastContiguousEvents(indexIntoFile()->runOrLumiEntries());
 
     EntryNumber_t currentRun = invalidEntry;
 
     // The main iterator created here (iEventSequence) is incremented
     // in the function handleToEndOfContiguousEventsInRun and
     // the functions it calls. The iterator is stored in "info",
     // which also holds other information related to the iteration.
     // The information is passed to these functions inside the "info"
     // object.
     for (info.iEventSequence_ = info.indexesSortedByEventEntry_.cbegin(),
         info.iEventSequenceEnd_ = info.indexesSortedByEventEntry_.cend();
          info.iEventSequence_ < info.iEventSequenceEnd_;) {
       info.eventSequenceIndex_ = info.iEventSequence_->runOrLumiIndex_;
       info.eventSequenceRunOrLumiEntry_ = &indexIntoFile()->runOrLumiEntries()[info.eventSequenceIndex_];
 
       assert(info.eventSequenceRunOrLumiEntry_->orderPHIDRun() != currentRun);
       currentRun = info.eventSequenceRunOrLumiEntry_->orderPHIDRun();
 
       // Handles the set of events contiguous in the Events TTree from
       // a single run and all the entries (Run or Lumi) associated with
       // those events and possibly some runs with no events that precede
       // the run in the runs TTree.
       handleToEndOfContiguousEventsInRun(info, currentRun);
     }
     // This takes care of only Runs with no Events at the end of
     // the Runs TTree that were not already added.
     addRunsWithNoEvents(info);
     indexedSize_ = fileOrderRunOrLumiEntry_.size();
   }

Member Function Documentation

◆ addRunsWithNoEvents()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::addRunsWithNoEvents	(	EntryOrderInitializationInfo &	info,
		EntryNumber_t	maxRunTTreeEntry = `invalidEntry`
	)

private

Definition at line 2196 of file IndexIntoFile.cc.

References info(), edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::runOrLumiEntries().

Referenced by IndexIntoFileItrEntryOrder().

                                                                                                       {
     auto const& runOrLumiEntries = indexIntoFile()->runOrLumiEntries();
 
     for (auto& nextRunWithNoEvents = info.nextRunWithNoEvents_;
          nextRunWithNoEvents != info.endRunsWithNoEvents_ &&
          (maxRunTTreeEntry == invalidEntry || nextRunWithNoEvents->ttreeEntry_ < maxRunTTreeEntry);
          ++nextRunWithNoEvents) {
       int index = nextRunWithNoEvents->runOrLumiIndex_;
       EntryNumber_t runToAdd = runOrLumiEntries[index].orderPHIDRun();
       for (int iEnd = static_cast<int>(runOrLumiEntries.size());
            index < iEnd && runOrLumiEntries[index].orderPHIDRun() == runToAdd;
            ++index) {
         // This will add in Run entries and the entries of Lumis in those Runs
         addToFileOrder(index, true, false);
       }
     }
   }

◆ addToFileOrder()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::addToFileOrder	(	int	index,
		bool	processRunOrLumi,
		bool	processEvents
	)

private

Definition at line 2269 of file IndexIntoFile.cc.

                                                                                                                    {
     fileOrderRunOrLumiEntry_.push_back(index);
     shouldProcessRunOrLumi_.push_back(processRunOrLumi);
     shouldProcessEvents_.push_back(processEvents);
   }

◆ clone()

IndexIntoFile::IndexIntoFileItrImpl * edm::IndexIntoFile::IndexIntoFileItrEntryOrder::clone ( void ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1832 of file IndexIntoFile.cc.

                                                                                           {
     return new IndexIntoFileItrEntryOrder(*this);
   }

◆ entry()

IndexIntoFile::EntryNumber_t edm::IndexIntoFile::IndexIntoFileItrEntryOrder::entry ( ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1854 of file IndexIntoFile.cc.

References mps_splice::entry, Exception, edm::IndexIntoFile::invalidEntry, edm::IndexIntoFile::kEnd, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, and edm::errors::LogicError.

                                                                                   {
     if (type() == kEnd)
       return invalidEntry;
     if (type() == kRun)
       return runOrLumisEntry(indexToRun()).entry();
     if (type() == kLumi) {
       auto entry = runOrLumisEntry(indexToLumi()).entry();
       if (entry == invalidEntry) {
         auto const& runLumiEntry = runOrLumisEntry(indexToLumi());
         for (int index = indexToLumi() + 1; index < indexedSize(); ++index) {
           auto const& laterRunOrLumiEntry = runOrLumisEntry(index);
           if (runLumiEntry.lumi() == laterRunOrLumiEntry.lumi() and runLumiEntry.run() == laterRunOrLumiEntry.run() and
               runLumiEntry.processHistoryIDIndex() == laterRunOrLumiEntry.processHistoryIDIndex() &&
               laterRunOrLumiEntry.entry() != invalidEntry) {
             return laterRunOrLumiEntry.entry();
           }
         }
         // We should always find one and never get here!
         throw Exception(errors::LogicError) << "In IndexIntoFile::IndexIntoFileItrEntryOrder::entry. Could not\n"
                                             << "find valid TTree entry number for lumi. This means the IndexIntoFile\n"
                                             << "product in the output file will be corrupted.\n"
                                             << "The output file will be unusable for most purposes.\n"
                                             << "If this occurs after an unrelated exception was thrown,\n"
                                             << "then ignore this exception and fix the primary exception.\n"
                                             << "This is an expected side effect.\n"
                                             << "Otherwise, please report this to the core framework developers\n";
       }
       return entry;
     }
     return runOrLumisEntry(indexToEventRange()).beginEvents() + indexToEvent();
   }

◆ fillLumisWithNoRemainingEvents()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::fillLumisWithNoRemainingEvents	(	std::vector< TTreeEntryAndIndex > &	lumisWithNoRemainingEvents,
		int	startingIndex,
		EntryNumber_t	currentRun,
		RunOrLumiEntry const *	eventSequenceRunOrLumiEntry
	)		const

private

Definition at line 2215 of file IndexIntoFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::RunOrLumiEntry::beginEvents(), edm::IndexIntoFile::beginEvents(), edm::IndexIntoFile::currentLumi(), edm::IndexIntoFile::currentRun(), edm::IndexIntoFile::invalidEntry, edm::IndexIntoFile::runOrLumiEntries(), jetsAK4_CHS_cff::sort, and edm::IndexIntoFile::IndexIntoFileItrEntryOrder::TTreeEntryAndIndex::ttreeEntry_.

                                                                {
     auto const& runOrLumiEntries = indexIntoFile()->runOrLumiEntries();
     int iEnd = static_cast<int>(runOrLumiEntries.size());
 
     // start at the first entry after the Run entries
     // iterate over all the lumi entries in this Run
     // The outer loop iterates over lumis and inner loop iterates over entries in each lumi
     for (int indexOfLumiEntry = startingIndex;
          indexOfLumiEntry < iEnd && runOrLumiEntries[indexOfLumiEntry].orderPHIDRun() == currentRun;) {
       auto currentLumiIndex = indexOfLumiEntry;
       auto const& currentLumiEntry = runOrLumiEntries[currentLumiIndex];
       assert(!currentLumiEntry.isRun());
       auto currentLumi = currentLumiEntry.orderPHIDRunLumi();
 
       bool foundUnprocessedEvents = false;
       EntryNumber_t minLumiTTreeEntry = invalidEntry;
       // iterate over the lumi entries associated with a single lumi
       for (; indexOfLumiEntry < iEnd && runOrLumiEntries[indexOfLumiEntry].orderPHIDRunLumi() == currentLumi;
            ++indexOfLumiEntry) {
         if (runOrLumiEntries[indexOfLumiEntry].beginEvents() >= eventSequenceRunOrLumiEntry->beginEvents()) {
           foundUnprocessedEvents = true;
         }
         // Find the smallest valid Lumi TTree entry for this lumi
         auto lumiTTreeEntry = runOrLumiEntries[indexOfLumiEntry].entry();
         if (lumiTTreeEntry != invalidEntry &&
             (minLumiTTreeEntry == invalidEntry || lumiTTreeEntry < minLumiTTreeEntry)) {
           minLumiTTreeEntry = lumiTTreeEntry;
         }
       }
       // No event sequences left to process and at least one valid lumi TTree entry.
       if (!foundUnprocessedEvents && minLumiTTreeEntry != invalidEntry) {
         lumisWithNoRemainingEvents.push_back({minLumiTTreeEntry, currentLumiIndex});
       }
     }
 
     std::sort(lumisWithNoRemainingEvents.begin(),
               lumisWithNoRemainingEvents.end(),
               [](TTreeEntryAndIndex const& left, TTreeEntryAndIndex const& right) -> bool {
                 return left.ttreeEntry_ < right.ttreeEntry_;
               });
   }

◆ getRunOrLumiEntryType()

IndexIntoFile::EntryType edm::IndexIntoFile::IndexIntoFileItrEntryOrder::getRunOrLumiEntryType ( int index ) const

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 2029 of file IndexIntoFile.cc.

References edm::IndexIntoFile::kEnd, edm::IndexIntoFile::kLumi, and edm::IndexIntoFile::kRun.

                                                                                                        {
     if (index < 0 || index >= indexedSize()) {
       return kEnd;
     } else if (runOrLumisEntry(index).isRun()) {
       return kRun;
     }
     return kLumi;
   }

◆ handleLumiEntriesNoRemainingEvents()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiEntriesNoRemainingEvents	(	EntryOrderInitializationInfo &	info,
		int &	iLumiIndex,
		int	currentLumi,
		EntryNumber_t	firstBeginEventsContiguousLumi,
		bool	completeAll = `false`
	)

private

Definition at line 2421 of file IndexIntoFile.cc.

References edm::IndexIntoFile::currentLumi(), mps_splice::entry, info(), edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::runOrLumiEntries().

                         {
     auto const& runOrLumiEntries = indexIntoFile()->runOrLumiEntries();
     int iEnd = static_cast<int>(runOrLumiEntries.size());
 
     for (; iLumiIndex < iEnd && runOrLumiEntries[iLumiIndex].orderPHIDRunLumi() == currentLumi &&
            (completeAll || runOrLumiEntries[iLumiIndex].entry() < info.eventSequenceRunOrLumiEntry_->entry());
          ++iLumiIndex) {
       if (runOrLumiEntries[iLumiIndex].entry() == invalidEntry ||
           runOrLumiEntries[iLumiIndex].beginEvents() >= firstBeginEventsContiguousLumi) {
         continue;
       }
       addToFileOrder(iLumiIndex, true, false);
     }
   }

◆ handleLumisWithNoEvents()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumisWithNoEvents	(	std::vector< TTreeEntryAndIndex >::const_iterator &	nextLumiWithNoEvents,
		std::vector< TTreeEntryAndIndex >::const_iterator &	endLumisWithNoEvents,
		EntryNumber_t	lumiTTreeEntryNumber,
		bool	completeAll = `false`
	)

private

Definition at line 2380 of file IndexIntoFile.cc.

References mps_splice::entry, edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::runOrLumiEntries().

                         {
     auto const& runOrLumiEntries = indexIntoFile()->runOrLumiEntries();
     int iEnd = static_cast<int>(runOrLumiEntries.size());
 
     for (; nextLumiWithNoEvents < endLumisWithNoEvents &&
            (completeAll || nextLumiWithNoEvents->ttreeEntry_ < lumiTTreeEntryNumber);
          ++nextLumiWithNoEvents) {
       int iLumiIndex = nextLumiWithNoEvents->runOrLumiIndex_;
       auto orderPHIDRunLumi = runOrLumiEntries[iLumiIndex].orderPHIDRunLumi();
       for (; iLumiIndex < iEnd && runOrLumiEntries[iLumiIndex].orderPHIDRunLumi() == orderPHIDRunLumi; ++iLumiIndex) {
         if (runOrLumiEntries[iLumiIndex].entry() != invalidEntry) {
           addToFileOrder(iLumiIndex, true, false);
         }
       }
     }
   }

◆ handleLumiWithEvents()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiWithEvents	(	EntryOrderInitializationInfo &	info,
		int	currentLumi,
		EntryNumber_t	firstBeginEventsContiguousLumi
	)

private

Definition at line 2401 of file IndexIntoFile.cc.

References edm::IndexIntoFile::currentLumi(), info(), edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::runOrLumiEntries().

                                                                                                                      {
     auto const& runOrLumiEntries = indexIntoFile()->runOrLumiEntries();
     int iLumiIndex = info.firstIndexOfLumi_[currentLumi];
     while (info.iEventSequence_ < info.iEventSequenceEnd_ &&
            info.eventSequenceRunOrLumiEntry_->orderPHIDRunLumi() == currentLumi) {
       // lumi entries for the currentLumi with no remaining Events to process and
       // with Lumi TTree entry numbers less than the Lumi TTree entry for the next
       // sequence of Events.
       handleLumiEntriesNoRemainingEvents(info, iLumiIndex, currentLumi, firstBeginEventsContiguousLumi);
 
       // Add entry with the next event sequence
       bool shouldProcessLumi = runOrLumiEntries[info.eventSequenceIndex_].entry() != invalidEntry;
       addToFileOrder(info.eventSequenceIndex_, shouldProcessLumi, true);
       info.nextEventSequence(runOrLumiEntries);
     }
     handleLumiEntriesNoRemainingEvents(info, iLumiIndex, currentLumi, firstBeginEventsContiguousLumi, true);
   }

◆ handleToEndOfContiguousEventsInLumis()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInLumis	(	EntryOrderInitializationInfo &	info,
		EntryNumber_t	currentRun,
		int	endOfRunEntries
	)

private

Definition at line 2320 of file IndexIntoFile.cc.

References edm::IndexIntoFile::currentLumi(), edm::IndexIntoFile::currentRun(), info(), edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::runOrLumiEntries().

                                                                                          {
     // Form a list of lumis that have no more events left to be processed and are in the current
     // run and have at least one valid Lumi TTree entry. Contains the index to the first
     // lumi entry and its TTree entry number, sorted by earliest lumi TTree entry number.
     std::vector<TTreeEntryAndIndex> lumisWithNoRemainingEvents;
     fillLumisWithNoRemainingEvents(
         lumisWithNoRemainingEvents, endOfRunEntries, currentRun, info.eventSequenceRunOrLumiEntry_);
     auto nextLumiWithNoEvents = lumisWithNoRemainingEvents.cbegin();
     auto endLumisWithNoEvents = lumisWithNoRemainingEvents.cend();
 
     // On each step of this iteration we process all the events in a contiguous sequence of events
     // from a single lumi (these are events that haven't already been processed and are contained
     // within the last contiguous sequence of events from the containing run).
     while (info.iEventSequence_ < info.iEventSequenceEnd_ &&
            info.eventSequenceRunOrLumiEntry_->orderPHIDRun() == currentRun) {
       auto currentLumi = info.eventSequenceRunOrLumiEntry_->orderPHIDRunLumi();
 
       // Last contiguous sequence of events in lumi
       if (info.startOfLastContiguousEventsInLumi_[currentLumi] == info.eventSequenceIndex_) {
         auto firstBeginEventsContiguousLumi = info.eventSequenceRunOrLumiEntry_->beginEvents();
         // Find the first Lumi TTree entry number for this Lumi
         EntryNumber_t lumiTTreeEntryNumber = lowestInLumi(info, currentLumi);
 
         // In addition, we want lumis before this in the lumi tree if they have no events
         // left to be processed
         handleLumisWithNoEvents(nextLumiWithNoEvents, endLumisWithNoEvents, lumiTTreeEntryNumber);
 
         // Handle the lumi with the next sequence of events to process
         handleLumiWithEvents(info, currentLumi, firstBeginEventsContiguousLumi);
 
       } else {
         // not last contiguous event sequence for lumi
         while (info.iEventSequence_ < info.iEventSequenceEnd_ &&
                info.eventSequenceRunOrLumiEntry_->orderPHIDRunLumi() == currentLumi) {
           addToFileOrder(info.eventSequenceIndex_, false, true);
           info.nextEventSequence(indexIntoFile()->runOrLumiEntries());
         }
       }
     }
     handleLumisWithNoEvents(nextLumiWithNoEvents, endLumisWithNoEvents, invalidEntry, true);
   }

◆ handleToEndOfContiguousEventsInRun()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInRun	(	EntryOrderInitializationInfo &	info,
		EntryNumber_t	currentRun
	)

private

Definition at line 2275 of file IndexIntoFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::currentRun(), mps_splice::entry, info(), and edm::IndexIntoFile::runOrLumiEntries().

Referenced by IndexIntoFileItrEntryOrder().

                                                                                                                {
     auto const& runOrLumiEntries = indexIntoFile()->runOrLumiEntries();
     int iEnd = static_cast<int>(runOrLumiEntries.size());
 
     int indexOfRunEntry = info.firstIndexOfRun_[currentRun];
 
     // Event entries are put in the exact same order as in the Events TTree.
     // We make some effort to make the Runs and Lumis come out in Run TTree
     // order and Lumi TTree order, but that is often not possible.
 
     // If it is the last contiguous sequence of events for the Run, also
     // add ALL entries corresponding to valid Run or Lumi TTree entries for
     // this Run. This is the place where the Run and Lumi products will get
     // processed and merged, ALL of them for this run whether or not they have
     // events in this particular subsequence of events. This forces all the Run
     // and Lumi product merging to occur the first time a file is read.
     if (info.startOfLastContiguousEventsInRun_[currentRun] == info.eventSequenceIndex_) {
       // Add runs with no events that have an earlier Run TTree entry number
       addRunsWithNoEvents(info, runOrLumiEntries[indexOfRunEntry].entry());
 
       // Add all valid run entries associated with the event sequence
       for (; indexOfRunEntry < iEnd && runOrLumiEntries[indexOfRunEntry].isRun(); ++indexOfRunEntry) {
         assert(runOrLumiEntries[indexOfRunEntry].orderPHIDRun() == currentRun);
         addToFileOrder(indexOfRunEntry, true, false);
       }
 
       // Add all lumi entries associated with this run
       handleToEndOfContiguousEventsInLumis(info, currentRun, indexOfRunEntry);
 
     } else {
       // Add only the first run entry and flag it to be not processed yet.
       addToFileOrder(indexOfRunEntry, false, false);
 
       // Add the minimum number of lumi entries so that the events they reference
       // will be processed in the correct order, lumis are not to be processed.
       // The lumis will be added again later to be processed.
       while (info.iEventSequence_ != info.iEventSequenceEnd_ &&
              info.eventSequenceRunOrLumiEntry_->orderPHIDRun() == currentRun) {
         addToFileOrder(info.eventSequenceIndex_, false, true);
         info.nextEventSequence(runOrLumiEntries);
       }
     }
   }

◆ indexedSize()

int edm::IndexIntoFile::IndexIntoFileItrEntryOrder::indexedSize ( ) const

inlineoverridevirtual

Reimplemented from edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 786 of file IndexIntoFile.h.

References indexedSize_.

786 { return indexedSize_; }

edm::IndexIntoFile::IndexIntoFileItrEntryOrder::indexedSize_

int indexedSize_

Definition: IndexIntoFile.h:877

◆ initializeLumi_()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::initializeLumi_ ( )

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1912 of file IndexIntoFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::beginEvents(), edm::IndexIntoFile::endEvents(), edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::invalidIndex.

                                                                 {
     assert(indexToLumi() != invalidIndex);
 
     setIndexToEventRange(invalidIndex);
     setIndexToEvent(0);
     setNEvents(0);
 
     for (int index = indexToLumi(); index < indexedSize(); ++index) {
       if (runOrLumisEntry(index).isRun()) {
         break;
       } else if (runOrLumisEntry(index).lumi() == runOrLumisEntry(indexToLumi()).lumi()) {
         if (runOrLumisEntry(index).beginEvents() == invalidEntry || !shouldProcessEvents(index)) {
           continue;
         }
         setIndexToEventRange(index);
         setIndexToEvent(0);
         setNEvents(runOrLumisEntry(indexToEventRange()).endEvents() -
                    runOrLumisEntry(indexToEventRange()).beginEvents());
         break;
       } else {
         break;
       }
     }
   }

◆ isSameLumi()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::isSameLumi	(	int	index1,
		int	index2
	)		const

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 2038 of file IndexIntoFile.cc.

                                                                                        {
     if (index1 < 0 || index1 >= indexedSize() || index2 < 0 || index2 >= indexedSize()) {
       return false;
     }
     return runOrLumisEntry(index1).lumi() == runOrLumisEntry(index2).lumi();
   }

◆ isSameRun()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::isSameRun	(	int	index1,
		int	index2
	)		const

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 2045 of file IndexIntoFile.cc.

                                                                                       {
     if (index1 < 0 || index1 >= indexedSize() || index2 < 0 || index2 >= indexedSize()) {
       return false;
     }
     return runOrLumisEntry(index1).run() == runOrLumisEntry(index2).run() &&
            runOrLumisEntry(index1).processHistoryIDIndex() == runOrLumisEntry(index2).processHistoryIDIndex();
   }

◆ lowestInLumi()

IndexIntoFile::EntryNumber_t edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lowestInLumi	(	EntryOrderInitializationInfo &	info,
		int	currentLumi
	)		const

private

Definition at line 2363 of file IndexIntoFile.cc.

References edm::IndexIntoFile::currentLumi(), info(), edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::runOrLumiEntries().

                                                                  {
     auto const& runOrLumiEntries = indexIntoFile()->runOrLumiEntries();
     int iEnd = static_cast<int>(runOrLumiEntries.size());
 
     for (int iLumiIndex = info.firstIndexOfLumi_[currentLumi];
          iLumiIndex < iEnd && runOrLumiEntries[iLumiIndex].orderPHIDRunLumi() == currentLumi;
          ++iLumiIndex) {
       EntryNumber_t lumiTTreeEntryNumber = runOrLumiEntries[iLumiIndex].entry();
       if (lumiTTreeEntryNumber != invalidEntry) {
         // First valid one is the lowest because of the sort order of the container
         return lumiTTreeEntryNumber;
       }
     }
     return invalidEntry;
   }

◆ lumi() [1/2]

LuminosityBlockNumber_t edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lumi ( ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1848 of file IndexIntoFile.cc.

References edm::IndexIntoFile::invalidLumi, edm::IndexIntoFile::kEnd, and edm::IndexIntoFile::kRun.

                                                                               {
     if (type() == kEnd || type() == kRun)
       return invalidLumi;
     return runOrLumisEntry(indexToLumi()).lumi();
   }

◆ lumi() [2/2]

LuminosityBlockNumber_t edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lumi ( int index ) const

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 2053 of file IndexIntoFile.cc.

References edm::IndexIntoFile::invalidLumi.

                                                                                        {
     if (index < 0 || index >= indexedSize()) {
       return invalidLumi;
     }
     return runOrLumisEntry(index).lumi();
   }

◆ lumiIterationStartingIndex()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lumiIterationStartingIndex ( int index ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 2012 of file IndexIntoFile.cc.

References cms::cuda::assert(), mps_splice::entry, edm::IndexIntoFile::invalidEntry, and BXlumiParameters_cfi::lumi.

                                                                                           {
     assert(index >= 0 && index < indexedSize());
     auto entry = runOrLumisEntry(index).entry();
     if (entry == invalidEntry) {
       // Usually the starting index is just the first one with a valid lumi TTree entry
       // number. If there aren't any that are valid, then use the last one.
       if (index + 1 < indexedSize()) {
         if (runOrLumisEntry(index).lumi() != runOrLumisEntry(index + 1).lumi()) {
           return true;
         }
       } else if (index + 1 == indexedSize()) {
         return true;
       }
     }
     return entry != invalidEntry;
   }

◆ nextEventRange()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::nextEventRange ( )

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1937 of file IndexIntoFile.cc.

References edm::IndexIntoFile::beginEvents(), edm::IndexIntoFile::endEvents(), edm::IndexIntoFile::invalidEntry, and edm::IndexIntoFile::invalidIndex.

                                                                {
     if (indexToEventRange() == invalidIndex)
       return false;
 
     // Look for the next event range, same lumi but different entry
     for (int index = indexToEventRange() + 1; index < indexedSize(); ++index) {
       if (runOrLumisEntry(index).isRun()) {
         return false;  // hit next run
       } else if (runOrLumisEntry(index).lumi() == runOrLumisEntry(indexToEventRange()).lumi()) {
         if (runOrLumisEntry(index).beginEvents() == invalidEntry || !shouldProcessEvents(index)) {
           continue;  // same lumi but has no events, keep looking
         }
         setIndexToEventRange(index);
         setIndexToEvent(0);
         setNEvents(runOrLumisEntry(indexToEventRange()).endEvents() -
                    runOrLumisEntry(indexToEventRange()).beginEvents());
         return true;  // found more events in this lumi
       }
       return false;  // hit next lumi
     }
     return false;  // hit the end of the IndexIntoFile
   }

◆ peekAheadAtEventEntry()

IndexIntoFile::EntryNumber_t edm::IndexIntoFile::IndexIntoFileItrEntryOrder::peekAheadAtEventEntry ( ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1904 of file IndexIntoFile.cc.

References edm::IndexIntoFile::invalidEntry, edm::IndexIntoFile::invalidIndex, and createIOVlist::nEvents.

                                                                                                   {
     if (indexToLumi() == invalidIndex)
       return invalidEntry;
     if (indexToEvent() >= nEvents())
       return invalidEntry;
     return runOrLumisEntry(indexToEventRange()).beginEvents() + indexToEvent();
   }

◆ peekAheadAtLumi()

LuminosityBlockNumber_t edm::IndexIntoFile::IndexIntoFileItrEntryOrder::peekAheadAtLumi ( ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1898 of file IndexIntoFile.cc.

References edm::IndexIntoFile::invalidIndex, and edm::IndexIntoFile::invalidLumi.

                                                                                          {
     if (indexToLumi() == invalidIndex)
       return invalidLumi;
     return runOrLumisEntry(indexToLumi()).lumi();
   }

◆ previousEventRange()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::previousEventRange ( )

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1960 of file IndexIntoFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::beginEvents(), edm::IndexIntoFile::endEvents(), edm::IndexIntoFile::invalidEntry, edm::IndexIntoFile::invalidIndex, and createIOVlist::nEvents.

                                                                    {
     if (indexToEventRange() == invalidIndex)
       return false;
     assert(indexToEventRange() < indexedSize());
 
     // Look backward for a previous event range with events, same lumi but different entry
     for (int newRange = indexToEventRange() - 1; newRange > 0; --newRange) {
       if (runOrLumisEntry(newRange).isRun()) {
         return false;  // hit run
       } else if (isSameLumi(newRange, indexToEventRange())) {
         if (runOrLumisEntry(newRange).beginEvents() == invalidEntry || !shouldProcessEvents(newRange)) {
           continue;  // same lumi but has no events, keep looking
         }
         setIndexToEventRange(newRange);
         setNEvents(runOrLumisEntry(indexToEventRange()).endEvents() -
                    runOrLumisEntry(indexToEventRange()).beginEvents());
         setIndexToEvent(nEvents() - 1);
         return true;  // found previous event in this lumi
       }
       return false;  // hit previous lumi
     }
     return false;  // hit the beginning of the IndexIntoFile, 0th entry has to be a run
   }

◆ processHistoryIDIndex()

int edm::IndexIntoFile::IndexIntoFileItrEntryOrder::processHistoryIDIndex ( ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1836 of file IndexIntoFile.cc.

References edm::IndexIntoFile::invalidIndex, and edm::IndexIntoFile::kEnd.

                                                                            {
     if (type() == kEnd)
       return invalidIndex;
     return runOrLumisEntry(indexToRun()).processHistoryIDIndex();
   }

◆ reserveSpaceInVectors()

void edm::IndexIntoFile::IndexIntoFileItrEntryOrder::reserveSpaceInVectors ( std::vector< EntryNumber_t >::size_type sizeToReserve )

private

Definition at line 2261 of file IndexIntoFile.cc.

Referenced by IndexIntoFileItrEntryOrder().

                                                        {
     // Reserve some space. Most likely this is not big enough, but better than reserving nothing.
     fileOrderRunOrLumiEntry_.reserve(sizeToReserve);
     shouldProcessRunOrLumi_.reserve(sizeToReserve);
     shouldProcessEvents_.reserve(sizeToReserve);
   }

◆ run()

RunNumber_t edm::IndexIntoFile::IndexIntoFileItrEntryOrder::run ( ) const

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1842 of file IndexIntoFile.cc.

References edm::IndexIntoFile::invalidRun, and edm::IndexIntoFile::kEnd.

Referenced by Types.EventID::cppID(), and Types.LuminosityBlockID::cppID().

                                                                  {
     if (type() == kEnd)
       return invalidRun;
     return runOrLumisEntry(indexToRun()).run();
   }

◆ runOrLumisEntry()

RunOrLumiEntry const& edm::IndexIntoFile::IndexIntoFileItrEntryOrder::runOrLumisEntry ( EntryNumber_t iEntry ) const

inlineprivate

Definition at line 797 of file IndexIntoFile.h.

References fileOrderRunOrLumiEntry_, edm::IndexIntoFile::IndexIntoFileItrImpl::indexIntoFile(), and edm::IndexIntoFile::runOrLumiEntries().

                                                                         {
         return indexIntoFile()->runOrLumiEntries()[fileOrderRunOrLumiEntry_[iEntry]];
       }

◆ setToLastEventInRange()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::setToLastEventInRange ( int index )

overrideprivatevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1984 of file IndexIntoFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::beginEvents(), edm::IndexIntoFile::endEvents(), edm::IndexIntoFile::invalidEntry, and createIOVlist::nEvents.

                                                                                {
     if (runOrLumisEntry(index).beginEvents() == invalidEntry || !shouldProcessEvents(index)) {
       return false;
     }
     setIndexToEventRange(index);
     setNEvents(runOrLumisEntry(indexToEventRange()).endEvents() - runOrLumisEntry(indexToEventRange()).beginEvents());
     assert(nEvents() > 0);
     setIndexToEvent(nEvents() - 1);
     return true;
   }

◆ shouldProcessEvents()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessEvents ( EntryNumber_t iEntry ) const

inlineprivate

Definition at line 801 of file IndexIntoFile.h.

References shouldProcessEvents_.

801 { return shouldProcessEvents_[iEntry]; }

edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessEvents_

std::vector< bool > shouldProcessEvents_

Definition: IndexIntoFile.h:880

◆ shouldProcessLumi()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessLumi ( ) const

finalvirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1886 of file IndexIntoFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::invalidIndex, and edm::IndexIntoFile::kLumi.

                                                                         {
     assert(type() == kLumi);
     assert(indexToLumi() != invalidIndex);
     return shouldProcessRunOrLumi_[indexToLumi()];
   }

◆ shouldProcessRun()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessRun ( ) const

finalvirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1892 of file IndexIntoFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::invalidIndex, and edm::IndexIntoFile::kRun.

                                                                        {
     assert(type() == kRun);
     assert(indexToRun() != invalidIndex);
     return shouldProcessRunOrLumi_[indexToRun()];
   }

◆ shouldProcessRunOrLumi()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessRunOrLumi ( EntryNumber_t iEntry ) const

inlineprivate

Definition at line 800 of file IndexIntoFile.h.

References shouldProcessRunOrLumi_.

800 { return shouldProcessRunOrLumi_[iEntry]; }

edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessRunOrLumi_

std::vector< bool > shouldProcessRunOrLumi_

Definition: IndexIntoFile.h:879

◆ skipLumiInRun()

bool edm::IndexIntoFile::IndexIntoFileItrEntryOrder::skipLumiInRun ( )

overridevirtual

Implements edm::IndexIntoFile::IndexIntoFileItrImpl.

Definition at line 1995 of file IndexIntoFile.cc.

References mps_fire::i, edm::IndexIntoFile::invalidIndex, and BXlumiParameters_cfi::lumi.

                                                               {
     if (indexToLumi() == invalidIndex)
       return false;
     for (int i = 1; indexToLumi() + i < indexedSize(); ++i) {
       int newLumi = indexToLumi() + i;
       if (runOrLumisEntry(newLumi).isRun()) {
         return false;  // hit next run
       } else if (runOrLumisEntry(newLumi).lumi() == runOrLumisEntry(indexToLumi()).lumi()) {
         continue;
       }
       setIndexToLumi(newLumi);
       initializeLumi();
       return true;  // hit next lumi
     }
     return false;  // hit the end of the IndexIntoFile
   }

Member Data Documentation

◆ fileOrderRunOrLumiEntry_

std::vector<EntryNumber_t> edm::IndexIntoFile::IndexIntoFileItrEntryOrder::fileOrderRunOrLumiEntry_

private

Definition at line 878 of file IndexIntoFile.h.

Referenced by IndexIntoFileItrEntryOrder(), and runOrLumisEntry().

◆ indexedSize_

int edm::IndexIntoFile::IndexIntoFileItrEntryOrder::indexedSize_ = 0

private

Definition at line 877 of file IndexIntoFile.h.

Referenced by indexedSize(), and IndexIntoFileItrEntryOrder().

◆ shouldProcessEvents_

std::vector<bool> edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessEvents_

private

Definition at line 880 of file IndexIntoFile.h.

Referenced by shouldProcessEvents().

◆ shouldProcessRunOrLumi_

std::vector<bool> edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessRunOrLumi_

private

Definition at line 879 of file IndexIntoFile.h.

Referenced by shouldProcessRunOrLumi().

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ IndexIntoFileItrEntryOrder()

Member Function Documentation

◆ addRunsWithNoEvents()

◆ addToFileOrder()

◆ clone()

◆ entry()

◆ fillLumisWithNoRemainingEvents()

◆ getRunOrLumiEntryType()

◆ handleLumiEntriesNoRemainingEvents()

◆ handleLumisWithNoEvents()

◆ handleLumiWithEvents()

◆ handleToEndOfContiguousEventsInLumis()

◆ handleToEndOfContiguousEventsInRun()

◆ indexedSize()

◆ initializeLumi_()

◆ isSameLumi()

◆ isSameRun()

◆ lowestInLumi()

◆ lumi() [1/2]

◆ lumi() [2/2]

◆ lumiIterationStartingIndex()

◆ nextEventRange()

◆ peekAheadAtEventEntry()

◆ peekAheadAtLumi()

◆ previousEventRange()

◆ processHistoryIDIndex()

◆ reserveSpaceInVectors()

◆ run()

◆ runOrLumisEntry()

◆ setToLastEventInRange()

◆ shouldProcessEvents()

◆ shouldProcessLumi()

◆ shouldProcessRun()

◆ shouldProcessRunOrLumi()

◆ skipLumiInRun()

Member Data Documentation

◆ fileOrderRunOrLumiEntry_

◆ indexedSize_

◆ shouldProcessEvents_

◆ shouldProcessRunOrLumi_