edm::IndexIntoFile Class Reference

#include <IndexIntoFile.h>

Classes
class	EventEntry
class	EventFinder
class	IndexIntoFileItr
class	IndexIntoFileItrEntryOrder
class	IndexIntoFileItrImpl
class	IndexIntoFileItrNoSort
class	IndexIntoFileItrSorted
class	IndexRunKey
class	IndexRunLumiEventKey
class	IndexRunLumiKey
class	RunOrLumiEntry
class	RunOrLumiIndexes
class	SortedRunOrLumiItr
struct	Transients

Public Types
using	EntryNumber_t = long long
enum	EntryType { kRun, kLumi, kEvent, kEnd }
enum	SortOrder { numericalOrder, firstAppearanceOrder, entryOrder }

Public Member Functions
void	addEntry (ProcessHistoryID const &processHistoryID, RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event, EntryNumber_t entry)
void	addLumi (int index, RunNumber_t run, LuminosityBlockNumber_t lumi, EntryNumber_t entry)
IndexIntoFileItr	begin (SortOrder sortOrder) const
SortedRunOrLumiItr	beginRunOrLumi () const
void	checkForMissingRunOrLumiEntry () const
	Run this check just after sorting. More...
bool	containsDuplicateEvents () const
	Returns true if the IndexIntoFile contains 2 events with the same ProcessHistoryID index, run number, lumi number and event number. More...
