#include <IndexIntoFile.h>

Classes
class	EventEntry

class	EventFinder

class	IndexIntoFileItr

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 }

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

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. Both sorting orders 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.

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 in the order they first appear in the input file. 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 in the input file. 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. (It has not happened yet as I am writing this, but a similar thing will likely occur for runs if/when we ever implement concurrent runs)

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 225 of file IndexIntoFile.h.

Member Typedef Documentation

◆ EntryNumber_t

using edm::IndexIntoFile::EntryNumber_t = long long

Definition at line 231 of file IndexIntoFile.h.

Member Enumeration Documentation

◆ EntryType

enum edm::IndexIntoFile::EntryType

Enumerator
kRun
kLumi
kEvent
kEnd

Definition at line 238 of file IndexIntoFile.h.

238 { 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:

firstAppearance of the ProcessHistoryID and run number in the file
firstAppearance of the ProcessHistoryID, run number and lumi number in the file
entry number

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

processHistoryID index (which are normally in order of appearance in the process)
run number
lumi number
event number
entry number

Enumerator
numericalOrder
firstAppearanceOrder

Definition at line 266 of file IndexIntoFile.h.

266 { numericalOrder, firstAppearanceOrder };

Constructor & Destructor Documentation

◆ IndexIntoFile()

edm::IndexIntoFile::IndexIntoFile ( )

Definition at line 51 of file IndexIntoFile.cc.

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

◆ ~IndexIntoFile()

edm::IndexIntoFile::~IndexIntoFile ( )

Definition at line 53 of file IndexIntoFile.cc.

53 {}

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.

                                                     {
     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;
  
     assert((currentRun() == run && currentIndex() == index) || currentRun() == invalidRun);
     if (lumi == invalidLumi) {
       if (currentLumi() != invalidLumi) {
         throw Exception(errors::LogicError)
             << "In IndexIntoFile::addEntry. Entries were added in illegal order.\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";
       }
       currentIndex() = invalidIndex;
       currentRun() = invalidRun;
       currentLumi() = invalidLumi;
       // assign each run an order value when first seen (using entry but any increasing value would work)
       std::pair<IndexRunKey, EntryNumber_t> keyAndOrder(IndexRunKey(index, run), entry);
       runToOrder().insert(keyAndOrder);  // Does nothing if this key was already inserted
       runOrLumiEntries_.emplace_back(
           runToOrder()[IndexRunKey(index, run)], invalidEntry, entry, index, run, lumi, invalidEntry, invalidEntry);
     } else {
       if (currentRun() == invalidRun) {
         currentRun() = run;
         currentIndex() = index;
       }
       if (event == invalidEvent) {
         if (currentLumi() != lumi and currentLumi() != invalidLumi) {
           //we have overlapping lumis so must inject a placeholder
           addLumi(index, run, currentLumi(), invalidEntry);
         }
         currentLumi() = invalidLumi;
         addLumi(index, run, lumi, entry);
       } else {
         if (currentLumi() != lumi and currentLumi() != invalidLumi) {
           //We have overlapping lumis so need to inject a placeholder
           addLumi(index, run, currentLumi(), invalidEntry);
         }
         setNumberOfEvents(numberOfEvents() + 1);
         if (beginEvents() == invalidEntry) {
           currentLumi() = lumi;
           beginEvents() = entry;
           endEvents() = beginEvents() + 1;
         } else {
           assert(currentLumi() == lumi);
           assert(entry == endEvents());
           ++endEvents();
         }
       }
     }
   }

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

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

◆ addLumi()

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

Definition at line 59 of file IndexIntoFile.cc.

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

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

Referenced by addEntry().

◆ 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 461 of file IndexIntoFile.cc.

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

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

◆ beginEvents()

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

inlineprivate

Definition at line 1072 of file IndexIntoFile.h.

1072 { return transient_.beginEvents_; }

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

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

◆ beginRunOrLumi()

IndexIntoFile::SortedRunOrLumiItr edm::IndexIntoFile::beginRunOrLumi ( ) const

Definition at line 710 of file IndexIntoFile.cc.

710 { return SortedRunOrLumiItr(this, 0); }

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

◆ 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 818 of file IndexIntoFile.cc.

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

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

◆ containsEvent()

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

Definition at line 700 of file IndexIntoFile.cc.

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

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

Referenced by containsItem().

◆ containsItem()

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

Definition at line 696 of file IndexIntoFile.cc.

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

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

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

◆ containsLumi()

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

Definition at line 704 of file IndexIntoFile.cc.

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

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

Referenced by containsItem().

◆ containsRun()

bool edm::IndexIntoFile::containsRun ( RunNumber_t run ) const

Definition at line 708 of file IndexIntoFile.cc.

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

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

Referenced by containsItem().

◆ currentIndex()

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

inlineprivate

Definition at line 1074 of file IndexIntoFile.h.

1074 { return transient_.currentIndex_; }

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

Referenced by addEntry().

◆ currentLumi()

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

inlineprivate

Definition at line 1076 of file IndexIntoFile.h.

1076 { return transient_.currentLumi_; }

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

Referenced by addEntry().

◆ currentRun()

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

inlineprivate

Definition at line 1075 of file IndexIntoFile.h.

1075 { return transient_.currentRun_; }

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

Referenced by addEntry().

◆ doneFileInitialization()

void edm::IndexIntoFile::doneFileInitialization ( )

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

Definition at line 306 of file IndexIntoFile.cc.

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

References unsortedEventNumbers().

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

◆ empty()

bool edm::IndexIntoFile::empty ( ) const

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

Definition at line 487 of file IndexIntoFile.cc.

487 { return runOrLumiEntries().empty(); }

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

◆ 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 470 of file IndexIntoFile.cc.

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

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

◆ endEvents()

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

inlineprivate

Definition at line 1073 of file IndexIntoFile.h.

1073 { return transient_.endEvents_; }

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

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

◆ endRunOrLumi()

IndexIntoFile::SortedRunOrLumiItr edm::IndexIntoFile::endRunOrLumi ( ) const

Definition at line 712 of file IndexIntoFile.cc.

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

References runOrLumiEntries(), and findQualityFiles::size.

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

◆ eventEntries()

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

inlineprivate

Definition at line 1065 of file IndexIntoFile.h.

1065 { return transient_.eventEntries_; }

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

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

◆ eventNumbers()

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

inlineprivate

Definition at line 1066 of file IndexIntoFile.h.

1066 { return transient_.eventNumbers_; }

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

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

◆ 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 200 of file IndexIntoFile.cc.

200 { fillEventNumbersOrEntries(false, true); }

References fillEventNumbersOrEntries().

◆ 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 198 of file IndexIntoFile.cc.

198 { fillEventNumbersOrEntries(true, false); }

References fillEventNumbersOrEntries().

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

◆ 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 202 of file IndexIntoFile.cc.

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

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

◆ 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 151 of file IndexIntoFile.cc.

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

References cms::cuda::assert(), invalidEntry, B2GTnPMonitor_cfi::item, 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().

◆ fillUnsortedEventNumbers()

void edm::IndexIntoFile::fillUnsortedEventNumbers ( ) const

private

Definition at line 279 of file IndexIntoFile.cc.

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

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

Referenced by fillEventNumbersOrEntries().

◆ 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 676 of file IndexIntoFile.cc.

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

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

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

◆ 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 685 of file IndexIntoFile.cc.

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

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

◆ 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 489 of file IndexIntoFile.cc.

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

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

◆ 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 635 of file IndexIntoFile.cc.

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

References begin(), end(), findPosition(), getEventNumberOfEntry(), invalidEvent, invalidLumi, BXlumiParameters_cfi::lumi, numericalOrder, and writedatasetfile::run.

◆ findRunPosition()

IndexIntoFile::IndexIntoFileItr edm::IndexIntoFile::findRunPosition ( RunNumber_t run ) const

Same as findPosition.

Definition at line 692 of file IndexIntoFile.cc.

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

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

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

◆ 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 370 of file IndexIntoFile.cc.

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

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

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

◆ getEventNumberOfEntry()

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

inlineprivate

Definition at line 1079 of file IndexIntoFile.h.

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

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

Referenced by fillUnsortedEventNumbers(), and findPosition().

◆ initializeTransients()

void edm::IndexIntoFile::initializeTransients ( )

inline

Definition at line 1028 of file IndexIntoFile.h.

1028 { transient_.reset(); }

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

◆ 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 299 of file IndexIntoFile.cc.

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

References eventEntries(), resetEventFinder(), runOrLumiIndexes(), and unsortedEventNumbers().

◆ iterationWillBeInEntryOrder()

bool edm::IndexIntoFile::iterationWillBeInEntryOrder ( SortOrder sortOrder ) const

Used to determine whether or not to disable fast cloning.

Definition at line 474 of file IndexIntoFile.cc.

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

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

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

◆ lumiToOrder()

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

inlineprivate

Definition at line 1071 of file IndexIntoFile.h.

1071 { return transient_.lumiToOrder_; }

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

Referenced by addLumi().

◆ numberOfEvents()

size_t edm::IndexIntoFile::numberOfEvents ( ) const

inlineprivate

Definition at line 1078 of file IndexIntoFile.h.

1078 { return transient_.numberOfEvents_; }

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

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

◆ previousAddedIndex()

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

inlineprivate

Definition at line 1069 of file IndexIntoFile.h.

1069 { return transient_.previousAddedIndex_; }

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

Referenced by addEntry().

◆ processHistoryID()

ProcessHistoryID const & edm::IndexIntoFile::processHistoryID ( int i ) const

Definition at line 55 of file IndexIntoFile.cc.

55 { return processHistoryIDs_.at(i); }

References mps_fire::i, and processHistoryIDs_.

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

◆ processHistoryIDs()

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

Definition at line 57 of file IndexIntoFile.cc.

57 { return processHistoryIDs_; }

References processHistoryIDs_.

Referenced by fixIndexes().

◆ 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 308 of file IndexIntoFile.cc.

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

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

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

◆ resetEventFinder()

void edm::IndexIntoFile::resetEventFinder ( ) const

inlineprivate

Definition at line 1064 of file IndexIntoFile.h.

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

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

Referenced by inputFileClosed().

◆ runOrLumiEntries()

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

inline

Used internally and for test purposes.

Definition at line 1023 of file IndexIntoFile.h.

1023 { return runOrLumiEntries_; }

References runOrLumiEntries_.

Referenced by empty(), endRunOrLumi(), edm::IndexIntoFile::IndexIntoFileItrNoSort::getRunOrLumiEntryType(), edm::IndexIntoFile::IndexIntoFileItrNoSort::initializeLumi_(), edm::IndexIntoFile::IndexIntoFileItrNoSort::nextEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::previousEventRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::setToLastEventInRange(), edm::IndexIntoFile::IndexIntoFileItrNoSort::skipLumiInRun(), and edm::IndexIntoFile::SortedRunOrLumiItr::SortedRunOrLumiItr().

◆ runOrLumiIndexes()

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

inlineprivate

Definition at line 1077 of file IndexIntoFile.h.

1077 { return transient_.runOrLumiIndexes_; }

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

◆ runToOrder()

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

inlineprivate

Definition at line 1070 of file IndexIntoFile.h.

1070 { return transient_.runToOrder_; }

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

Referenced by addEntry(), and sortVector_Run_Or_Lumi_Entries().

◆ 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 716 of file IndexIntoFile.cc.

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

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

◆ 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 952 of file IndexIntoFile.h.

952 { transient_.eventFinder_ = ptr; }

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

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

◆ 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 945 of file IndexIntoFile.h.

945 { transient_.numberOfEvents_ = nevents; }

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

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

◆ 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 1012 of file IndexIntoFile.h.

1012 { return processHistoryIDs_; }

References processHistoryIDs_.

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

◆ 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 1007 of file IndexIntoFile.h.

1007 { return runOrLumiEntries_; }

References runOrLumiEntries_.

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

◆ sortEventEntries()

void edm::IndexIntoFile::sortEventEntries ( ) const

private

Definition at line 436 of file IndexIntoFile.cc.

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

References cms::cuda::assert(), begin(), eventEntries(), fillRunOrLumiIndexes(), runOrLumiIndexes(), and findQualityFiles::size.

Referenced by fillEventNumbersOrEntries().

◆ sortEvents()

void edm::IndexIntoFile::sortEvents ( ) const

private

Definition at line 411 of file IndexIntoFile.cc.

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

References cms::cuda::assert(), begin(), eventNumbers(), fillRunOrLumiIndexes(), runOrLumiIndexes(), and findQualityFiles::size.

Referenced by fillEventNumbersOrEntries().

◆ 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 392 of file IndexIntoFile.cc.

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

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

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

◆ 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 994 of file IndexIntoFile.h.

994 { return transient_.unsortedEventNumbers_; }

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

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

◆ unsortedEventNumbers() [2/2]

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

inline

Definition at line 995 of file IndexIntoFile.h.

995 { return transient_.unsortedEventNumbers_; }

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

◆ unsortedEventNumbersMutable()

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

inlineprivate

Definition at line 1062 of file IndexIntoFile.h.

1062 { return transient_.unsortedEventNumbers_; }

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

Referenced by fillUnsortedEventNumbers().

Friends And Related Function Documentation

◆ ::TestIndexIntoFile

friend class ::TestIndexIntoFile

friend

Definition at line 1051 of file IndexIntoFile.h.

◆ ::TestIndexIntoFile1

friend class ::TestIndexIntoFile1

friend

Definition at line 1052 of file IndexIntoFile.h.

◆ ::TestIndexIntoFile2

friend class ::TestIndexIntoFile2

friend

Definition at line 1053 of file IndexIntoFile.h.

◆ ::TestIndexIntoFile3

friend class ::TestIndexIntoFile3

friend

Definition at line 1054 of file IndexIntoFile.h.

◆ ::TestIndexIntoFile4

friend class ::TestIndexIntoFile4

friend

Definition at line 1055 of file IndexIntoFile.h.

◆ ::TestIndexIntoFile5

friend class ::TestIndexIntoFile5

friend

Definition at line 1056 of file IndexIntoFile.h.

Member Data Documentation

◆ invalidEntry

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

staticconstexpr

Definition at line 236 of file IndexIntoFile.h.

◆ invalidEvent

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

staticconstexpr

Definition at line 235 of file IndexIntoFile.h.

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

◆ invalidIndex

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

staticconstexpr

Definition at line 232 of file IndexIntoFile.h.

◆ invalidLumi

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

staticconstexpr

Definition at line 234 of file IndexIntoFile.h.

◆ invalidRun

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

staticconstexpr

Definition at line 233 of file IndexIntoFile.h.

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

◆ processHistoryIDs_

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

private

Definition at line 1086 of file IndexIntoFile.h.

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

◆ runOrLumiEntries_

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

private

Definition at line 1087 of file IndexIntoFile.h.

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

◆ transient_

Transients edm::IndexIntoFile::transient_

mutableprivate

Definition at line 1084 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().

Classes

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ EntryNumber_t

Member Enumeration Documentation

◆ EntryType

◆ SortOrder

Constructor & Destructor Documentation

◆ IndexIntoFile()

◆ ~IndexIntoFile()

Member Function Documentation

◆ addEntry()

◆ addLumi()

◆ begin()

◆ beginEvents()

◆ beginRunOrLumi()

◆ containsDuplicateEvents()

◆ containsEvent()

◆ containsItem()

◆ containsLumi()

◆ containsRun()

◆ currentIndex()

◆ currentLumi()

◆ currentRun()

◆ doneFileInitialization()

◆ empty()

◆ end()

◆ endEvents()

◆ endRunOrLumi()

◆ eventEntries()

◆ eventNumbers()

◆ fillEventEntries()

◆ fillEventNumbers()

◆ fillEventNumbersOrEntries()

◆ fillRunOrLumiIndexes()

◆ fillUnsortedEventNumbers()

◆ findEventPosition()

◆ findLumiPosition()

◆ findPosition() [1/2]

◆ findPosition() [2/2]

◆ findRunPosition()

◆ fixIndexes()

◆ getEventNumberOfEntry()

◆ initializeTransients()

◆ inputFileClosed()

◆ iterationWillBeInEntryOrder()

◆ lumiToOrder()

◆ numberOfEvents()

◆ previousAddedIndex()

◆ processHistoryID()

◆ processHistoryIDs()

◆ reduceProcessHistoryIDs()

◆ resetEventFinder()

◆ runOrLumiEntries()

◆ runOrLumiIndexes()

◆ runToOrder()

◆ set_intersection()

◆ setEventFinder()

◆ setNumberOfEvents()

◆ setProcessHistoryIDs()

◆ setRunOrLumiEntries()

◆ sortEventEntries()

◆ sortEvents()

◆ sortVector_Run_Or_Lumi_Entries()

◆ unsortedEventNumbers() [1/2]

◆ unsortedEventNumbers() [2/2]

◆ unsortedEventNumbersMutable()

Friends And Related Function Documentation

◆ ::TestIndexIntoFile

◆ ::TestIndexIntoFile1

◆ ::TestIndexIntoFile2

◆ ::TestIndexIntoFile3

◆ ::TestIndexIntoFile4

◆ ::TestIndexIntoFile5