bool	containsEvent (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const
bool	containsItem (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const
bool	containsLumi (RunNumber_t run, LuminosityBlockNumber_t lumi) const
bool	containsRun (RunNumber_t run) const
void	doneFileInitialization ()
	Clears the temporary vector of event numbers to reduce memory usage. More...
bool	empty () const
	True if no runs, lumis, or events are in the file. More...
IndexIntoFileItr	end (SortOrder sortOrder) const
	Used to end an iteration over the Runs, Lumis, and Events in a file. More...
SortedRunOrLumiItr	endRunOrLumi () const
void	fillEventEntries () const
void	fillEventNumbers () const
void	fillEventNumbersOrEntries (bool needEventNumbers, bool needEventEntries) const
IndexIntoFileItr	findEventPosition (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const
IndexIntoFileItr	findLumiPosition (RunNumber_t run, LuminosityBlockNumber_t lumi) const
IndexIntoFileItr	findPosition (RunNumber_t run, LuminosityBlockNumber_t lumi=0U, EventNumber_t event=0U) const
IndexIntoFileItr	findPosition (SortOrder sortOrder, RunNumber_t run, LuminosityBlockNumber_t lumi=0U, EventNumber_t event=0U) const
IndexIntoFileItr	findRunPosition (RunNumber_t run) const
	Same as findPosition. More...
void	fixIndexes (std::vector< ProcessHistoryID > &processHistoryIDs)
	IndexIntoFile ()
void	initializeTransients ()
void	inputFileClosed ()
bool	iterationWillBeInEntryOrder (SortOrder sortOrder) const
	Used to determine whether or not to disable fast cloning. More...
ProcessHistoryID const &	processHistoryID (int i) const
std::vector< ProcessHistoryID > const &	processHistoryIDs () const
void	reduceProcessHistoryIDs (ProcessHistoryRegistry const &processHistoryRegistry)
std::vector< RunOrLumiEntry > const &	runOrLumiEntries () const
	Used internally and for test purposes. More...
void	set_intersection (IndexIntoFile const &indexIntoFile, std::set< IndexRunLumiEventKey > &intersection) const
void	setEventFinder (std::shared_ptr< EventFinder > ptr)
void	setNumberOfEvents (EntryNumber_t nevents)
std::vector< ProcessHistoryID > &	setProcessHistoryIDs ()
std::vector< RunOrLumiEntry > &	setRunOrLumiEntries ()
void	sortVector_Run_Or_Lumi_Entries ()
std::vector< EventNumber_t > &	unsortedEventNumbers ()
std::vector< EventNumber_t > const &	unsortedEventNumbers () const
	~IndexIntoFile ()

Static Public Attributes
static constexpr EntryNumber_t	invalidEntry = -1LL
static constexpr EventNumber_t	invalidEvent = 0U
static constexpr int	invalidIndex = -1
static constexpr LuminosityBlockNumber_t	invalidLumi = 0U
static constexpr RunNumber_t	invalidRun = 0U

Private Member Functions
EntryNumber_t &	beginEvents () const
int &	currentIndex () const
LuminosityBlockNumber_t &	currentLumi () const
RunNumber_t &	currentRun () const
EntryNumber_t &	endEvents () const
std::vector< EventEntry > &	eventEntries () const
std::vector< EventNumber_t > &	eventNumbers () const
void	fillRunOrLumiIndexes () const
void	fillUnsortedEventNumbers () const
EventNumber_t	getEventNumberOfEntry (EntryNumber_t entry) const
std::map< IndexRunLumiKey, EntryNumber_t > &	lumiToOrder () const
size_t	numberOfEvents () const
int &	previousAddedIndex () const
void	resetEventFinder () const
std::vector< RunOrLumiIndexes > &	runOrLumiIndexes () const
std::map< IndexRunKey, EntryNumber_t > &	runToOrder () const
void	sortEventEntries () const
void	sortEvents () const
std::vector< EventNumber_t > &	unsortedEventNumbersMutable () const

Private Attributes
std::vector< ProcessHistoryID >	processHistoryIDs_
std::vector< RunOrLumiEntry >	runOrLumiEntries_
Transients	transient_

Friends
class	::TestIndexIntoFile
class	::TestIndexIntoFile1
class	::TestIndexIntoFile2
class	::TestIndexIntoFile3
class	::TestIndexIntoFile4
class	::TestIndexIntoFile5

Detailed Description

Used to quickly find the Events, Lumis, and Runs in a single ROOT format data file and step through them in the desired order.

A list of the most important functions that a client would use directly follows. There are detailed comments below with the declaration of each function.

The begin and end functions are used to start and stop an iteration loop. An argument to the iterator constructor determines the order of iteration.

The functions findPosition, findEventPosition, findRunPosition, and findLumiPosition are used to navigate directly to specific runs, lumis, and events.

The functions mentioned above return an object of type IndexIntoFileItr. The IndexIntoFileItr class has member functions which allow one to navigate forward and backward through the runs, lumis, and events in alternative ways. See more comments with the declaration of each public member function in IndexIntoFileItr.

The iterator will know what the current item is (as one would expect). This could be a run, lumi, or event. It knows more than that though, it knows all three as is explained below.

In the run state, IndexIntoFileItr knows which lumi will be processed next after the run and also which event will be processed after the lumi. These may not be the first ones in the run if the skip functions were used.

In the lumi state, the IndexIntoFileItr will always point at the last associated run and the next event to be processed after the lumi. This may not be the first event if the skip function was used.

In the event state, the IndexIntoFileItr will always point at the last corresponding run and also the last corresponding lumi.

There can be multiple run entries in a TTree associated with the same run number and ProcessHistoryID in a file. There can also be multiple lumi entries associated with the same lumi number, run number, and ProcessHistoryID. The sorting orders identified as numericalOrder and firstAppearanceOrder will make these subgroups contiguous, but beyond that is up to the client (normally PoolSource, which passes them up to the EventProcessor) to deal with merging the multiple run (or lumi) entries together.

In entryOrder, the Events are processed in the order they appear in the Events TTree. The event entries associated with a run might not be contiguous. The event entries associated with a lumi might not be contiguous. Even so, the iteration order will always follow the pattern run followed by contained lumis followed by contained events (note it's possible there are no contained events for a lumi or no contained lumis for a run). Because the events are not contiguous, this leads to run or lumi entries appearing more than once in the iteration (once for each contained contiguous sequence of events plus possibly one additional time near the end for the run or lumi to be processed and merged, although this might or might not occur with the last contiguous sequence of events). The iterator is designed to automatically step to each event once, even when it points at the same RunOrLumiEntry with the same events more than once in the iteration. The client does not need to do anything special related to events. On the other hand, the client (usually PoolSource, which passes the value into the Principal) needs to check the iterator functions named shouldProcessLumi or shouldProcessRun to determine whether a lumi or run is being encountered more than once. Those functions will return true only once. At that time, run or lumi products are read, possibly merged, and written to output. When those functions return false, transitions still occur but products are not read, merged or written. If a module attempts to get run or lumi products in those transitions, there will be a "ProductNotFound" exception or invalid Handle. In general, getting run or lumi products from events does not work with the EntryOrder iterator type.

One final comment with regards to IndexIntoFileItr. This is not an STL iterator and it cannot be used with std:: algorithms. The data structures are complex and designed to optimize memory usage. It would be difficult or impossible implement an iterator that is STL compliant.

Here is a summary of the data structures in IndexIntoFile. The persistent data consists of two vectors.

processHistoryIDs_ is a std::vector<ProcessHistoryID> that contains the ProcessHistoryIDs with one element in the vector for each unique ProcessHistoryID. On output they are ordered as they first written out for each output file. On input they are ordered as they are first seen in each process. Note that each ProcessHistoryID is stored once in this separate vector. Everywhere else it is needed it stored as an index into this vector because the ProcessHistoryID itself is large and it would take more memory to store them repeatedly in the other vectors. Note that the ProcessHistoryID's referenced in this class are always the "reduced" ProcessHistoryID's, not the ProcessHistoryID of the full ProcessHistory. You cannot use them to directly access the ProcessHistory from the ProcessHistoryRegistry.

runOrLumiEntries_ is a std::vector<RunOrLumiEntry>. This vector holds one element per entry in the run TTree and one element per entry in the lumi TTree. When sorted, everything associated with a given run and ProcessHistoryID will be contiguous in the vector. These groups of elements will be sorted by an OutputModule in the order they first appear when an Event, Lumi or Run is written to output (close to input order but because of concurrency it might not be exactly the same). Within each of these groups the run entries come first in order, followed by the elements associated with the lumis. The lumis are also contiguous and sorted by first appearance by the output module in a way similar to runs. Within a lumi they are sorted by entry order. And each luminosity element corresponds to one contiguous sequence of Events in the Events TTree. Before we implemented concurrent processing of luminosity blocks that was the full story. After that it became more complicated because the sequence of events written to an output file that were associated with a particular luminosity block TTree entry might no longer be contiguous. Events from another concurrent luminosity block could get mixed in because with multiple events processing simultaneously, there is no longer any guarantee they will finish in the same order that they were read. This is handled by writing additional elements to the runOrLumiEntries_ vector, one for each contiguous block of events associated with a particular luminosity block. Only one of these vector elements will be associated with each entry in the luminosity block TTree and all the others will contain a TTree entry number that is invalid (note the one element with a valid entry might or might not be associated with a contiguous block of events). In the sort of elements related to a particular luminosity block, the entries with invalid entry numbers will come before the valid ones.

There are a number of transient data members also. The 3 most important of these are vectors. To save memory, these are only filled when needed.

runOrLumiIndexes_ is a std::vector<RunOrLumiIndexes>. There is a one to one correspondence between the elements of this vector and the elements of runOrLumiEntries_. The elements of this vector are sorted in numerical order using the ProcessHistoryID index, the run number, and the lumi number. This ordering allows iteration in numerical order and also fast lookup based on run number and lumi number. Each element also has indexes into the eventNumbers_ and eventEntries_ vectors which hold the information giving the event numbers and event entry numbers. Note this vector is initially formed in the identical order as runOrLumiEntries_ and then sorted with a stable sort. The fact that it is a stable sort means that within the subrange associated with a particular luminosity block the elements with an invalid TTree entry number come first and the later come the elements with a valid TTree entry number which are in order of TTree entry number.

eventNumbers_ is a std::vector containing EventNumber_t's. eventEntries_ is a std::vector containing EventEntry's. If filled, both vectors contain the same number of entries with identical event numbers sorted in the same order. The only difference is that one includes the entry numbers and thus takes more memory. Each element of runOrLumiIndexes_ associated with a luminosity block has the indexes necessary to find the range inside eventNumbers_ or eventEntries_ corresponding to its lumi. Within that range the elements are sorted by event number, which is used for the numerical order iteration and to find an event by the event number.

The details of the data structure are a little different when reading files written before release 3_8_0 (backward compatibility, see RootFile::fillIndexIntoFile for the details).

This data structure is optimized for low memory usage when there are large numbers of events. The optimal case would occur when there was was one run in a file, one luminosity block in that run and everything had the same ProcessHistoryID. If duplicate checking were off and the process simply iterated through the file in the default order, then only the persistent vectors would be filled. One vector would contain 2 elements, one for the run and the other for the lumi. The other vector would contain one element, the ProcessHistoryID. Even if there were a billion events, that would be all that would exist and take up memory. The data structure is not the optimal structure for a very sparse skim, but the overheads should be tolerable given the number of runs and luminosity blocks that should occur in CMS data.

Normally only the persistent parts of the data structure are filled in the output module. The output module fills them using two functions designed specifically for that purpose. The functions are addEntry and sortVector_Run_Or_Lumi_Entries.

There are some complexities associated with filling the data structure, mostly revolving around optimizations to minimize the per event memory usage. The client needs to know which parts of the data structure to fill. See the functions below named fixIndexes, setNumberOfEvents, setEventFinder, fillEventNumbers, fillEventEntries, and inputFileClosed.

Note that this class is not intended to be used directly by the average CMS user. PoolSource and PoolOutputModule are the main clients. Other executables that read ROOT format data files, but do not use PoolSource may also need to use it directly (FWLite, Fireworks, edmFileUtil ...). The interface is too complex for general use.

Author

W. David Dagenhart, created 19 May, 2010

Definition at line 255 of file IndexIntoFile.h.

Member Typedef Documentation

EntryNumber_t

using edm::IndexIntoFile::EntryNumber_t = long long

Definition at line 261 of file IndexIntoFile.h.

Member Enumeration Documentation

EntryType

enum edm::IndexIntoFile::EntryType

Enumerator
kRun
kLumi
kEvent
kEnd

Definition at line 268 of file IndexIntoFile.h.

{ kRun, kLumi, kEvent, kEnd };

SortOrder

enum edm::IndexIntoFile::SortOrder

This enum is used to specify the order of iteration. In firstAppearanceOrder there are 3 sort criteria, in order of precedence these are:

1. firstAppearance of the ProcessHistoryID and run number in the Events TTree of the file (in cases where there are no Events in a run it depends on the order of the call to writeRun or writeLumi in the preceding step where the IndexIntoFile was created)
2. firstAppearance of the ProcessHistoryID, run number and lumi number in the Events TTree of the file (in cases where there are no Events in a lumi it depends on the order of the call to writeRun or writeLumi in the preceding step where the IndexIntoFile was created)
3. entry number

In numerical order the criteria are in order of precedence are:

1. processHistoryID index (which are normally in order of appearance in the output module)
2. run number
3. lumi number
4. event number
5. entry number

In entryOrder the order of iteration is as follows:

1. Events are processed in the exact order they appear in the input Events TTree. (The main purpose of this order is to allow fast cloning of the input Events TTree to the output Events TTree.)
2. Runs and Lumis will show up around events so that the pattern run, then contained lumi(s), then contained event(s) is always followed, but because events from a run (or lumi) may not be contiguous a particular run entry or lumi entry may appear multiple times in this ordering. Each Run entry or lumi entry will appear once with the function shouldProcessRun or shouldProcessLumi returning true. The client (usually PoolSource) must notice when these return false and not read or process them multiple times.

All runs and lumis associated with a run should be processed when the last contiguous sequence of events for that run is processed. If a run has no events, then it is interspersed within that sequence of runs according to its run TTree entry number.

1. Within a run, lumis should be processed when the last contiguous subsequence of events from that lumi is processed. If there are no events from a lumi in the last contiguous sequence of events from the run, then the lumis are interspersed within the sequence of lumis from that run in order of lumi TTree entry number.

Note that the ordering above will allow the client (usually PoolSource) to merge all run entries associated with a single run and merge all lumi entries associated with a single lumi the first time an input file is read. This is the same as in the other two orderings.

Enumerator
numericalOrder
firstAppearanceOrder
entryOrder

Definition at line 333 of file IndexIntoFile.h.

{ numericalOrder, firstAppearanceOrder, entryOrder };

Constructor & Destructor Documentation

IndexIntoFile()

edm::IndexIntoFile::IndexIntoFile

(

)

Definition at line 51 of file IndexIntoFile.cc.

: transient_(), processHistoryIDs_(), runOrLumiEntries_() {}

~IndexIntoFile()

edm::IndexIntoFile::~IndexIntoFile

(

)

Definition at line 53 of file IndexIntoFile.cc.

{}

Member Function Documentation

addEntry()

void edm::IndexIntoFile::addEntry	(	ProcessHistoryID const &	processHistoryID,
		RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event,
		EntryNumber_t	entry
	)

Used by RootOutputModule to fill the persistent data. This will not work properly if entries are not added in the same order as in RootOutputModule

Definition at line 75 of file IndexIntoFile.cc.

References addLumi(), cms::cuda::assert(), beginEvents(), currentIndex(), currentLumi(), currentRun(), endEvents(), mps_splice::entry, invalidEntry, invalidEvent, invalidIndex, invalidLumi, invalidRun, BXlumiParameters_cfi::lumi, numberOfEvents(), or, previousAddedIndex(), processHistoryID(), processHistoryIDs_, writedatasetfile::run, runOrLumiEntries_, runToOrder(), and setNumberOfEvents().

Referenced by edm::RootOutputFile::writeLuminosityBlock(), edm::RootOutputFile::writeOne(), and edm::RootOutputFile::writeRun().

                                                    {
    int index = 0;
    // First see if the ProcessHistoryID is the same as the previous one.
    // This is just a performance optimization.  We expect to usually get
    // many in a row that are the same.
    if (previousAddedIndex() != invalidIndex && processHistoryID == processHistoryIDs_[previousAddedIndex()]) {
      index = previousAddedIndex();
    } else {
      // If it was not the same as the previous one then search through the
      // entire vector.  If it is not there, it needs to be added at the
      // end.
      index = 0;
      while (index < static_cast<int>(processHistoryIDs_.size()) && processHistoryIDs_[index] != processHistoryID) {
        ++index;
      }
      if (index == static_cast<int>(processHistoryIDs_.size())) {
        processHistoryIDs_.push_back(processHistoryID);
      }
    }
    previousAddedIndex() = index;

    if (lumi == invalidLumi) {  // adding a run entry
      std::pair<IndexRunKey, EntryNumber_t> keyAndOrder{IndexRunKey{index, run}, runToOrder().size()};
      runToOrder().insert(keyAndOrder);  // does nothing if this key already was inserted
      runOrLumiEntries_.emplace_back(
          runToOrder()[IndexRunKey{index, run}], invalidEntry, entry, index, run, lumi, invalidEntry, invalidEntry);
    } else {
      if (event == invalidEvent) {  // adding a lumi entry
        if ((currentIndex() != index or currentRun() != run or currentLumi() != lumi) and
            currentLumi() != invalidLumi) {
          //we have overlapping lumis so must inject a placeholder
          addLumi(currentIndex(), currentRun(), currentLumi(), invalidEntry);
        }
        addLumi(index, run, lumi, entry);
        currentIndex() = invalidIndex;
        currentRun() = invalidRun;
        currentLumi() = invalidLumi;
        std::pair<IndexRunKey, EntryNumber_t> keyAndOrder{IndexRunKey{index, run}, runToOrder().size()};
        runToOrder().insert(keyAndOrder);  // does nothing if this key already was inserted
      } else {                             // adding an event entry
        if ((currentIndex() != index or currentRun() != run or currentLumi() != lumi) and
            currentLumi() != invalidLumi) {
          //We have overlapping lumis so need to inject a placeholder
          addLumi(currentIndex(), currentRun(), currentLumi(), invalidEntry);
        }
        setNumberOfEvents(numberOfEvents() + 1);
        if (beginEvents() == invalidEntry) {
          currentRun() = run;
          currentIndex() = index;
          currentLumi() = lumi;
          beginEvents() = entry;
          endEvents() = beginEvents() + 1;
          std::pair<IndexRunKey, EntryNumber_t> keyAndOrder{IndexRunKey{index, run}, runToOrder().size()};
          runToOrder().insert(keyAndOrder);  // does nothing if this key already was inserted
        } else {
          assert(currentIndex() == index);
          assert(currentRun() == run);
          assert(currentLumi() == lumi);
          assert(entry == endEvents());
          ++endEvents();
        }
      }
    }
  }

addLumi()

void edm::IndexIntoFile::addLumi	(	int	index,
		RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EntryNumber_t	entry
	)

Definition at line 59 of file IndexIntoFile.cc.

References beginEvents(), endEvents(), mps_splice::entry, invalidEntry, BXlumiParameters_cfi::lumi, lumiToOrder(), writedatasetfile::run, and runOrLumiEntries_.

Referenced by addEntry().

                                                                                                           {
    // assign each lumi an order value sequentially when first seen
    std::pair<IndexRunLumiKey, EntryNumber_t> keyAndOrder{IndexRunLumiKey{index, run, lumi}, lumiToOrder().size()};
    lumiToOrder().insert(keyAndOrder);  // does nothing if this key already was inserted
    runOrLumiEntries_.emplace_back(invalidEntry,
                                   lumiToOrder()[IndexRunLumiKey{index, run, lumi}],
                                   entry,
                                   index,
                                   run,
                                   lumi,
                                   beginEvents(),
                                   endEvents());
    beginEvents() = invalidEntry;
    endEvents() = invalidEntry;
  }

begin()

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::begin

(

SortOrder

sortOrder

)

const

Used to start an iteration over the Runs, Lumis, and Events in a file. Note the argument specifies the order

Definition at line 506 of file IndexIntoFile.cc.

References empty(), end(), edm::IndexIntoFile::IndexIntoFileItr::initializeRun(), invalidIndex, and kRun.

Referenced by containsDuplicateEvents(), findPosition(), iterationWillBeInEntryOrder(), edm::postIndexIntoFilePrintEventLists(), edm::postIndexIntoFilePrintEventsInLumis(), edm::RootFile::RootFile(), set_intersection(), sortEventEntries(), and sortEvents().

                                                                              {
    if (empty()) {
      return end(sortOrder);
    }
    IndexIntoFileItr iter(this, sortOrder, kRun, 0, invalidIndex, invalidIndex, 0, 0);
    iter.initializeRun();
    return iter;
  }

beginEvents()

EntryNumber_t& edm::IndexIntoFile::beginEvents ( ) const

inlineprivate

Definition at line 1285 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::beginEvents_, and transient_.

Referenced by addEntry(), addLumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesSortedByEventEntry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::fillLumisWithNoRemainingEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::gatherNeededInfo(), edm::IndexIntoFile::IndexIntoFileItrNoSort::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrNoSort::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::setToLastEventInRange(), and edm::IndexIntoFile::IndexIntoFileItrEntryOrder::setToLastEventInRange().

{ return transient_.beginEvents_; }

beginRunOrLumi()

IndexIntoFile::SortedRunOrLumiItr edm::IndexIntoFile::beginRunOrLumi

(

)

const

Definition at line 755 of file IndexIntoFile.cc.

Referenced by containsDuplicateEvents(), fillEventNumbersOrEntries(), and set_intersection().

{ return SortedRunOrLumiItr(this, 0); }

checkForMissingRunOrLumiEntry()

void edm::IndexIntoFile::checkForMissingRunOrLumiEntry

(

)

const

Run this check just after sorting.

Definition at line 405 of file IndexIntoFile.cc.

References currentLumi(), currentRun(), edm::IndexIntoFile::RunOrLumiEntry::entry(), Exception, invalidEntry, B2GTnPMonitor_cfi::item, edm::errors::LogicError, edm::IndexIntoFile::RunOrLumiEntry::lumi(), edm::IndexIntoFile::RunOrLumiEntry::run(), and runOrLumiEntries_.

Referenced by sortVector_Run_Or_Lumi_Entries().

                                                          {
    bool shouldThrow = false;
    bool foundValidLumiEntry = true;
    EntryNumber_t currentRun = invalidEntry;
    EntryNumber_t currentLumi = invalidEntry;
    EntryNumber_t previousLumi = invalidEntry;

    RunOrLumiEntry const* lastEntry = nullptr;
    for (RunOrLumiEntry const& item : runOrLumiEntries_) {
      if (item.isRun()) {
        currentRun = item.orderPHIDRun();
      } else {  // Lumi
        if (item.orderPHIDRun() != currentRun) {
          throw Exception(errors::LogicError)
              << "In IndexIntoFile::sortVector_Run_Or_Lumi_Entries. Missing Run entry.\n"
              << "If this occurs after an unrelated exception occurs, please ignore this\n"
              << "exception and fix the primary exception. This is a possible and expected\n"
              << "side effect. Otherwise, please report to Framework developers.\n"
              << "This could indicate a bug in the source or Framework\n"
              << "Run: " << item.run() << " Lumi: " << item.lumi() << " Entry: " << item.entry() << "\n";
        }
        currentLumi = item.orderPHIDRunLumi();
        if (currentLumi != previousLumi) {
          if (!foundValidLumiEntry) {
            shouldThrow = true;
            break;
          }
          foundValidLumiEntry = false;
          previousLumi = currentLumi;
        }
        if (item.entry() != invalidEntry) {
          foundValidLumiEntry = true;
        }
      }
      lastEntry = &item;
    }
    if (!foundValidLumiEntry) {
      shouldThrow = true;
    }

    if (shouldThrow) {
      throw Exception(errors::LogicError)
          << "In IndexIntoFile::sortVector_Run_Or_Lumi_Entries. Missing valid Lumi entry.\n"
          << "If this occurs after an unrelated exception occurs, please ignore this\n"
          << "exception and fix the primary exception. This is a possible and expected\n"
          << "side effect. Otherwise, please report to Framework developers.\n"
          << "This could indicate a bug in the source or Framework\n"
          << "Run: " << lastEntry->run() << " Lumi: " << lastEntry->lumi() << " Entry: " << lastEntry->entry() << "\n";
    }
  }

containsDuplicateEvents()

bool edm::IndexIntoFile::containsDuplicateEvents

(

)

const

Returns true if the IndexIntoFile contains 2 events with the same ProcessHistoryID index, run number, lumi number and event number.

Definition at line 863 of file IndexIntoFile.cc.

References begin(), edm::IndexIntoFile::RunOrLumiIndexes::beginEventNumbers(), beginRunOrLumi(), empty(), edm::IndexIntoFile::RunOrLumiIndexes::endEventNumbers(), endRunOrLumi(), eventEntries(), eventNumbers(), fillEventNumbers(), edm::IndexIntoFile::RunOrLumiIndexes::isRun(), and dqmdumpme::last.

Referenced by edm::DuplicateChecker::inputFileOpened().

                                                    {
    RunOrLumiIndexes const* previousIndexes = nullptr;

    for (SortedRunOrLumiItr iter = beginRunOrLumi(), iEnd = endRunOrLumi(); iter != iEnd; ++iter) {
      RunOrLumiIndexes const& indexes = iter.runOrLumiIndexes();

      // Skip it if it is a run or the same lumi
      if (indexes.isRun() || (previousIndexes && !(*previousIndexes < indexes))) {
        continue;
      }
      previousIndexes = &indexes;

      long long beginEventNumbers = indexes.beginEventNumbers();
      long long endEventNumbers = indexes.endEventNumbers();

      // there must be more than 1 event in the lumi for there to be any duplicates
      if (beginEventNumbers + 1 >= endEventNumbers)
        continue;

      if (!eventEntries().empty()) {
        std::vector<EventEntry>::iterator last = eventEntries().begin() + endEventNumbers;
        if (std::adjacent_find(eventEntries().begin() + beginEventNumbers, last) != last) {
          return true;
        }
      } else {
        fillEventNumbers();
        std::vector<EventNumber_t>::iterator last = eventNumbers().begin() + endEventNumbers;
        if (std::adjacent_find(eventNumbers().begin() + beginEventNumbers, last) != last) {
          return true;
        }
      }
    }
    return false;
  }

containsEvent()

bool edm::IndexIntoFile::containsEvent	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)		const

Definition at line 745 of file IndexIntoFile.cc.

References findEventPosition(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), kEnd, and writedatasetfile::run.

Referenced by containsItem().

                                                                                                            {
    return findEventPosition(run, lumi, event).getEntryType() != kEnd;
  }

containsItem()

bool edm::IndexIntoFile::containsItem	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)		const

Definition at line 741 of file IndexIntoFile.cc.

References containsEvent(), containsLumi(), containsRun(), and writedatasetfile::run.

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

                                                                                                           {
    return (event != 0) ? containsEvent(run, lumi, event) : (lumi ? containsLumi(run, lumi) : containsRun(run));
  }

containsLumi()

bool edm::IndexIntoFile::containsLumi	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)		const

Definition at line 749 of file IndexIntoFile.cc.

References findLumiPosition(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), kEnd, and writedatasetfile::run.

Referenced by containsItem().

                                                                                      {
    return findLumiPosition(run, lumi).getEntryType() != kEnd;
  }

containsRun()

bool edm::IndexIntoFile::containsRun

(

RunNumber_t

run

)

const

Definition at line 753 of file IndexIntoFile.cc.

References findRunPosition(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), kEnd, and writedatasetfile::run.

Referenced by containsItem().

{ return findRunPosition(run).getEntryType() != kEnd; }

currentIndex()

int& edm::IndexIntoFile::currentIndex ( ) const

inlineprivate

Definition at line 1287 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::currentIndex_, and transient_.

Referenced by addEntry(), and edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesSortedByEventEntry().

{ return transient_.currentIndex_; }

currentLumi()

LuminosityBlockNumber_t& edm::IndexIntoFile::currentLumi ( ) const

inlineprivate

Definition at line 1289 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::currentLumi_, and transient_.

Referenced by addEntry(), checkForMissingRunOrLumiEntry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesToLastContiguousEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::fillLumisWithNoRemainingEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiEntriesNoRemainingEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiWithEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInLumis(), and edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lowestInLumi().

{ return transient_.currentLumi_; }

currentRun()

RunNumber_t& edm::IndexIntoFile::currentRun ( ) const

inlineprivate

Definition at line 1288 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::currentRun_, and transient_.

Referenced by addEntry(), checkForMissingRunOrLumiEntry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesToLastContiguousEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::fillLumisWithNoRemainingEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInLumis(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInRun(), and edm::IndexIntoFile::IndexIntoFileItrEntryOrder::IndexIntoFileItrEntryOrder().

{ return transient_.currentRun_; }

doneFileInitialization()

void edm::IndexIntoFile::doneFileInitialization

(

)

Clears the temporary vector of event numbers to reduce memory usage.

Definition at line 299 of file IndexIntoFile.cc.

References edm::swap(), and unsortedEventNumbers().

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

{ std::vector<EventNumber_t>().swap(unsortedEventNumbers()); }

empty()

bool edm::IndexIntoFile::empty

(

)

const

True if no runs, lumis, or events are in the file.

Definition at line 532 of file IndexIntoFile.cc.

References runOrLumiEntries().

Referenced by begin(), containsDuplicateEvents(), fwlite::EntryFinder::empty(), fillEventNumbersOrEntries(), fillUnsortedEventNumbers(), fwlite::EntryFinder::findEvent(), fwlite::EntryFinder::findLumi(), findPosition(), fwlite::EntryFinder::findRun(), set_intersection(), and edm::RootFile::validateFile().

{ return runOrLumiEntries().empty(); }

end()

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::end

(

SortOrder

sortOrder

)

const

Used to end an iteration over the Runs, Lumis, and Events in a file.

Definition at line 515 of file IndexIntoFile.cc.

References invalidIndex, and kEnd.

Referenced by begin(), Types.LuminosityBlockRange::cppID(), Types.EventRange::cppID(), fwlite::EntryFinder::findEvent(), fwlite::EntryFinder::findLumi(), findPosition(), fwlite::EntryFinder::findRun(), edm::RootFile::goToEvent(), iterationWillBeInEntryOrder(), edm::postIndexIntoFilePrintEventLists(), edm::postIndexIntoFilePrintEventsInLumis(), and edm::RootFile::RootFile().

                                                                            {
    return IndexIntoFileItr(this, sortOrder, kEnd, invalidIndex, invalidIndex, invalidIndex, 0, 0);
  }

endEvents()

EntryNumber_t& edm::IndexIntoFile::endEvents ( ) const

inlineprivate

Definition at line 1286 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::endEvents_, and transient_.

Referenced by addEntry(), addLumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesSortedByEventEntry(), edm::IndexIntoFile::IndexIntoFileItrNoSort::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrNoSort::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::setToLastEventInRange(), and edm::IndexIntoFile::IndexIntoFileItrEntryOrder::setToLastEventInRange().

{ return transient_.endEvents_; }

endRunOrLumi()

IndexIntoFile::SortedRunOrLumiItr edm::IndexIntoFile::endRunOrLumi

(

)

const

Definition at line 757 of file IndexIntoFile.cc.

References runOrLumiEntries(), and findQualityFiles::size.

Referenced by containsDuplicateEvents(), fillEventNumbersOrEntries(), and set_intersection().

                                                                    {
    return SortedRunOrLumiItr(this, runOrLumiEntries().size());
  }

eventEntries()

std::vector<EventEntry>& edm::IndexIntoFile::eventEntries ( ) const

inlineprivate

Definition at line 1278 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::eventEntries_, and transient_.

Referenced by containsDuplicateEvents(), fillEventNumbersOrEntries(), findPosition(), inputFileClosed(), set_intersection(), and sortEventEntries().

{ return transient_.eventEntries_; }

eventNumbers()

std::vector<EventNumber_t>& edm::IndexIntoFile::eventNumbers ( ) const

inlineprivate

Definition at line 1279 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::eventNumbers_, and transient_.

Referenced by containsDuplicateEvents(), fillEventNumbersOrEntries(), findPosition(), set_intersection(), and sortEvents().

{ return transient_.eventNumbers_; }

fillEventEntries()

void edm::IndexIntoFile::fillEventEntries

(

)

const

Fills a vector of objects that contain an event number and the corresponding TTree entry number for the event. Not filling it reduces the memory used by IndexIntoFile. As long as the event finder is still pointing at an open file this will automatically be called on demand (when the event numbers and entries are are needed). It makes sense for the client to fill this explicitly in advance if it is known that it will be needed, because in some cases this will prevent the event numbers vector from being unnecessarily filled (wasting memory). This vector will be needed when iterating over events in numerical order or looking up specific events. The entry numbers are needed if the events are actually read from the input file.

Definition at line 193 of file IndexIntoFile.cc.

References fillEventNumbersOrEntries().

{ fillEventNumbersOrEntries(false, true); }

fillEventNumbers()

void edm::IndexIntoFile::fillEventNumbers

(

)

const

Fills a vector of event numbers. Not filling it reduces the memory used by IndexIntoFile. As long as the event finder is still pointing at an open file this will automatically be called on demand (when the event numbers are are needed). In cases, where the input file may be closed when the need arises, the client code must call this explicitly and fill the vector before the file is closed. In PoolSource, this is necessary when duplicate checking across all files and when doing lookups to see if an event is in a previously opened file. Either this vector or the one that also contains event entry numbers can be used when looking for duplicate events within the same file or looking up events in in the current file without reading them.

Definition at line 191 of file IndexIntoFile.cc.

References fillEventNumbersOrEntries().

Referenced by containsDuplicateEvents(), findPosition(), edm::RootFile::goToEvent(), and set_intersection().

{ fillEventNumbersOrEntries(true, false); }

fillEventNumbersOrEntries()

void edm::IndexIntoFile::fillEventNumbersOrEntries	(	bool	needEventNumbers,
		bool	needEventEntries
	)		const

If needEventNumbers is true then this function does the same thing as fillEventNumbers. If NeedEventEntries is true, then this function does the same thing as fillEventEntries. If both are true, it fills both within the same loop and it uses less CPU than calling those two functions separately.

Definition at line 195 of file IndexIntoFile.cc.

References cms::cuda::assert(), beginRunOrLumi(), empty(), endRunOrLumi(), mps_splice::entry, edmPickEvents::event, eventEntries(), eventNumbers(), fillUnsortedEventNumbers(), invalidEntry, invalidEvent, L1DTConfigBti_cff::LL, numberOfEvents(), hltrates_dqm_sourceclient-live_cfg::offset, findQualityFiles::size, sortEventEntries(), sortEvents(), mitigatedMETSequence_cff::U, and unsortedEventNumbers().

Referenced by fillEventEntries(), fillEventNumbers(), and edm::RootFile::validateFile().

                                                                                                  {
    if (numberOfEvents() == 0) {
      return;
    }

    if (needEventNumbers && !eventNumbers().empty()) {
      needEventNumbers = false;
    }

    if (needEventEntries && !eventEntries().empty()) {
      needEventEntries = false;
    }

    if (needEventNumbers && !eventEntries().empty()) {
      assert(numberOfEvents() == eventEntries().size());
      eventNumbers().reserve(eventEntries().size());
      for (std::vector<EventNumber_t>::size_type entry = 0U; entry < numberOfEvents(); ++entry) {
        eventNumbers().push_back(eventEntries()[entry].event());
      }
      return;
    }

    if (!needEventNumbers && !needEventEntries) {
      return;
    }

    fillUnsortedEventNumbers();

    if (needEventNumbers) {
      eventNumbers().resize(numberOfEvents(), IndexIntoFile::invalidEvent);
    }
    if (needEventEntries) {
      eventEntries().resize(numberOfEvents());
    }

    long long offset = 0;
    long long previousBeginEventNumbers = -1LL;

    for (SortedRunOrLumiItr runOrLumi = beginRunOrLumi(), runOrLumiEnd = endRunOrLumi(); runOrLumi != runOrLumiEnd;
         ++runOrLumi) {
      if (runOrLumi.isRun())
        continue;

      long long beginEventNumbers = 0;
      long long endEventNumbers = 0;
      EntryNumber_t beginEventEntry = invalidEntry;
      EntryNumber_t endEventEntry = invalidEntry;
      runOrLumi.getRange(beginEventNumbers, endEventNumbers, beginEventEntry, endEventEntry);

      // This is true each time one hits a new lumi section (except if the previous lumi had
      // no events, in which case the offset is still 0 anyway)
      if (beginEventNumbers != previousBeginEventNumbers)
        offset = 0;

      for (EntryNumber_t entry = beginEventEntry; entry != endEventEntry; ++entry) {
        if (needEventNumbers) {
          eventNumbers().at((entry - beginEventEntry) + offset + beginEventNumbers) = unsortedEventNumbers().at(entry);
        }
        if (needEventEntries) {
          eventEntries().at((entry - beginEventEntry) + offset + beginEventNumbers) =
              EventEntry(unsortedEventNumbers().at(entry), entry);
        }
      }

      previousBeginEventNumbers = beginEventNumbers;
      offset += endEventEntry - beginEventEntry;
    }
    if (needEventNumbers) {
      sortEvents();
      assert(numberOfEvents() == eventNumbers().size());
    }
    if (needEventEntries) {
      sortEventEntries();
      assert(numberOfEvents() == eventEntries().size());
    }
  }

fillRunOrLumiIndexes()

void edm::IndexIntoFile::fillRunOrLumiIndexes ( ) const

private

This function will automatically get called when needed. It depends only on the fact that the persistent data has been filled already.

Definition at line 144 of file IndexIntoFile.cc.

References cms::cuda::assert(), invalidEntry, B2GTnPMonitor_cfi::item, submitPVValidationJobs::nEvents, runOrLumiEntries_, runOrLumiIndexes(), findQualityFiles::size, and edm::stable_sort_all().

Referenced by findPosition(), edm::IndexIntoFile::IndexIntoFileItrSorted::IndexIntoFileItrSorted(), set_intersection(), edm::IndexIntoFile::SortedRunOrLumiItr::SortedRunOrLumiItr(), sortEventEntries(), and sortEvents().

                                                 {
    if (runOrLumiEntries_.empty() || !runOrLumiIndexes().empty()) {
      return;
    }
    runOrLumiIndexes().reserve(runOrLumiEntries_.size());

    int index = 0;
    for (RunOrLumiEntry const& item : runOrLumiEntries_) {
      runOrLumiIndexes().emplace_back(item.processHistoryIDIndex(), item.run(), item.lumi(), index);
      ++index;
    }
    stable_sort_all(runOrLumiIndexes());

    long long beginEventNumbers = 0;

    std::vector<RunOrLumiIndexes>::iterator beginOfLumi = runOrLumiIndexes().begin();
    std::vector<RunOrLumiIndexes>::iterator endOfLumi = beginOfLumi;
    std::vector<RunOrLumiIndexes>::iterator iEnd = runOrLumiIndexes().end();
    while (true) {
      while (beginOfLumi != iEnd && beginOfLumi->isRun()) {
        ++beginOfLumi;
      }
      if (beginOfLumi == iEnd)
        break;

      endOfLumi = beginOfLumi + 1;
      while (endOfLumi != iEnd && beginOfLumi->processHistoryIDIndex() == endOfLumi->processHistoryIDIndex() &&
             beginOfLumi->run() == endOfLumi->run() && beginOfLumi->lumi() == endOfLumi->lumi()) {
        ++endOfLumi;
      }
      int nEvents = 0;
      for (std::vector<RunOrLumiIndexes>::iterator iter = beginOfLumi; iter != endOfLumi; ++iter) {
        if (runOrLumiEntries_[iter->indexToGetEntry()].beginEvents() != invalidEntry) {
          nEvents += runOrLumiEntries_[iter->indexToGetEntry()].endEvents() -
                     runOrLumiEntries_[iter->indexToGetEntry()].beginEvents();
        }
      }
      for (std::vector<RunOrLumiIndexes>::iterator iter = beginOfLumi; iter != endOfLumi; ++iter) {
        iter->setBeginEventNumbers(beginEventNumbers);
        iter->setEndEventNumbers(beginEventNumbers + nEvents);
      }
      beginEventNumbers += nEvents;
      beginOfLumi = endOfLumi;
    }
    assert(runOrLumiIndexes().size() == runOrLumiEntries_.size());
  }

fillUnsortedEventNumbers()

void edm::IndexIntoFile::fillUnsortedEventNumbers ( ) const

private

Definition at line 272 of file IndexIntoFile.cc.

References empty(), mps_splice::entry, getEventNumberOfEntry(), numberOfEvents(), mitigatedMETSequence_cff::U, unsortedEventNumbers(), and unsortedEventNumbersMutable().

Referenced by fillEventNumbersOrEntries().

                                                     {
    if (numberOfEvents() == 0 || !unsortedEventNumbers().empty()) {
      return;
    }
    unsortedEventNumbersMutable().reserve(numberOfEvents());

    // The main purpose for the existence of the unsortedEventNumbers
    // vector is that it can easily be filled by reading through
    // the EventAuxiliary branch in the same order as the TTree
    // entries. fillEventNumbersOrEntries can then use this information
    // instead of using getEventNumberOfEntry directly and reading
    // the branch in a different order.
    for (std::vector<EventNumber_t>::size_type entry = 0U; entry < numberOfEvents(); ++entry) {
      unsortedEventNumbersMutable().push_back(getEventNumberOfEntry(entry));
    }
  }

findEventPosition()

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::findEventPosition	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)		const

Same as findPosition,except the entry type of the returned iterator will be kEvent or kEnd and the event argument must be nonzero. This means the next thing to be processed will be the event if it is found.

Definition at line 721 of file IndexIntoFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToEvent(), cms::cuda::assert(), findPosition(), invalidEvent, and writedatasetfile::run.

Referenced by containsEvent(), fwlite::EntryFinder::findEvent(), and edm::RootFile::setEntryAtEvent().

                                                                                              {
    assert(event != invalidEvent);
    IndexIntoFileItr iter = findPosition(run, lumi, event);
    iter.advanceToEvent();
    return iter;
  }

findLumiPosition()

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::findLumiPosition	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)		const

Same as findPosition,except the entry type of the returned iterator will be kLumi or kEnd and the lumi argument must be nonzero. This means the next thing to be processed will be the lumi if it is found.

Definition at line 730 of file IndexIntoFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToLumi(), cms::cuda::assert(), findPosition(), invalidLumi, writedatasetfile::run, and mitigatedMETSequence_cff::U.

Referenced by containsLumi(), fwlite::EntryFinder::findLumi(), and edm::RootFile::setEntryAtLumi().

                                                                                                                   {
    assert(lumi != invalidLumi);
    IndexIntoFileItr iter = findPosition(run, lumi, 0U);
    iter.advanceToLumi();
    return iter;
  }

findPosition() [1/2]

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::findPosition	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi = 0U,
		EventNumber_t	event = 0U
	)		const

Find a run, lumi, or event. Returns an iterator pointing at it. The iterator will always be in numericalOrder mode. If it is not found the entry type of the iterator will be kEnd. If it is found the entry type of the iterator will always be kRun so the next thing to be processed is the run containing the desired lumi or event or if looking for a run, the run itself. If the lumi and event arguments are 0 (invalid), then it will find a run. If only the event argument is 0 (invalid), then it will find a lumi. If will look for an event if all three arguments are nonzero or if only the lumi argument is 0 (invalid). Note that it will find the first match only so if there is more than one match then the others cannot be found with this method. The order of the search is by processHistoryID index, then run number, then lumi number, then event entry. If searching for a lumi the iterator will advance directly to the desired lumi after the run even if it is not the first lumi in the run. If searching for an event, the iterator will advance to the lumi containing the run and then the requested event after run even if there are other lumis earlier in that run and other events earlier in that lumi.

Definition at line 534 of file IndexIntoFile.cc.

References cms::cuda::assert(), begin(), empty(), mps_splice::entry, edmPickEvents::event, eventEntries(), eventNumbers(), fillEventNumbers(), fillRunOrLumiIndexes(), edm::IndexIntoFile::IndexIntoFileItr::initializeLumi(), edm::IndexIntoFile::IndexIntoFileItr::initializeRun(), invalidEntry, invalidEvent, invalidIndex, invalidLumi, kEnd, kRun, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, BXlumiParameters_cfi::lumi, numericalOrder, writedatasetfile::run, runOrLumiEntries_, runOrLumiIndexes(), and pfDeepBoostedJetPreprocessParams_cfi::upper_bound.

Referenced by findEventPosition(), findLumiPosition(), findPosition(), findRunPosition(), and edm::RootFile::goToEvent().

                                                                                         {
    fillRunOrLumiIndexes();

    bool lumiMissing = (lumi == 0 && event != 0);

    std::vector<RunOrLumiIndexes>::const_iterator iEnd = runOrLumiIndexes().end();
    std::vector<RunOrLumiIndexes>::const_iterator phEnd;

    // Loop over ranges of entries with the same ProcessHistoryID
    for (std::vector<RunOrLumiIndexes>::const_iterator phBegin = runOrLumiIndexes().begin(); phBegin != iEnd;
         phBegin = phEnd) {
      RunOrLumiIndexes el(phBegin->processHistoryIDIndex(), run, lumi, 0);
      phEnd = std::upper_bound(phBegin, iEnd, el, Compare_Index());

      std::vector<RunOrLumiIndexes>::const_iterator iRun = std::lower_bound(phBegin, phEnd, el, Compare_Index_Run());

      if (iRun == phEnd || iRun->run() != run)
        continue;

      if (lumi == invalidLumi && event == invalidEvent) {
        IndexIntoFileItr indexItr(
            this, numericalOrder, kRun, iRun - runOrLumiIndexes().begin(), invalidIndex, invalidIndex, 0, 0);
        indexItr.initializeRun();
        return indexItr;
      }

      std::vector<RunOrLumiIndexes>::const_iterator iRunEnd = std::upper_bound(iRun, phEnd, el, Compare_Index_Run());
      if (!lumiMissing) {
        std::vector<RunOrLumiIndexes>::const_iterator iLumi = std::lower_bound(iRun, iRunEnd, el);
        if (iLumi == iRunEnd || iLumi->lumi() != lumi)
          continue;

        if (event == invalidEvent) {
          IndexIntoFileItr indexItr(this,
                                    numericalOrder,
                                    kRun,
                                    iRun - runOrLumiIndexes().begin(),
                                    iLumi - runOrLumiIndexes().begin(),
                                    invalidIndex,
                                    0,
                                    0);
          indexItr.initializeLumi();
          return indexItr;
        }

        long long beginEventNumbers = iLumi->beginEventNumbers();
        long long endEventNumbers = iLumi->endEventNumbers();
        if (beginEventNumbers >= endEventNumbers)
          continue;

        long long indexToEvent = 0;
        if (!eventEntries().empty()) {
          std::vector<EventEntry>::const_iterator eventIter =
              std::lower_bound(eventEntries().begin() + beginEventNumbers,
                               eventEntries().begin() + endEventNumbers,
                               EventEntry(event, invalidEntry));
          if (eventIter == (eventEntries().begin() + endEventNumbers) || eventIter->event() != event)
            continue;

          indexToEvent = eventIter - eventEntries().begin() - beginEventNumbers;
        } else {
          fillEventNumbers();
          std::vector<EventNumber_t>::const_iterator eventIter = std::lower_bound(
              eventNumbers().begin() + beginEventNumbers, eventNumbers().begin() + endEventNumbers, event);
          if (eventIter == (eventNumbers().begin() + endEventNumbers) || *eventIter != event)
            continue;

          indexToEvent = eventIter - eventNumbers().begin() - beginEventNumbers;
        }

        int newIndexToLumi = iLumi - runOrLumiIndexes().begin();
        while (runOrLumiEntries_[runOrLumiIndexes()[newIndexToLumi].indexToGetEntry()].entry() == invalidEntry) {
          ++newIndexToLumi;
          assert(static_cast<unsigned>(newIndexToLumi) < runOrLumiEntries_.size());
          assert(runOrLumiIndexes()[newIndexToLumi].lumi() == lumi);
        }

        return IndexIntoFileItr(this,
                                numericalOrder,
                                kRun,
                                iRun - runOrLumiIndexes().begin(),
                                newIndexToLumi,
                                iLumi - runOrLumiIndexes().begin(),
                                indexToEvent,
                                endEventNumbers - beginEventNumbers);
      }
      if (lumiMissing) {
        std::vector<RunOrLumiIndexes>::const_iterator iLumi = iRun;
        while (iLumi != iRunEnd && iLumi->lumi() == invalidLumi) {
          ++iLumi;
        }
        if (iLumi == iRunEnd)
          continue;

        std::vector<RunOrLumiIndexes>::const_iterator lumiEnd;
        for (; iLumi != iRunEnd; iLumi = lumiEnd) {
          RunOrLumiIndexes elWithLumi(phBegin->processHistoryIDIndex(), run, iLumi->lumi(), 0);
          lumiEnd = std::upper_bound(iLumi, iRunEnd, elWithLumi);

          long long beginEventNumbers = iLumi->beginEventNumbers();
          long long endEventNumbers = iLumi->endEventNumbers();
          if (beginEventNumbers >= endEventNumbers)
            continue;

          long long indexToEvent = 0;
          if (!eventEntries().empty()) {
            std::vector<EventEntry>::const_iterator eventIter =
                std::lower_bound(eventEntries().begin() + beginEventNumbers,
                                 eventEntries().begin() + endEventNumbers,
                                 EventEntry(event, invalidEntry));
            if (eventIter == (eventEntries().begin() + endEventNumbers) || eventIter->event() != event)
              continue;
            indexToEvent = eventIter - eventEntries().begin() - beginEventNumbers;
          } else {
            fillEventNumbers();
            std::vector<EventNumber_t>::const_iterator eventIter = std::lower_bound(
                eventNumbers().begin() + beginEventNumbers, eventNumbers().begin() + endEventNumbers, event);
            if (eventIter == (eventNumbers().begin() + endEventNumbers) || *eventIter != event)
              continue;
            indexToEvent = eventIter - eventNumbers().begin() - beginEventNumbers;
          }

          int newIndexToLumi = iLumi - runOrLumiIndexes().begin();
          while (runOrLumiEntries_[runOrLumiIndexes()[newIndexToLumi].indexToGetEntry()].entry() == invalidEntry) {
            ++newIndexToLumi;
            assert(static_cast<unsigned>(newIndexToLumi) < runOrLumiEntries_.size());
            assert(runOrLumiIndexes()[newIndexToLumi].lumi() == iLumi->lumi());
          }

          return IndexIntoFileItr(this,
                                  numericalOrder,
                                  kRun,
                                  iRun - runOrLumiIndexes().begin(),
                                  newIndexToLumi,
                                  iLumi - runOrLumiIndexes().begin(),
                                  indexToEvent,
                                  endEventNumbers - beginEventNumbers);
        }
      }
    }  // Loop over ProcessHistoryIDs

    return IndexIntoFileItr(this, numericalOrder, kEnd, invalidIndex, invalidIndex, invalidIndex, 0, 0);
  }

findPosition() [2/2]

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::findPosition	(	SortOrder	sortOrder,
		RunNumber_t	run,
		LuminosityBlockNumber_t	lumi = 0U,
		EventNumber_t	event = 0U
	)		const

Definition at line 680 of file IndexIntoFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToNextRun(), begin(), end(), findPosition(), getEventNumberOfEntry(), invalidEvent, invalidLumi, BXlumiParameters_cfi::lumi, numericalOrder, edm::IndexIntoFile::IndexIntoFileItr::peekAheadAtEventEntry(), edm::IndexIntoFile::IndexIntoFileItr::peekAheadAtLumi(), writedatasetfile::run, edm::IndexIntoFile::IndexIntoFileItr::run(), edm::IndexIntoFile::IndexIntoFileItr::skipLumiInRun(), and edm::IndexIntoFile::IndexIntoFileItr::skipToNextEventInLumi().

                                                                                         {
    if (sortOrder == IndexIntoFile::numericalOrder) {
      return findPosition(run, lumi, event);  // a faster algorithm
    }
    IndexIntoFileItr itr = begin(sortOrder);
    IndexIntoFileItr itrEnd = end(sortOrder);

    while (itr != itrEnd) {
      if (itr.run() != run) {
        itr.advanceToNextRun();
      } else {
        if (lumi == invalidLumi && event == invalidEvent) {
          return itr;
        } else if (lumi != invalidLumi && itr.peekAheadAtLumi() != lumi) {
          if (!itr.skipLumiInRun()) {
            itr.advanceToNextRun();
          }
        } else {
          if (event == invalidEvent) {
            return itr;
          } else {
            EventNumber_t eventNumber = getEventNumberOfEntry(itr.peekAheadAtEventEntry());
            if (eventNumber == event) {
              return itr;
            } else {
              if (!itr.skipToNextEventInLumi()) {
                if (!itr.skipLumiInRun()) {
                  itr.advanceToNextRun();
                }
              }
            }
          }
        }
      }
    }
    return itrEnd;
  }

findRunPosition()

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::findRunPosition

(

RunNumber_t

run

)

const

Same as findPosition.

Definition at line 737 of file IndexIntoFile.cc.

References findPosition(), writedatasetfile::run, and mitigatedMETSequence_cff::U.

Referenced by containsRun(), fwlite::EntryFinder::findRun(), and edm::RootFile::setEntryAtRun().

                                                                                    {
    return findPosition(run, 0U, 0U);
  }

fixIndexes()

void edm::IndexIntoFile::fixIndexes

(

std::vector< ProcessHistoryID > &

processHistoryIDs

)

Used by PoolSource to force the ProcessHistoryID indexes to be consistent across all input files. Currently this consistency is important when duplicate checking across all input files. It may be important for other reasons in the future. It is important this be called immediately after reading in the object from the input file, before filling the transient data members or using the indexes in any way.

Definition at line 363 of file IndexIntoFile.cc.

References spr::find(), B2GTnPMonitor_cfi::item, processHistoryIDs(), processHistoryIDs_, and runOrLumiEntries_.

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

                                                                               {
    std::map<int, int> oldToNewIndex;
    for (std::vector<ProcessHistoryID>::const_iterator iter = processHistoryIDs_.begin(),
                                                       iEnd = processHistoryIDs_.end();
         iter != iEnd;
         ++iter) {
      std::vector<ProcessHistoryID>::const_iterator iterExisting =
          std::find(processHistoryIDs.begin(), processHistoryIDs.end(), *iter);
      if (iterExisting == processHistoryIDs.end()) {
        oldToNewIndex[iter - processHistoryIDs_.begin()] = processHistoryIDs.size();
        processHistoryIDs.push_back(*iter);
      } else {
        oldToNewIndex[iter - processHistoryIDs_.begin()] = iterExisting - processHistoryIDs.begin();
      }
    }
    processHistoryIDs_ = processHistoryIDs;

    for (RunOrLumiEntry& item : runOrLumiEntries_) {
      item.setProcessHistoryIDIndex(oldToNewIndex[item.processHistoryIDIndex()]);
    }
  }

getEventNumberOfEntry()

EventNumber_t edm::IndexIntoFile::getEventNumberOfEntry ( EntryNumber_t  entry ) const

inlineprivate

Definition at line 1292 of file IndexIntoFile.h.

References mps_splice::entry, edm::IndexIntoFile::Transients::eventFinder_, and transient_.

Referenced by fillUnsortedEventNumbers(), and findPosition().

                                                                   {
      return transient_.eventFinder_->getEventNumberOfEntry(entry);
    }

initializeTransients()

void edm::IndexIntoFile::initializeTransients ( )

inline

Definition at line 1241 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::reset(), and transient_.

{ transient_.reset(); }

inputFileClosed()

void edm::IndexIntoFile::inputFileClosed

(

)

Clear some vectors and eventFinder when an input file is closed. This reduces the memory used by IndexIntoFile

Definition at line 292 of file IndexIntoFile.cc.

References eventEntries(), resetEventFinder(), runOrLumiIndexes(), edm::swap(), and unsortedEventNumbers().

                                      {
    std::vector<EventEntry>().swap(eventEntries());
    std::vector<RunOrLumiIndexes>().swap(runOrLumiIndexes());
    std::vector<EventNumber_t>().swap(unsortedEventNumbers());
    resetEventFinder();
  }

iterationWillBeInEntryOrder()

bool edm::IndexIntoFile::iterationWillBeInEntryOrder

(

SortOrder

sortOrder

)

const

Used to determine whether or not to disable fast cloning.

Definition at line 519 of file IndexIntoFile.cc.

References begin(), end(), invalidEntry, and kEvent.

Referenced by edm::postIndexIntoFilePrintEventLists(), and edm::RootFile::setIfFastClonable().

                                                                           {
    EntryNumber_t maxEntry = invalidEntry;
    for (IndexIntoFileItr it = begin(sortOrder), itEnd = end(sortOrder); it != itEnd; ++it) {
      if (it.getEntryType() == kEvent) {
        if (it.entry() < maxEntry) {
          return false;
        }
        maxEntry = it.entry();
      }
    }
    return true;
  }

lumiToOrder()

std::map<IndexRunLumiKey, EntryNumber_t>& edm::IndexIntoFile::lumiToOrder ( ) const

inlineprivate

Definition at line 1284 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::lumiToOrder_, and transient_.

Referenced by addLumi().

{ return transient_.lumiToOrder_; }

numberOfEvents()

size_t edm::IndexIntoFile::numberOfEvents ( ) const

inlineprivate

Definition at line 1291 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::numberOfEvents_, and transient_.

Referenced by addEntry(), fillEventNumbersOrEntries(), and fillUnsortedEventNumbers().

{ return transient_.numberOfEvents_; }

previousAddedIndex()

int& edm::IndexIntoFile::previousAddedIndex ( ) const

inlineprivate

Definition at line 1282 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::previousAddedIndex_, and transient_.

Referenced by addEntry().

{ return transient_.previousAddedIndex_; }

processHistoryID()

ProcessHistoryID const & edm::IndexIntoFile::processHistoryID

(

int

i

)

const

Definition at line 55 of file IndexIntoFile.cc.

References mps_fire::i, and processHistoryIDs_.

Referenced by addEntry(), and edm::RootFile::readCurrentEvent().

{ return processHistoryIDs_.at(i); }

processHistoryIDs()

std::vector< ProcessHistoryID > const & edm::IndexIntoFile::processHistoryIDs

(

)

const

Definition at line 57 of file IndexIntoFile.cc.

References processHistoryIDs_.

Referenced by fixIndexes().

{ return processHistoryIDs_; }

reduceProcessHistoryIDs()

void edm::IndexIntoFile::reduceProcessHistoryIDs

(

ProcessHistoryRegistry const &

processHistoryRegistry

)

Used for backward compatibility to convert objects created with releases that used the full ProcessHistoryID in IndexIntoFile to use the reduced ProcessHistoryID.

Definition at line 301 of file IndexIntoFile.cc.

References B2GTnPMonitor_cfi::item, processHistoryIDs_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), and runOrLumiEntries_.

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

                                                                                                  {
    std::vector<ProcessHistoryID> reducedPHIDs;

    std::map<ProcessHistoryID, int> reducedPHIDToIndex;
    std::pair<ProcessHistoryID, int> mapEntry(ProcessHistoryID(), 0);
    std::pair<std::map<ProcessHistoryID, int>::iterator, bool> insertResult;

    std::vector<int> phidIndexConverter;
    for (auto const& phid : processHistoryIDs_) {
      ProcessHistoryID const& reducedPHID = processHistoryRegistry.reducedProcessHistoryID(phid);
      mapEntry.first = reducedPHID;
      insertResult = reducedPHIDToIndex.insert(mapEntry);

      if (insertResult.second) {
        insertResult.first->second = reducedPHIDs.size();
        reducedPHIDs.push_back(reducedPHID);
      }
      phidIndexConverter.push_back(insertResult.first->second);
    }
    processHistoryIDs_.swap(reducedPHIDs);

    // If the size of the vector of IDs does not change
    // then their indexes and the ordering of the Runs and
    // and Lumis does not change, so we are done.
    if (processHistoryIDs_.size() == reducedPHIDs.size()) {
      return;
    }

    std::map<IndexIntoFile::IndexRunKey, int> runOrderMap;
    std::pair<std::map<IndexIntoFile::IndexRunKey, int>::iterator, bool> runInsertResult;

    std::map<IndexIntoFile::IndexRunLumiKey, int> lumiOrderMap;
    std::pair<std::map<IndexIntoFile::IndexRunLumiKey, int>::iterator, bool> lumiInsertResult;

    // loop over all the RunOrLumiEntry's
    for (auto& item : runOrLumiEntries_) {
      // Convert the process history index so it points into the new vector of reduced IDs
      item.setProcessHistoryIDIndex(phidIndexConverter.at(item.processHistoryIDIndex()));

      // Convert the phid-run order
      IndexIntoFile::IndexRunKey runKey(item.processHistoryIDIndex(), item.run());
      runInsertResult = runOrderMap.insert(std::pair<IndexIntoFile::IndexRunKey, int>(runKey, 0));
      if (runInsertResult.second) {
        runInsertResult.first->second = item.orderPHIDRun();
      } else {
        item.setOrderPHIDRun(runInsertResult.first->second);
      }

      // Convert the phid-run-lumi order for the lumi entries
      if (item.lumi() != 0) {
        IndexIntoFile::IndexRunLumiKey lumiKey(item.processHistoryIDIndex(), item.run(), item.lumi());
        lumiInsertResult = lumiOrderMap.insert(std::pair<IndexIntoFile::IndexRunLumiKey, int>(lumiKey, 0));
        if (lumiInsertResult.second) {
          lumiInsertResult.first->second = item.orderPHIDRunLumi();
        } else {
          item.setOrderPHIDRunLumi(lumiInsertResult.first->second);
        }
      }
    }
    std::stable_sort(runOrLumiEntries_.begin(), runOrLumiEntries_.end());
  }

resetEventFinder()

void edm::IndexIntoFile::resetEventFinder ( ) const

inlineprivate

Definition at line 1277 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::eventFinder_, and transient_.

Referenced by inputFileClosed().

{ transient_.eventFinder_ = nullptr; }  // propagate_const<T> has no reset() function

runOrLumiEntries()

std::vector<RunOrLumiEntry> const& edm::IndexIntoFile::runOrLumiEntries ( ) const

inline

Used internally and for test purposes.

Definition at line 1236 of file IndexIntoFile.h.

References runOrLumiEntries_.

Referenced by edm::IndexIntoFile::IndexIntoFileItrEntryOrder::addRunsWithNoEvents(), empty(), endRunOrLumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesSortedByEventEntry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesToLastContiguousEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::fillLumisWithNoRemainingEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::gatherNeededInfo(), edm::IndexIntoFile::IndexIntoFileItrNoSort::getRunOrLumiEntryType(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiEntriesNoRemainingEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumisWithNoEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiWithEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInLumis(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInRun(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::IndexIntoFileItrEntryOrder(), edm::IndexIntoFile::IndexIntoFileItrNoSort::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lowestInLumi(), edm::IndexIntoFile::IndexIntoFileItrNoSort::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::nextEventSequence(), edm::IndexIntoFile::IndexIntoFileItrNoSort::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::resizeVectors(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::runOrLumisEntry(), edm::IndexIntoFile::IndexIntoFileItrNoSort::setToLastEventInRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::skipLumiInRun(), and edm::IndexIntoFile::SortedRunOrLumiItr::SortedRunOrLumiItr().

{ return runOrLumiEntries_; }

runOrLumiIndexes()

std::vector<RunOrLumiIndexes>& edm::IndexIntoFile::runOrLumiIndexes ( ) const

inlineprivate

Definition at line 1290 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::runOrLumiIndexes_, and transient_.

Referenced by fillRunOrLumiIndexes(), findPosition(), edm::IndexIntoFile::IndexIntoFileItrSorted::getRunOrLumiEntryType(), edm::IndexIntoFile::IndexIntoFileItrSorted::initializeLumi_(), inputFileClosed(), set_intersection(), edm::IndexIntoFile::IndexIntoFileItrSorted::setToLastEventInRange(), edm::IndexIntoFile::IndexIntoFileItrSorted::skipLumiInRun(), sortEventEntries(), and sortEvents().

{ return transient_.runOrLumiIndexes_; }

runToOrder()

std::map<IndexRunKey, EntryNumber_t>& edm::IndexIntoFile::runToOrder ( ) const

inlineprivate

Definition at line 1283 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::runToOrder_, and transient_.

Referenced by addEntry(), and sortVector_Run_Or_Lumi_Entries().

{ return transient_.runToOrder_; }

set_intersection()

void edm::IndexIntoFile::set_intersection	(	IndexIntoFile const &	indexIntoFile,
		std::set< IndexRunLumiEventKey > &	intersection
	)		const

The intersection argument will be filled with an entry for each event in both IndexIntoFile objects. To be added the event must have the same ProcessHistoryID index, run number, lumi number and event number.

Definition at line 761 of file IndexIntoFile.cc.

References begin(), edm::IndexIntoFile::RunOrLumiIndexes::beginEventNumbers(), beginRunOrLumi(), empty(), edm::IndexIntoFile::RunOrLumiIndexes::endEventNumbers(), endRunOrLumi(), mps_splice::entry, eventEntries(), eventNumbers(), fillEventNumbers(), fillRunOrLumiIndexes(), reco::helper::VirtualJetProducerHelper::intersection(), edm::IndexIntoFile::RunOrLumiIndexes::isRun(), edm::IndexIntoFile::SortedRunOrLumiItr::isRun(), edm::IndexIntoFile::RunOrLumiIndexes::lumi(), edm::IndexIntoFile::RunOrLumiIndexes::processHistoryIDIndex(), edm::IndexIntoFile::RunOrLumiIndexes::run(), edm::IndexIntoFile::SortedRunOrLumiItr::runOrLumiIndexes(), runOrLumiIndexes(), and DBoxMetadataHelper::set_intersection().

Referenced by edm::DuplicateChecker::inputFileOpened().

                                                                                         {
    if (empty() || indexIntoFile.empty())
      return;
    fillRunOrLumiIndexes();
    indexIntoFile.fillRunOrLumiIndexes();
    RunOrLumiIndexes const& back1 = runOrLumiIndexes().back();
    RunOrLumiIndexes const& back2 = indexIntoFile.runOrLumiIndexes().back();

    // Very quick decision if the run ranges in the two files do not overlap
    if (back2 < runOrLumiIndexes().front())
      return;
    if (back1 < indexIntoFile.runOrLumiIndexes().front())
      return;

    SortedRunOrLumiItr iter1 = beginRunOrLumi();
    SortedRunOrLumiItr iEnd1 = endRunOrLumi();

    SortedRunOrLumiItr iter2 = indexIntoFile.beginRunOrLumi();
    SortedRunOrLumiItr iEnd2 = indexIntoFile.endRunOrLumi();

    // Quick decision if the lumi ranges in the two files do not overlap
    while (iter1 != iEnd1 && iter1.isRun())
      ++iter1;
    if (iter1 == iEnd1)
      return;
    if (back2 < iter1.runOrLumiIndexes())
      return;

    while (iter2 != iEnd2 && iter2.isRun())
      ++iter2;
    if (iter2 == iEnd2)
      return;
    if (back1 < iter2.runOrLumiIndexes())
      return;

    RunOrLumiIndexes const* previousIndexes = nullptr;

    // Loop through the both IndexIntoFile objects and look for matching lumis
    while (iter1 != iEnd1 && iter2 != iEnd2) {
      RunOrLumiIndexes const& indexes1 = iter1.runOrLumiIndexes();
      RunOrLumiIndexes const& indexes2 = iter2.runOrLumiIndexes();
      if (indexes1 < indexes2) {
        ++iter1;
      } else if (indexes2 < indexes1) {
        ++iter2;
      } else {  // they are equal

        // Skip them if it is a run or the same lumi
        if (indexes1.isRun() || (previousIndexes && !(*previousIndexes < indexes1))) {
          ++iter1;
          ++iter2;
        } else {
          previousIndexes = &indexes1;

          // Found a matching lumi, now look for matching events

          long long beginEventNumbers1 = indexes1.beginEventNumbers();
          long long endEventNumbers1 = indexes1.endEventNumbers();

          long long beginEventNumbers2 = indexes2.beginEventNumbers();
          long long endEventNumbers2 = indexes2.endEventNumbers();

          // there must be at least 1 event in each lumi for there to be any matches
          if ((beginEventNumbers1 >= endEventNumbers1) || (beginEventNumbers2 >= endEventNumbers2)) {
            ++iter1;
            ++iter2;
            continue;
          }

          if (!eventEntries().empty() && !indexIntoFile.eventEntries().empty()) {
            std::vector<EventEntry> matchingEvents;
            std::insert_iterator<std::vector<EventEntry> > insertIter(matchingEvents, matchingEvents.begin());
            std::set_intersection(eventEntries().begin() + beginEventNumbers1,
                                  eventEntries().begin() + endEventNumbers1,
                                  indexIntoFile.eventEntries().begin() + beginEventNumbers2,
                                  indexIntoFile.eventEntries().begin() + endEventNumbers2,
                                  insertIter);
            for (EventEntry const& entry : matchingEvents) {
              intersection.insert(IndexRunLumiEventKey(
                  indexes1.processHistoryIDIndex(), indexes1.run(), indexes1.lumi(), entry.event()));
            }
          } else {
            fillEventNumbers();
            indexIntoFile.fillEventNumbers();
            std::vector<EventNumber_t> matchingEvents;
            std::insert_iterator<std::vector<EventNumber_t> > insertIter(matchingEvents, matchingEvents.begin());
            std::set_intersection(eventNumbers().begin() + beginEventNumbers1,
                                  eventNumbers().begin() + endEventNumbers1,
                                  indexIntoFile.eventNumbers().begin() + beginEventNumbers2,
                                  indexIntoFile.eventNumbers().begin() + endEventNumbers2,
                                  insertIter);
            for (EventNumber_t const& eventNumber : matchingEvents) {
              intersection.insert(
                  IndexRunLumiEventKey(indexes1.processHistoryIDIndex(), indexes1.run(), indexes1.lumi(), eventNumber));
            }
          }
        }
      }
    }
  }

setEventFinder()

void edm::IndexIntoFile::setEventFinder ( std::shared_ptr< EventFinder >  ptr )

inline

Calling this enables the functions that fill the event vectors to get the event numbers. It needs to be called before filling the events vectors This implies the client needs to define a class that inherits from EventFinder and then create one. This function is used to pass in a pointer to its base class.

Definition at line 1165 of file IndexIntoFile.h.

References edm::IndexIntoFile::Transients::eventFinder_, and transient_.

Referenced by fwlite::EntryFinder::fillIndex(), and edm::RootFile::validateFile().

{ transient_.eventFinder_ = ptr; }

setNumberOfEvents()

void edm::IndexIntoFile::setNumberOfEvents ( EntryNumber_t  nevents )

inline

The number of events needs to be set before filling the transient event vectors. It is used to resize them.

Definition at line 1158 of file IndexIntoFile.h.

References cmsHarvester::nevents, edm::IndexIntoFile::Transients::numberOfEvents_, and transient_.

Referenced by addEntry(), fwlite::EntryFinder::fillIndex(), and edm::RootFile::validateFile().

{ transient_.numberOfEvents_ = nevents; }

setProcessHistoryIDs()

std::vector<ProcessHistoryID>& edm::IndexIntoFile::setProcessHistoryIDs ( )

inline

Used for backward compatibility and tests. RootFile::fillIndexIntoFile uses this to deal with input files created with releases before 3_8_0 which do not contain an IndexIntoFile.

Definition at line 1225 of file IndexIntoFile.h.

References processHistoryIDs_.

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

{ return processHistoryIDs_; }

setRunOrLumiEntries()

std::vector<RunOrLumiEntry>& edm::IndexIntoFile::setRunOrLumiEntries ( )

inline

Used for backward compatibility and tests. RootFile::fillIndexIntoFile uses this to deal with input files created with releases before 3_8_0 which do not contain an IndexIntoFile.

Definition at line 1220 of file IndexIntoFile.h.

References runOrLumiEntries_.

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

{ return runOrLumiEntries_; }

sortEventEntries()

void edm::IndexIntoFile::sortEventEntries ( ) const

private

Definition at line 481 of file IndexIntoFile.cc.

References cms::cuda::assert(), begin(), eventEntries(), fillRunOrLumiIndexes(), runOrLumiIndexes(), and jetUpdater_cfi::sort.

Referenced by fillEventNumbersOrEntries().

                                             {
    fillRunOrLumiIndexes();
    std::vector<RunOrLumiIndexes>::iterator beginOfLumi = runOrLumiIndexes().begin();
    std::vector<RunOrLumiIndexes>::iterator endOfLumi = beginOfLumi;
    std::vector<RunOrLumiIndexes>::iterator iEnd = runOrLumiIndexes().end();
    while (true) {
      while (beginOfLumi != iEnd && beginOfLumi->isRun()) {
        ++beginOfLumi;
      }
      if (beginOfLumi == iEnd)
        break;

      endOfLumi = beginOfLumi + 1;
      while (endOfLumi != iEnd && beginOfLumi->processHistoryIDIndex() == endOfLumi->processHistoryIDIndex() &&
             beginOfLumi->run() == endOfLumi->run() && beginOfLumi->lumi() == endOfLumi->lumi()) {
        ++endOfLumi;
      }
      assert(beginOfLumi->endEventNumbers() >= 0);
      assert(beginOfLumi->endEventNumbers() <= static_cast<long long>(eventEntries().size()));
      std::sort(eventEntries().begin() + beginOfLumi->beginEventNumbers(),
                eventEntries().begin() + beginOfLumi->endEventNumbers());
      beginOfLumi = endOfLumi;
    }
  }

sortEvents()

void edm::IndexIntoFile::sortEvents ( ) const

private

Definition at line 456 of file IndexIntoFile.cc.

References cms::cuda::assert(), begin(), eventNumbers(), fillRunOrLumiIndexes(), runOrLumiIndexes(), and jetUpdater_cfi::sort.

Referenced by fillEventNumbersOrEntries().

                                       {
    fillRunOrLumiIndexes();
    std::vector<RunOrLumiIndexes>::iterator beginOfLumi = runOrLumiIndexes().begin();
    std::vector<RunOrLumiIndexes>::iterator endOfLumi = beginOfLumi;
    std::vector<RunOrLumiIndexes>::iterator iEnd = runOrLumiIndexes().end();
    while (true) {
      while (beginOfLumi != iEnd && beginOfLumi->isRun()) {
        ++beginOfLumi;
      }
      if (beginOfLumi == iEnd)
        break;

      endOfLumi = beginOfLumi + 1;
      while (endOfLumi != iEnd && beginOfLumi->processHistoryIDIndex() == endOfLumi->processHistoryIDIndex() &&
             beginOfLumi->run() == endOfLumi->run() && beginOfLumi->lumi() == endOfLumi->lumi()) {
        ++endOfLumi;
      }
      assert(beginOfLumi->endEventNumbers() >= 0);
      assert(beginOfLumi->endEventNumbers() <= static_cast<long long>(eventNumbers().size()));
      std::sort(eventNumbers().begin() + beginOfLumi->beginEventNumbers(),
                eventNumbers().begin() + beginOfLumi->endEventNumbers());
      beginOfLumi = endOfLumi;
    }
  }

sortVector_Run_Or_Lumi_Entries()

void edm::IndexIntoFile::sortVector_Run_Or_Lumi_Entries

(

)

Used by RootOutputModule after all entries have been added. This only works after the correct sequence of addEntry calls, because it makes some corrections before sorting. A std::stable_sort works in cases where those corrections are not needed.

Definition at line 385 of file IndexIntoFile.cc.

References checkForMissingRunOrLumiEntry(), Exception, B2GTnPMonitor_cfi::item, edm::errors::LogicError, runOrLumiEntries_, runToOrder(), and edm::stable_sort_all().

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

                                                     {
    for (RunOrLumiEntry& item : runOrLumiEntries_) {
      std::map<IndexRunKey, EntryNumber_t>::const_iterator keyAndOrder =
          runToOrder().find(IndexRunKey(item.processHistoryIDIndex(), item.run()));
      if (keyAndOrder == runToOrder().end()) {
        throw Exception(errors::LogicError)
            << "In IndexIntoFile::sortVector_Run_Or_Lumi_Entries. A run entry is missing.\n"
            << "This means the IndexIntoFile 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 in\n"
            << "endLuminosityBlock or endRun then ignore this exception and fix\n"
            << "the primary exception. This is an expected side effect.\n"
            << "Otherwise please report this to the core framework developers\n";
      }
      item.setOrderPHIDRun(keyAndOrder->second);
    }
    stable_sort_all(runOrLumiEntries_);
    checkForMissingRunOrLumiEntry();
  }

unsortedEventNumbers() [1/2]

std::vector<EventNumber_t>& edm::IndexIntoFile::unsortedEventNumbers ( )

inline

If something external to IndexIntoFile is reading through the EventAuxiliary then it could use this to fill in the event numbers so that IndexIntoFile will not read through it again.

Definition at line 1207 of file IndexIntoFile.h.

References transient_, and edm::IndexIntoFile::Transients::unsortedEventNumbers_.

Referenced by doneFileInitialization(), fillEventNumbersOrEntries(), edm::RootFile::fillIndexIntoFile(), fillUnsortedEventNumbers(), and inputFileClosed().

{ return transient_.unsortedEventNumbers_; }

unsortedEventNumbers() [2/2]

std::vector<EventNumber_t> const& edm::IndexIntoFile::unsortedEventNumbers ( ) const

inline

Definition at line 1208 of file IndexIntoFile.h.

References transient_, and edm::IndexIntoFile::Transients::unsortedEventNumbers_.

{ return transient_.unsortedEventNumbers_; }

unsortedEventNumbersMutable()

std::vector<EventNumber_t>& edm::IndexIntoFile::unsortedEventNumbersMutable ( ) const

inlineprivate

Definition at line 1275 of file IndexIntoFile.h.

References transient_, and edm::IndexIntoFile::Transients::unsortedEventNumbers_.

Referenced by fillUnsortedEventNumbers().

{ return transient_.unsortedEventNumbers_; }

Friends And Related Function Documentation

::TestIndexIntoFile

friend class ::TestIndexIntoFile

friend

Definition at line 1264 of file IndexIntoFile.h.

::TestIndexIntoFile1

friend class ::TestIndexIntoFile1

friend

Definition at line 1265 of file IndexIntoFile.h.

::TestIndexIntoFile2

friend class ::TestIndexIntoFile2

friend

Definition at line 1266 of file IndexIntoFile.h.

::TestIndexIntoFile3

friend class ::TestIndexIntoFile3

friend

Definition at line 1267 of file IndexIntoFile.h.

::TestIndexIntoFile4

friend class ::TestIndexIntoFile4

friend

Definition at line 1268 of file IndexIntoFile.h.

::TestIndexIntoFile5

friend class ::TestIndexIntoFile5

friend

Definition at line 1269 of file IndexIntoFile.h.

Member Data Documentation

invalidEntry

IndexIntoFile::EntryNumber_t const edm::IndexIntoFile::invalidEntry = -1LL

static

Definition at line 266 of file IndexIntoFile.h.

Referenced by addEntry(), addLumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::addRunsWithNoEvents(), checkForMissingRunOrLumiEntry(), edm::IndexIntoFile::IndexIntoFileItrNoSort::entry(), edm::IndexIntoFile::IndexIntoFileItrSorted::entry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::entry(), fillEventNumbersOrEntries(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesSortedByEventEntry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesToLastContiguousEvents(), edm::RootFile::fillIndexIntoFile(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::fillLumisWithNoRemainingEvents(), fillRunOrLumiIndexes(), findPosition(), edm::IndexIntoFile::IndexIntoFileItrImpl::firstEventEntryThisLumi(), edm::IndexIntoFile::IndexIntoFileItrImpl::firstEventEntryThisRun(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::gatherNeededInfo(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiEntriesNoRemainingEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumisWithNoEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleLumiWithEvents(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::handleToEndOfContiguousEventsInLumis(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::IndexIntoFileItrEntryOrder(), edm::RootFile::initializeDuplicateChecker(), edm::RootFile::initializeFirstProcessBlockEntry(), edm::IndexIntoFile::IndexIntoFileItrNoSort::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::initializeLumi_(), iterationWillBeInEntryOrder(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lowestInLumi(), edm::IndexIntoFile::IndexIntoFileItrNoSort::lumiIterationStartingIndex(), edm::IndexIntoFile::IndexIntoFileItrSorted::lumiIterationStartingIndex(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lumiIterationStartingIndex(), edm::IndexIntoFile::IndexIntoFileItrNoSort::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::peekAheadAtEventEntry(), edm::IndexIntoFile::IndexIntoFileItrSorted::peekAheadAtEventEntry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::peekAheadAtEventEntry(), edm::IndexIntoFile::IndexIntoFileItrNoSort::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::previousEventRange(), edm::RootFile::readLuminosityBlockAuxiliary_(), edm::RootEmbeddedFileSequence::readOneSequential(), edm::RootFile::readRunAuxiliary_(), edm::IndexIntoFile::Transients::reset(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::resizeVectors(), edm::RootTree::rewindToInvalid(), edm::RootEmbeddedFileSequence::RootEmbeddedFileSequence(), edm::IndexIntoFile::IndexIntoFileItrNoSort::setToLastEventInRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::setToLastEventInRange(), edm::RootEmbeddedFileSequence::skipEntries(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventBackward(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventForward(), edm::RootFile::skipEvents(), and edm::RootFile::wasFirstEventJustRead().

invalidEvent

EventNumber_t const edm::IndexIntoFile::invalidEvent = 0U

static

Definition at line 265 of file IndexIntoFile.h.

Referenced by addEntry(), fillEventNumbersOrEntries(), findEventPosition(), findPosition(), and edm::PoolSource::getNextItemType().

invalidIndex

int const edm::IndexIntoFile::invalidIndex = -1

static

Definition at line 262 of file IndexIntoFile.h.

Referenced by addEntry(), edm::IndexIntoFile::IndexIntoFileItrImpl::advanceToNextLumiOrRun(), begin(), end(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::fillIndexesSortedByEventEntry(), findPosition(), edm::IndexIntoFile::IndexIntoFileItrImpl::firstEventEntryThisLumi(), edm::IndexIntoFile::IndexIntoFileItrImpl::firstEventEntryThisRun(), edm::IndexIntoFile::IndexIntoFileItrNoSort::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrSorted::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrImpl::initializeRun(), edm::IndexIntoFile::IndexIntoFileItrNoSort::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::peekAheadAtEventEntry(), edm::IndexIntoFile::IndexIntoFileItrSorted::peekAheadAtEventEntry(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::peekAheadAtEventEntry(), edm::IndexIntoFile::IndexIntoFileItrNoSort::peekAheadAtLumi(), edm::IndexIntoFile::IndexIntoFileItrSorted::peekAheadAtLumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::peekAheadAtLumi(), edm::IndexIntoFile::IndexIntoFileItrNoSort::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrImpl::previousLumiWithEvents(), edm::IndexIntoFile::IndexIntoFileItrNoSort::processHistoryIDIndex(), edm::IndexIntoFile::IndexIntoFileItrSorted::processHistoryIDIndex(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::processHistoryIDIndex(), edm::IndexIntoFile::Transients::reset(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::EntryOrderInitializationInfo::resizeVectors(), edm::IndexIntoFile::IndexIntoFileItrImpl::setInvalid(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessLumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::shouldProcessRun(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventBackward(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventForward(), edm::RootFile::skipEvents(), edm::IndexIntoFile::IndexIntoFileItrNoSort::skipLumiInRun(), edm::IndexIntoFile::IndexIntoFileItrSorted::skipLumiInRun(), and edm::IndexIntoFile::IndexIntoFileItrEntryOrder::skipLumiInRun().

invalidLumi

LuminosityBlockNumber_t const edm::IndexIntoFile::invalidLumi = 0U

static

Definition at line 264 of file IndexIntoFile.h.

Referenced by addEntry(), findLumiPosition(), findPosition(), edm::IndexIntoFile::IndexIntoFileItrImpl::getLumisInRun(), edm::PoolSource::getNextItemType(), edm::IndexIntoFile::RunOrLumiEntry::isRun(), edm::IndexIntoFile::RunOrLumiIndexes::isRun(), edm::IndexIntoFile::SortedRunOrLumiItr::isRun(), edm::IndexIntoFile::IndexIntoFileItrNoSort::lumi(), edm::IndexIntoFile::IndexIntoFileItrSorted::lumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::lumi(), edm::IndexIntoFile::IndexIntoFileItrNoSort::peekAheadAtLumi(), edm::IndexIntoFile::IndexIntoFileItrSorted::peekAheadAtLumi(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::peekAheadAtLumi(), edm::IndexIntoFile::Transients::reset(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventBackward(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventForward(), edm::RootFile::skipEvents(), and edm::RootFile::skipThisEntry().

invalidRun

RunNumber_t const edm::IndexIntoFile::invalidRun = 0U

static

Definition at line 263 of file IndexIntoFile.h.

Referenced by addEntry(), edm::PoolSource::getNextItemType(), edm::IndexIntoFile::Transients::reset(), edm::IndexIntoFile::IndexIntoFileItrNoSort::run(), edm::IndexIntoFile::IndexIntoFileItrSorted::run(), edm::IndexIntoFile::IndexIntoFileItrEntryOrder::run(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventBackward(), edm::IndexIntoFile::IndexIntoFileItrImpl::skipEventForward(), and edm::RootFile::skipEvents().

processHistoryIDs_

std::vector<ProcessHistoryID> edm::IndexIntoFile::processHistoryIDs_

private

Definition at line 1299 of file IndexIntoFile.h.

Referenced by addEntry(), fixIndexes(), processHistoryID(), processHistoryIDs(), reduceProcessHistoryIDs(), and setProcessHistoryIDs().

runOrLumiEntries_

std::vector<RunOrLumiEntry> edm::IndexIntoFile::runOrLumiEntries_

private

Definition at line 1300 of file IndexIntoFile.h.

Referenced by addEntry(), addLumi(), checkForMissingRunOrLumiEntry(), fillRunOrLumiIndexes(), findPosition(), fixIndexes(), reduceProcessHistoryIDs(), runOrLumiEntries(), setRunOrLumiEntries(), and sortVector_Run_Or_Lumi_Entries().

transient_

Transients edm::IndexIntoFile::transient_

mutableprivate

Definition at line 1297 of file IndexIntoFile.h.

Referenced by beginEvents(), currentIndex(), currentLumi(), currentRun(), endEvents(), eventEntries(), eventNumbers(), getEventNumberOfEntry(), initializeTransients(), lumiToOrder(), numberOfEvents(), previousAddedIndex(), resetEventFinder(), runOrLumiIndexes(), runToOrder(), setEventFinder(), setNumberOfEvents(), unsortedEventNumbers(), and unsortedEventNumbersMutable().