#include <RootInputFileSequence.h>

Public Types
typedef std::shared_ptr< RootFile >	RootFileSharedPtr

Public Member Functions
void	closeFile_ ()

bool	containedInCurrentFile (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const

void	dropUnwantedBranches_ (std::vector< std::string > const &wantedBranches)

void	endJob ()

std::shared_ptr < BranchIDListHelper const >	fileBranchIDListHelper () const

std::shared_ptr < ProductRegistry const >	fileProductRegistry () const

ProcessingController::ForwardState	forwardState () const

InputSource::ItemType	getNextItemType (RunNumber_t &run, LuminosityBlockNumber_t &lumi, EventNumber_t &event)

bool	goToEvent (EventID const &eventID)

void	initAssociationsFromSecondary (std::set< BranchID > const &)

RootInputFileSequence &	operator= (RootInputFileSequence const &)=delete

ProcessHistoryRegistry const &	processHistoryRegistry () const

ProcessHistoryRegistry &	processHistoryRegistryForUpdate ()

void	readEvent (EventPrincipal &cache)

std::unique_ptr< FileBlock >	readFile_ ()

void	readLuminosityBlock_ (LuminosityBlockPrincipal &lumiPrincipal)

std::shared_ptr < LuminosityBlockAuxiliary >	readLuminosityBlockAuxiliary_ ()

void	readOneRandom (EventPrincipal &cache, size_t &fileNameHash, CLHEP::HepRandomEngine *)

bool	readOneRandomWithID (EventPrincipal &cache, size_t &fileNameHash, LuminosityBlockID const &id, CLHEP::HepRandomEngine *)

bool	readOneSequential (EventPrincipal &cache, size_t &fileNameHash)

bool	readOneSequentialWithID (EventPrincipal &cache, size_t &fileNameHash, LuminosityBlockID const &id)

void	readOneSpecified (EventPrincipal &cache, size_t &fileNameHash, SecondaryEventIDAndFileInfo const &id)

void	readRun_ (RunPrincipal &runPrincipal)

std::shared_ptr< RunAuxiliary >	readRunAuxiliary_ ()

ProcessingController::ReverseState	reverseState () const

void	rewind_ ()

	RootInputFileSequence (ParameterSet const &pset, PoolSource &input, InputFileCatalog const &catalog, unsigned int nStreams, InputType inputType)

	RootInputFileSequence (RootInputFileSequence const &)=delete

void	skipEntries (unsigned int offset)

bool	skipEvents (int offset)

bool	skipToItem (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event, size_t fileNameHash=0U, bool currentFileFirst=true)

bool	skipToItemInNewFile (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event)

bool	skipToItemInNewFile (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event, size_t fileNameHash)

virtual	~RootInputFileSequence ()

Static Public Member Functions
static void	fillDescription (ParameterSetDescription &desc)

Private Member Functions
std::vector< FileCatalogItem > const &	fileCatalogItems () const

void	initFile (bool skipBadFiles)

bool	nextFile ()

bool	previousFile ()

ProcessConfiguration const &	processConfiguration () const

std::shared_ptr < ProductRegistry const >	productRegistry () const

ProductRegistry &	productRegistryUpdate () const

int	remainingEvents () const

int	remainingLuminosityBlocks () const

void	rewindFile ()

Private Attributes
std::vector< BranchID >	associationsFromSecondary_

BranchDescription::MatchMode	branchesMustMatch_

bool	bypassVersionCheck_

InputFileCatalog const &	catalog_

bool	dropDescendants_

std::shared_ptr< DuplicateChecker >	duplicateChecker_

bool	enablePrefetching_

std::shared_ptr< EventSkipperByID >	eventSkipperByID_

int	eventsRemainingInFile_

std::vector< FileCatalogItem > ::const_iterator	fileIter_

std::vector< FileCatalogItem > ::const_iterator	fileIterBegin_

std::vector< FileCatalogItem > ::const_iterator	fileIterEnd_

std::vector< FileCatalogItem > ::const_iterator	fileIterLastOpened_

std::unique_ptr < std::unordered_multimap < size_t, size_t > >	findFileForSpecifiedID_

bool	firstFile_

std::vector< std::shared_ptr < IndexIntoFile > >	indexesIntoFiles_

int	initialNumberOfEventsToSkip_

PoolSource &	input_

InputType	inputType_

bool	labelRawDataLikeMC_

std::string	lfn_

size_t	lfnHash_

bool	noEventSort_

unsigned int	nStreams_

std::vector< ProcessHistoryID >	orderedProcessHistoryIDs_

ProductSelectorRules	productSelectorRules_

RootFileSharedPtr	rootFile_

RunNumber_t	setRun_

bool	skipBadFiles_

unsigned int	treeCacheSize_

int const	treeMaxVirtualSize_

bool	usedFallback_

bool	usingGoToEvent_

Detailed Description

Definition at line 40 of file RootInputFileSequence.h.

Member Typedef Documentation

typedef std::shared_ptr<RootFile> edm::RootInputFileSequence::RootFileSharedPtr

Definition at line 52 of file RootInputFileSequence.h.

Constructor & Destructor Documentation

edm::RootInputFileSequence::RootInputFileSequence	(	ParameterSet const &	pset,
		PoolSource &	input,
		InputFileCatalog const &	catalog,
		unsigned int	nStreams,
		InputType	inputType
	)

explicit

Definition at line 30 of file RootInputFileSequence.cc.

References StorageFactory::activateTimeout(), branchesMustMatch_, prof2calltree::count, enablePrefetching_, f, fileIter_, fileIterBegin_, fileIterEnd_, StorageFactory::get(), edm::ParameterSet::getUntrackedParameter(), initFile(), initialNumberOfEventsToSkip_, inputType_, edm::Service< T >::isAvailable(), HLT_25ns14e33_v1_cff::offset, edm::Primary, productRegistryUpdate(), rootFile_, edm::SecondaryFile, edm::SecondarySource, fileCollector::seed, skipBadFiles_, skipEvents(), StorageFactory::stagein(), edm::BranchDescription::Strict, AlCaHLTBitMon_QueryRunRegistry::string, treeCacheSize_, and edm::ProductRegistry::updateFromInput().

                                      :
     input_(input),
     inputType_(inputType),
     catalog_(catalog),
     firstFile_(true),
     lfn_("unknown"),
     lfnHash_(0U),
     findFileForSpecifiedID_(nullptr),
     fileIterBegin_(fileCatalogItems().begin()),
     fileIterEnd_(fileCatalogItems().end()),
     fileIter_(fileIterEnd_),
     fileIterLastOpened_(fileIterEnd_),
     rootFile_(),
     branchesMustMatch_(BranchDescription::Permissive),
     indexesIntoFiles_(fileCatalogItems().size()),
     orderedProcessHistoryIDs_(),
     nStreams_(nStreams),
     eventSkipperByID_(inputType == InputType::Primary ? EventSkipperByID::create(pset).release() : 0),
     eventsRemainingInFile_(0),
     // The default value provided as the second argument to the getUntrackedParameter function call
     // is not used when the ParameterSet has been validated and the parameters are not optional
     // in the description.  This is currently true when PoolSource is the primary input source.
     // The modules that use PoolSource as a SecSource have not defined their fillDescriptions function
     // yet, so the ParameterSet does not get validated yet.  As soon as all the modules with a SecSource
     // have defined descriptions, the defaults in the getUntrackedParameterSet function calls can
     // and should be deleted from the code.
     initialNumberOfEventsToSkip_(inputType != InputType::SecondaryFile ? pset.getUntrackedParameter<unsigned int>("skipEvents", 0U) : 0U),
     noEventSort_(inputType == InputType::Primary ? pset.getUntrackedParameter<bool>("noEventSort", true) : false),
     skipBadFiles_(pset.getUntrackedParameter<bool>("skipBadFiles", false)),
     bypassVersionCheck_(pset.getUntrackedParameter<bool>("bypassVersionCheck", false)),
     treeCacheSize_(noEventSort_ ? pset.getUntrackedParameter<unsigned int>("cacheSize", roottree::defaultCacheSize) : 0U),
     treeMaxVirtualSize_(pset.getUntrackedParameter<int>("treeMaxVirtualSize", -1)),
     setRun_(pset.getUntrackedParameter<unsigned int>("setRunNumber", 0U)),
     productSelectorRules_(pset, "inputCommands", "InputSource"),
     duplicateChecker_(inputType == InputType::Primary ? new DuplicateChecker(pset) : 0),
     dropDescendants_(pset.getUntrackedParameter<bool>("dropDescendantsOfDroppedBranches", inputType != InputType::SecondarySource)),
     labelRawDataLikeMC_(pset.getUntrackedParameter<bool>("labelRawDataLikeMC", true)),
     usingGoToEvent_(false),
     enablePrefetching_(false),
     usedFallback_(false) {
 
     // The SiteLocalConfig controls the TTreeCache size and the prefetching settings.
     Service<SiteLocalConfig> pSLC;
     if(pSLC.isAvailable()) {
       if(treeCacheSize_ != 0U && pSLC->sourceTTreeCacheSize()) {
         treeCacheSize_ = *(pSLC->sourceTTreeCacheSize());
       }
       enablePrefetching_ = pSLC->enablePrefetching();
     }
 
     std::string branchesMustMatch = pset.getUntrackedParameter<std::string>("branchesMustMatch", std::string("permissive"));
     if(branchesMustMatch == std::string("strict")) branchesMustMatch_ = BranchDescription::Strict;
 
     StorageFactory *factory = StorageFactory::get();
 
     if(inputType == InputType::SecondarySource) {
       // For the secondary input source we do not stage in,
       // and we randomly choose the first file to open.
       // We cannot use the random number service yet.
       std::ifstream f("/dev/urandom");
       unsigned int seed;
       f.read(reinterpret_cast<char*>(&seed), sizeof(seed)); 
       std::default_random_engine dre(seed);
       size_t count = fileIterEnd_ - fileIterBegin_;
       std::uniform_int_distribution<int> distribution(0, count - 1);
       while(!rootFile_ && count != 0) {
         --count;
         int offset = distribution(dre);
         fileIter_ = fileIterBegin_ + offset;
         initFile(skipBadFiles_);
       }
     } else {
       // Prestage the files
       for(fileIter_ = fileIterBegin_; fileIter_ != fileIterEnd_; ++fileIter_) {
         factory->activateTimeout(fileIter_->fileName());
         factory->stagein(fileIter_->fileName());
         //NOTE: we do not want to stage in all secondary files since we can be given a list of
         // thousands of files and prestaging all those files can cause a site to fail.
         // So, we stage in the first secondary file only.
         if(inputType_ != InputType::Primary) {
           break;
         }
       }
       // Open the first file.
       for(fileIter_ = fileIterBegin_; fileIter_ != fileIterEnd_; ++fileIter_) {
         initFile(skipBadFiles_);
         if(rootFile_) break;
       }
     }
     if(rootFile_) {
       productRegistryUpdate().updateFromInput(rootFile_->productRegistry()->productList());
       if(inputType == InputType::Primary && initialNumberOfEventsToSkip_ != 0) {
         skipEvents(initialNumberOfEventsToSkip_);
       }
     }
   }

edm::RootInputFileSequence::~RootInputFileSequence ( )

virtual

Definition at line 395 of file RootInputFileSequence.cc.

395 {

396 }

edm::RootInputFileSequence::RootInputFileSequence ( RootInputFileSequence const & )

delete

Member Function Documentation

void edm::RootInputFileSequence::closeFile_ ( )

Definition at line 161 of file RootInputFileSequence.cc.

References duplicateChecker_, input_, inputType_, lfn_, edm::Primary, rootFile_, edm::SecondarySource, and usedFallback_.

Referenced by endJob(), initFile(), and rewind_().

                                          {
     // close the currently open file, if any, and delete the RootFile object.
     if(rootFile_) {
       if(inputType_ != InputType::SecondarySource) {
         std::unique_ptr<InputSource::FileCloseSentry>
         sentry((inputType_ == InputType::Primary) ? new InputSource::FileCloseSentry(input_, lfn_, usedFallback_) : 0);
         rootFile_->close();
         if(duplicateChecker_) duplicateChecker_->inputFileClosed();
       }
       rootFile_.reset();
     }
   }

bool edm::RootInputFileSequence::containedInCurrentFile	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)		const

Definition at line 467 of file RootInputFileSequence.cc.

References rootFile_.

                                                                                                                         {
     if(!rootFile_) return false;
     return rootFile_->containsItem(run, lumi, event);
   }

void edm::RootInputFileSequence::dropUnwantedBranches_ ( std::vector< std::string > const & wantedBranches )

Definition at line 692 of file RootInputFileSequence.cc.

References edm::ParameterSet::addUntrackedParameter(), productSelectorRules_, cmsCodeRulesChecker::rules, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
     std::vector<std::string> rules;
     rules.reserve(wantedBranches.size() + 1);
     rules.emplace_back("drop *");
     for(std::string const& branch : wantedBranches) {
       rules.push_back("keep " + branch + "_*");
     }
     ParameterSet pset;
     pset.addUntrackedParameter("inputCommands", rules);
     productSelectorRules_ = ProductSelectorRules(pset, "inputCommands", "InputSource");
   }

void edm::RootInputFileSequence::endJob ( void )

Definition at line 138 of file RootInputFileSequence.cc.

References closeFile_().

                                 {
     closeFile_();
   }

std::shared_ptr< BranchIDListHelper const > edm::RootInputFileSequence::fileBranchIDListHelper ( ) const

Definition at line 341 of file RootInputFileSequence.cc.

References assert(), and rootFile_.

                                                       {
     assert(rootFile_);
     return rootFile_->branchIDListHelper();
   }

std::vector< FileCatalogItem > const & edm::RootInputFileSequence::fileCatalogItems ( ) const

private

Definition at line 133 of file RootInputFileSequence.cc.

References catalog_, and edm::InputFileCatalog::fileCatalogItems().

Referenced by readOneRandom().

                                                 {
     return catalog_.fileCatalogItems();
   }

std::shared_ptr< ProductRegistry const > edm::RootInputFileSequence::fileProductRegistry ( ) const

Definition at line 335 of file RootInputFileSequence.cc.

References assert(), and rootFile_.

                                                    {
     assert(rootFile_);
     return rootFile_->productRegistry();
   }

void edm::RootInputFileSequence::fillDescription ( ParameterSetDescription & desc )

static

Definition at line 904 of file RootInputFileSequence.cc.

References edm::ParameterSetDescription::addUntracked(), edm::roottree::defaultCacheSize, edm::EventSkipperByID::fillDescription(), edm::ProductSelectorRules::fillDescription(), edm::DuplicateChecker::fillDescription(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::PoolSource::fillDescriptions().

                                                                        {
     desc.addUntracked<unsigned int>("skipEvents", 0U)
         ->setComment("Skip the first 'skipEvents' events that otherwise would have been processed.");
     desc.addUntracked<bool>("noEventSort", true)
         ->setComment("True:  Process runs, lumis and events in the order they appear in the file (but see notes 1 and 2).\n"
                      "False: Process runs, lumis and events in each file in numerical order (run#, lumi#, event#) (but see note 3).\n"
                      "Note 1: Events within the same lumi will always be processed contiguously.\n"
                      "Note 2: Lumis within the same run will always be processed contiguously.\n"
                      "Note 3: Any sorting occurs independently in each input file (no sorting across input files).");
     desc.addUntracked<bool>("skipBadFiles", false)
         ->setComment("True:  Ignore any missing or unopenable input file.\n"
                      "False: Throw exception if missing or unopenable input file.");
     desc.addUntracked<bool>("bypassVersionCheck", false)
         ->setComment("True:  Bypass release version check.\n"
                      "False: Throw exception if reading file in a release prior to the release in which the file was written.");
     desc.addUntracked<unsigned int>("cacheSize", roottree::defaultCacheSize)
         ->setComment("Size of ROOT TTree prefetch cache.  Affects performance.");
     desc.addUntracked<int>("treeMaxVirtualSize", -1)
         ->setComment("Size of ROOT TTree TBasket cache.  Affects performance.");
     desc.addUntracked<unsigned int>("setRunNumber", 0U)
         ->setComment("If non-zero, change number of first run to this number. Apply same offset to all runs.  Allowed only for simulation.");
     desc.addUntracked<bool>("dropDescendantsOfDroppedBranches", true)
         ->setComment("If True, also drop on input any descendent of any branch dropped on input.");
     std::string defaultString("permissive");
     desc.addUntracked<std::string>("branchesMustMatch", defaultString)
         ->setComment("'strict':     Branches in each input file must match those in the first file.\n"
                      "'permissive': Branches in each input file may be any subset of those in the first file.");
     desc.addUntracked<bool>("labelRawDataLikeMC", true)
         ->setComment("If True: replace module label for raw data to match MC. Also use 'LHC' as process.");
 
     ProductSelectorRules::fillDescription(desc, "inputCommands");
     EventSkipperByID::fillDescription(desc);
     DuplicateChecker::fillDescription(desc);
   }

ProcessingController::ForwardState edm::RootInputFileSequence::forwardState ( ) const

Definition at line 940 of file RootInputFileSequence.cc.

References fileIter_, fileIterEnd_, edm::ProcessingController::kAtLastEvent, edm::ProcessingController::kEventsAheadInFile, edm::ProcessingController::kNextFileExists, edm::ProcessingController::kUnknownForward, and rootFile_.

                                             {
     if(rootFile_) {
       if(!rootFile_->wasLastEventJustRead()) {
         return ProcessingController::kEventsAheadInFile;
       }
       std::vector<FileCatalogItem>::const_iterator itr(fileIter_);
       if(itr != fileIterEnd_) ++itr;
       if(itr != fileIterEnd_) {
         return ProcessingController::kNextFileExists;
       }
       return ProcessingController::kAtLastEvent;
     }
     return ProcessingController::kUnknownForward;
   }

InputSource::ItemType edm::RootInputFileSequence::getNextItemType	(	RunNumber_t &	run,
		LuminosityBlockNumber_t &	lumi,
		EventNumber_t &	event
	)

Definition at line 442 of file RootInputFileSequence.cc.

References assert(), fileIter_, fileIterEnd_, firstFile_, edm::InputSource::IsEvent, edm::InputSource::IsFile, edm::InputSource::IsLumi, edm::InputSource::IsRun, edm::InputSource::IsStop, edm::IndexIntoFile::kEnd, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, and rootFile_.

                                                                                                               {
     if(fileIter_ == fileIterEnd_) {
       return InputSource::IsStop;
     }
     if(firstFile_) {
       return InputSource::IsFile;
     }
     if(rootFile_) {
       IndexIntoFile::EntryType entryType = rootFile_->getNextItemType(run, lumi, event);
       if(entryType == IndexIntoFile::kEvent) {
         return InputSource::IsEvent;
       } else if(entryType == IndexIntoFile::kLumi) {
         return InputSource::IsLumi;
       } else if(entryType == IndexIntoFile::kRun) {
         return InputSource::IsRun;
       }
       assert(entryType == IndexIntoFile::kEnd);
     }
     if(fileIter_ + 1 == fileIterEnd_) {
       return InputSource::IsStop;
     }
     return InputSource::IsFile;
   }

bool edm::RootInputFileSequence::goToEvent ( EventID const & eventID )

Definition at line 519 of file RootInputFileSequence.cc.

References assert(), edm::EventID::event(), fileIter_, fileIterBegin_, newFWLiteAna::found, indexesIntoFiles_, initFile(), edm::EventID::luminosityBlock(), rootFile_, edm::EventID::run(), and usingGoToEvent_.

                                                          {
     usingGoToEvent_ = true;
     if(rootFile_) {
       if(rootFile_->goToEvent(eventID)) {
         return true;
       }
       // If only one input file, give up now, to save time.
       if(rootFile_ && indexesIntoFiles_.size() == 1) {
         return false;
       }
       // Save the current file and position so that we can restore them
       // if we fail to restore the desired event
       bool closedOriginalFile = false;
       std::vector<FileCatalogItem>::const_iterator originalFile = fileIter_;
       IndexIntoFile::IndexIntoFileItr originalPosition = rootFile_->indexIntoFileIter();
 
       // Look for item (run/lumi/event) in files previously opened without reopening unnecessary files.
       typedef std::vector<std::shared_ptr<IndexIntoFile> >::const_iterator Iter;
       for(Iter it = indexesIntoFiles_.begin(), itEnd = indexesIntoFiles_.end(); it != itEnd; ++it) {
         if(*it && (*it)->containsItem(eventID.run(), eventID.luminosityBlock(), eventID.event())) {
           // We found it. Close the currently open file, and open the correct one.
           fileIter_ = fileIterBegin_ + (it - indexesIntoFiles_.begin());
           initFile(false);
           // Now get the item from the correct file.
           assert(rootFile_);
           bool found = rootFile_->goToEvent(eventID);
           assert(found);
           return true;
         }
       }
       // Look for item in files not yet opened.
       for(Iter it = indexesIntoFiles_.begin(), itEnd = indexesIntoFiles_.end(); it != itEnd; ++it) {
         if(!*it) {
           fileIter_ = fileIterBegin_ + (it - indexesIntoFiles_.begin());
           initFile(false);
           closedOriginalFile = true;
           if((*it)->containsItem(eventID.run(), eventID.luminosityBlock(), eventID.event())) {
             assert(rootFile_);
             if(rootFile_->goToEvent(eventID)) {
               return true;
             }
           }
         }
       }
       if(closedOriginalFile) {
         fileIter_ = originalFile;
         initFile(false);
         assert(rootFile_);
         rootFile_->setPosition(originalPosition);
       }
     }
     return false;
   }

void edm::RootInputFileSequence::initAssociationsFromSecondary ( std::set< BranchID > const & associationsFromSecondary )

Definition at line 969 of file RootInputFileSequence.cc.

References associationsFromSecondary_, and rootFile_.

                                                                                                              {
     for(auto const& branchID : associationsFromSecondary) {
       associationsFromSecondary_.push_back(branchID);
     }
     rootFile_->initAssociationsFromSecondary(associationsFromSecondary_);
   }

void edm::RootInputFileSequence::initFile ( bool skipBadFiles )

private

Definition at line 174 of file RootInputFileSequence.cc.

References StorageFactory::activateTimeout(), cms::Exception::additionalInfo(), assert(), associationsFromSecondary_, edm::InputSource::branchIDListHelper(), bypassVersionCheck_, closeFile_(), dropDescendants_, duplicateChecker_, alignCSCRings::e, enablePrefetching_, eventSkipperByID_, edm::hlt::Exception, cms::Exception::explainSelf(), edm::errors::FallbackFileOpenError, fileIter_, fileIterBegin_, fileIterEnd_, fileIterLastOpened_, edm::errors::FileOpenError, StorageFactory::get(), indexesIntoFiles_, initialNumberOfEventsToSkip_, input_, RPC_Client_on_RootFile::InputFile, inputType_, labelRawDataLikeMC_, lfn_, lfnHash_, noEventSort_, nStreams_, orderedProcessHistoryIDs_, dbtoconf::out, dbtoconf::pfn, edm::Primary, processConfiguration(), processHistoryRegistryForUpdate(), edm::InputSource::processingMode(), productSelectorRules_, remainingEvents(), remainingLuminosityBlocks(), edm::InputFile::reportFallbackAttempt(), edm::InputFile::reportSkippedFile(), rootFile_, alignCSCRings::s, edm::SecondaryFile, edm::SecondarySource, setRun_, AlCaHLTBitMon_QueryRunRegistry::string, edm::InputSource::thinnedAssociationsHelper(), treeCacheSize_, treeMaxVirtualSize_, usedFallback_, and usingGoToEvent_.

Referenced by goToEvent(), nextFile(), previousFile(), readFile_(), readOneRandom(), readOneSequential(), readOneSequentialWithID(), rewind_(), RootInputFileSequence(), skipEntries(), skipToItem(), and skipToItemInNewFile().

                                                         {
     // We are really going to close the open file.
 
     // If this is the primary sequence, we are not duplicate checking across files
     // and we are not using random access to find events, then we can delete the
     // IndexIntoFile for the file we are closing. If we can't delete all of it,
     // then we can delete the parts we do not need.
     if(fileIterLastOpened_ != fileIterEnd_) {
       size_t currentIndexIntoFile = fileIterLastOpened_ - fileIterBegin_;
       bool needIndexesForDuplicateChecker = duplicateChecker_ && duplicateChecker_->checkingAllFiles() && !duplicateChecker_->checkDisabled();
       bool deleteIndexIntoFile = inputType_ == InputType::Primary &&
                                  !needIndexesForDuplicateChecker &&
                                  !usingGoToEvent_;
       if(deleteIndexIntoFile) {
         indexesIntoFiles_[currentIndexIntoFile].reset();
       } else {
         if(indexesIntoFiles_[currentIndexIntoFile]) indexesIntoFiles_[currentIndexIntoFile]->inputFileClosed();
       }
       fileIterLastOpened_ = fileIterEnd_;
     }
     closeFile_();
 
     if(fileIter_ == fileIterEnd_) {
       // No files specified
       return;
     }
 
     // Check if the logical file name was found.
     if(fileIter_->fileName().empty()) {
       // LFN not found in catalog.
       InputFile::reportSkippedFile(fileIter_->fileName(), fileIter_->logicalFileName());
       if(!skipBadFiles) {
         throw cms::Exception("LogicalFileNameNotFound", "RootInputFileSequence::initFile()\n")
           << "Logical file name '" << fileIter_->logicalFileName() << "' was not found in the file catalog.\n"
           << "If you wanted a local file, you forgot the 'file:' prefix\n"
           << "before the file name in your configuration file.\n";
       }
       LogWarning("") << "Input logical file: " << fileIter_->logicalFileName() << " was not found in the catalog, and will be skipped.\n";
       return;
     }
 
     lfn_ = fileIter_->logicalFileName().empty() ? fileIter_->fileName() : fileIter_->logicalFileName();
     lfnHash_ = std::hash<std::string>()(lfn_);
     usedFallback_ = false;
 
     // Determine whether we have a fallback URL specified; if so, prepare it;
     // Only valid if it is non-empty and differs from the original filename.
     std::string fallbackName = fileIter_->fallbackFileName();
     bool hasFallbackUrl = !fallbackName.empty() && fallbackName != fileIter_->fileName();
 
     std::shared_ptr<InputFile> filePtr;
     std::list<std::string> originalInfo;
     try {
       std::unique_ptr<InputSource::FileOpenSentry>
         sentry(inputType_ == InputType::Primary ? new InputSource::FileOpenSentry(input_, lfn_, usedFallback_) : 0);
       filePtr.reset(new InputFile(gSystem->ExpandPathName(fileIter_->fileName().c_str()), "  Initiating request to open file ", inputType_));
     }
     catch (cms::Exception const& e) {
       if(!skipBadFiles) {
         if(hasFallbackUrl) {
           std::ostringstream out;
           out << e.explainSelf();
           std::string pfn(gSystem->ExpandPathName(fallbackName.c_str()));
           InputFile::reportFallbackAttempt(pfn, fileIter_->logicalFileName(), out.str());
           originalInfo = e.additionalInfo();
         } else {
           InputFile::reportSkippedFile(fileIter_->fileName(), fileIter_->logicalFileName());
           Exception ex(errors::FileOpenError, "", e);
           ex.addContext("Calling RootInputFileSequence::initFile()");
           std::ostringstream out;
           out << "Input file " << fileIter_->fileName() << " could not be opened.";
           ex.addAdditionalInfo(out.str());
           throw ex;
         }
       }
     }
     if(!filePtr && (hasFallbackUrl)) {
       try {
         usedFallback_ = true;
         std::unique_ptr<InputSource::FileOpenSentry>
           sentry(inputType_ == InputType::Primary ? new InputSource::FileOpenSentry(input_, lfn_, usedFallback_) : 0);
         std::string fallbackFullName = gSystem->ExpandPathName(fallbackName.c_str());
         StorageFactory *factory = StorageFactory::get();
         if (factory) {factory->activateTimeout(fallbackFullName);}
         filePtr.reset(new InputFile(fallbackFullName.c_str(), "  Fallback request to file ", inputType_));
       }
       catch (cms::Exception const& e) {
         if(!skipBadFiles) {
           InputFile::reportSkippedFile(fileIter_->fileName(), fileIter_->logicalFileName());
           Exception ex(errors::FallbackFileOpenError, "", e);
           ex.addContext("Calling RootInputFileSequence::initFile()");
           std::ostringstream out;
           out << "Input file " << fileIter_->fileName() << " could not be opened.\n";
           out << "Fallback Input file " << fallbackName << " also could not be opened.";
           if (originalInfo.size()) {
             out << std::endl << "Original exception info is above; fallback exception info is below.";
             ex.addAdditionalInfo(out.str());
             for (auto const & s : originalInfo) {
               ex.addAdditionalInfo(s);
             }
           } else {
             ex.addAdditionalInfo(out.str());
           }
           throw ex;
         }
       }
     }
     if(filePtr) {
       std::vector<std::shared_ptr<IndexIntoFile> >::size_type currentIndexIntoFile = fileIter_ - fileIterBegin_;
       rootFile_ = RootFileSharedPtr(new RootFile(
           fileIter_->fileName(),
           processConfiguration(),
           fileIter_->logicalFileName(),
           filePtr,
           eventSkipperByID_,
           initialNumberOfEventsToSkip_ != 0,
           remainingEvents(),
           remainingLuminosityBlocks(),
       nStreams_,
           treeCacheSize_,
           treeMaxVirtualSize_,
           input_.processingMode(),
           setRun_,
           noEventSort_,
           productSelectorRules_,
           inputType_,
           (inputType_ == InputType::SecondarySource ?  std::make_shared<BranchIDListHelper>() :  input_.branchIDListHelper()),
           (inputType_ == InputType::SecondarySource ?  std::shared_ptr<ThinnedAssociationsHelper>() : input_.thinnedAssociationsHelper()),
           associationsFromSecondary_,
           duplicateChecker_,
           dropDescendants_,
           processHistoryRegistryForUpdate(),
           indexesIntoFiles_,
           currentIndexIntoFile,
           orderedProcessHistoryIDs_,
           bypassVersionCheck_,
           labelRawDataLikeMC_,
           usingGoToEvent_,
           enablePrefetching_));
 
       assert(rootFile_);
       fileIterLastOpened_ = fileIter_;
       indexesIntoFiles_[currentIndexIntoFile] = rootFile_->indexIntoFileSharedPtr();
       char const* inputType = 0;
       switch(inputType_) {
       case InputType::Primary: inputType = "primaryFiles"; break;
       case InputType::SecondaryFile: inputType = "secondaryFiles"; break;
       case InputType::SecondarySource: inputType = "mixingFiles"; break;
       }
       rootFile_->reportOpened(inputType);
     } else {
       InputFile::reportSkippedFile(fileIter_->fileName(), fileIter_->logicalFileName());
       if(!skipBadFiles) {
         throw Exception(errors::FileOpenError) <<
            "RootInputFileSequence::initFile(): Input file " << fileIter_->fileName() << " was not found or could not be opened.\n";
       }
       LogWarning("") << "Input file: " << fileIter_->fileName() << " was not found or could not be opened, and will be skipped.\n";
     }
   }

bool edm::RootInputFileSequence::nextFile ( )

private

Definition at line 346 of file RootInputFileSequence.cc.

References branchesMustMatch_, edm::hlt::Exception, fileIter_, fileIterBegin_, fileIterEnd_, initFile(), inputType_, edm::ProductRegistry::merge(), edm::errors::MismatchedInputFiles, edm::Primary, productRegistryUpdate(), rootFile_, skipBadFiles_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by readFile_(), and skipEvents().

                                        {
     if(fileIter_ != fileIterEnd_) ++fileIter_;
     if(fileIter_ == fileIterEnd_) {
       if(inputType_ == InputType::Primary) {
         return false;
       } else {
         fileIter_ = fileIterBegin_;
       }
     }
 
     initFile(skipBadFiles_);
 
     if(inputType_ == InputType::Primary && rootFile_) {
       // make sure the new product registry is compatible with the main one
       std::string mergeInfo = productRegistryUpdate().merge(*rootFile_->productRegistry(),
                                                             fileIter_->fileName(),
                                                             branchesMustMatch_);
       if(!mergeInfo.empty()) {
         throw Exception(errors::MismatchedInputFiles,"RootInputFileSequence::nextFile()") << mergeInfo;
       }
     }
     return true;
   }

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

delete

bool edm::RootInputFileSequence::previousFile ( )

private

Definition at line 370 of file RootInputFileSequence.cc.

References branchesMustMatch_, edm::hlt::Exception, fileIter_, fileIterBegin_, fileIterEnd_, initFile(), inputType_, edm::ProductRegistry::merge(), edm::errors::MismatchedInputFiles, edm::Primary, productRegistryUpdate(), rootFile_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by skipEvents().

                                            {
     if(fileIter_ == fileIterBegin_) {
       if(inputType_ == InputType::Primary) {
         return false;
       } else {
         fileIter_ = fileIterEnd_;
       }
     }
     --fileIter_;
 
     initFile(false);
 
     if(inputType_ == InputType::Primary && rootFile_) {
       // make sure the new product registry is compatible to the main one
       std::string mergeInfo = productRegistryUpdate().merge(*rootFile_->productRegistry(),
                                                             fileIter_->fileName(),
                                                             branchesMustMatch_);
       if(!mergeInfo.empty()) {
         throw Exception(errors::MismatchedInputFiles,"RootInputFileSequence::previousEvent()") << mergeInfo;
       }
     }
     if(rootFile_) rootFile_->setToLastEntry();
     return true;
   }

ProcessConfiguration const & edm::RootInputFileSequence::processConfiguration ( ) const

private

Definition at line 667 of file RootInputFileSequence.cc.

References input_, and edm::InputSource::processConfiguration().

Referenced by initFile().

                                                     {
     return input_.processConfiguration();
   }

ProcessHistoryRegistry const & edm::RootInputFileSequence::processHistoryRegistry ( ) const

Definition at line 657 of file RootInputFileSequence.cc.

References input_, and edm::InputSource::processHistoryRegistry().

                                                       {
     return input_.processHistoryRegistry();
   }

ProcessHistoryRegistry & edm::RootInputFileSequence::processHistoryRegistryForUpdate ( )

Definition at line 662 of file RootInputFileSequence.cc.

References input_, and edm::InputSource::processHistoryRegistryForUpdate().

Referenced by initFile().

                                                          {
     return input_.processHistoryRegistryForUpdate();
   }

std::shared_ptr< ProductRegistry const > edm::RootInputFileSequence::productRegistry ( ) const

private

Definition at line 687 of file RootInputFileSequence.cc.

References input_, and edm::InputSource::productRegistry().

                                               {
     return input_.productRegistry();
   }

ProductRegistry & edm::RootInputFileSequence::productRegistryUpdate ( ) const

private

Definition at line 682 of file RootInputFileSequence.cc.

References input_, and edm::InputSource::productRegistryUpdate().

Referenced by nextFile(), previousFile(), and RootInputFileSequence().

                                                     {
     return input_.productRegistryUpdate();
   }

void edm::RootInputFileSequence::readEvent ( EventPrincipal & cache )

Definition at line 436 of file RootInputFileSequence.cc.

References assert(), and rootFile_.

                                                                  {
     assert(rootFile_);
     rootFile_->readEvent(eventPrincipal);
   }

std::unique_ptr< FileBlock > edm::RootInputFileSequence::readFile_ ( )

Definition at line 143 of file RootInputFileSequence.cc.

References assert(), firstFile_, initFile(), nextFile(), rootFile_, and skipBadFiles_.

                                    {
     if(firstFile_) {
       // The first input file has already been opened.
       firstFile_ = false;
       if(!rootFile_) {
         initFile(skipBadFiles_);
       }
     } else {
       if(!nextFile()) {
         assert(0);
       }
     }
     if(!rootFile_) {
       return std::unique_ptr<FileBlock>(new FileBlock);
     }
     return rootFile_->createFileBlock();
   }

void edm::RootInputFileSequence::readLuminosityBlock_ ( LuminosityBlockPrincipal & lumiPrincipal )

Definition at line 417 of file RootInputFileSequence.cc.

References assert(), and rootFile_.

                                                                                      {
     assert(rootFile_);
     rootFile_->readLuminosityBlock_(lumiPrincipal);
   }

std::shared_ptr< LuminosityBlockAuxiliary > edm::RootInputFileSequence::readLuminosityBlockAuxiliary_ ( )

Definition at line 405 of file RootInputFileSequence.cc.

References assert(), and rootFile_.

                                                        {
     assert(rootFile_);
     return rootFile_->readLuminosityBlockAuxiliary_();
   }

void edm::RootInputFileSequence::readOneRandom	(	EventPrincipal &	cache,
		size_t &	fileNameHash,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 825 of file RootInputFileSequence.cc.

References assert(), edm::errors::Configuration, eventsRemainingInFile_, edm::hlt::Exception, fileCatalogItems(), fileIter_, fileIterBegin_, fileIterEnd_, firstFile_, newFWLiteAna::found, initFile(), lfnHash_, edm::errors::NotFound, rootFile_, findQualityFiles::size, and skipBadFiles_.

                                                                                                                 {
     firstFile_ = false;
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneRandom(): no input files specified for secondary input source.\n";
     }
     assert(rootFile_);
     skipBadFiles_ = false;
     unsigned int currentSeqNumber = fileIter_ - fileIterBegin_;
     while(eventsRemainingInFile_ == 0) {
 
       fileIter_ = fileIterBegin_ + CLHEP::RandFlat::shootInt(engine, fileCatalogItems().size());
       unsigned int newSeqNumber = fileIter_ - fileIterBegin_;
       if(newSeqNumber != currentSeqNumber) {
         initFile(false);
         currentSeqNumber = newSeqNumber;
       }
       eventsRemainingInFile_ = rootFile_->eventTree().entries();
       if(eventsRemainingInFile_ == 0) {
         throw Exception(errors::NotFound) <<
            "RootInputFileSequence::readOneRandom(): Secondary Input file " << fileIter_->fileName() << " contains no events.\n";
       }
       rootFile_->setAtEventEntry(CLHEP::RandFlat::shootInt(engine, eventsRemainingInFile_) - 1);
     }
     rootFile_->nextEventEntry();
 
     bool found = rootFile_->readCurrentEvent(cache);
     if(!found) {
       rootFile_->setAtEventEntry(0);
       bool found = rootFile_->readCurrentEvent(cache);
       assert(found);
     }
     fileNameHash = lfnHash_;
     --eventsRemainingInFile_;
   }

bool edm::RootInputFileSequence::readOneRandomWithID	(	EventPrincipal &	cache,
		size_t &	fileNameHash,
		LuminosityBlockID const &	id,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 863 of file RootInputFileSequence.cc.

References assert(), edm::errors::Configuration, edm::hlt::Exception, fileIter_, fileIterBegin_, fileIterEnd_, firstFile_, newFWLiteAna::found, i, lfnHash_, rootFile_, DTTTrigCorrFirst::run, skipBadFiles_, and skipToItem().

                                                                                                                                                    {
     firstFile_ = false;
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneRandomWithID(): no input files specified for secondary input source.\n";
     }
     skipBadFiles_ = false;
     if(fileIter_ == fileIterEnd_ || !rootFile_ ||
         rootFile_->indexIntoFileIter().run() != id.run() ||
         rootFile_->indexIntoFileIter().lumi() != id.luminosityBlock()) {
       bool found = skipToItem(id.run(), id.luminosityBlock(), 0);
       if(!found) {
         return false;
       }
       int eventsInLumi = 0;
       assert(rootFile_);
       while(rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock())) ++eventsInLumi;
       found = skipToItem(id.run(), id.luminosityBlock(), 0);
       assert(found);
       int eventInLumi = CLHEP::RandFlat::shootInt(engine, eventsInLumi);
       for(int i = 0; i < eventInLumi; ++i) {
         bool found = rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock());
         assert(found);
       }
     }
     assert(rootFile_);
     bool found = rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock());
     if(found) {
       found = rootFile_->readCurrentEvent(cache);
     }
     if(!found) {
       bool found = rootFile_->setEntryAtItem(id.run(), id.luminosityBlock(), 0);
       if(!found) {
         return false;
       }
       return readOneRandomWithID(cache, fileNameHash, id, engine);
     }
     fileNameHash = lfnHash_;
     return true;
   }

bool edm::RootInputFileSequence::readOneSequential	(	EventPrincipal &	cache,
		size_t &	fileNameHash
	)

Definition at line 721 of file RootInputFileSequence.cc.

References assert(), edm::errors::Configuration, edm::hlt::Exception, fileIter_, fileIterBegin_, fileIterEnd_, firstFile_, newFWLiteAna::found, initFile(), initialNumberOfEventsToSkip_, edm::IndexIntoFile::invalidEntry, lfnHash_, rootFile_, skipBadFiles_, and skipEntries().

                                                                                       {
     skipBadFiles_ = false;
     if(firstFile_) {
       firstFile_ = false;
       if(fileIterEnd_ == fileIterBegin_) {
         throw Exception(errors::Configuration) << "RootInputFileSequence::readOneSequential(): no input files specified for secondary input source.\n";
       }
       if(fileIter_ != fileIterBegin_) {
         fileIter_ = fileIterBegin_;
         initFile(false);
       }
       assert(rootFile_);
       rootFile_->setAtEventEntry(IndexIntoFile::invalidEntry);
       skipEntries(initialNumberOfEventsToSkip_);
     }
     assert(rootFile_);
     rootFile_->nextEventEntry();
     bool found = rootFile_->readCurrentEvent(cache);
     if(!found) {
       ++fileIter_;
       if(fileIter_ == fileIterEnd_) {
         fileIter_ = fileIterBegin_;
       }
       initFile(false);
       assert(rootFile_);
       rootFile_->setAtEventEntry(IndexIntoFile::invalidEntry);
       return readOneSequential(cache, fileNameHash);
     }
     fileNameHash = lfnHash_;
     return true;
   }

bool edm::RootInputFileSequence::readOneSequentialWithID	(	EventPrincipal &	cache,
		size_t &	fileNameHash,
		LuminosityBlockID const &	id
	)

Definition at line 754 of file RootInputFileSequence.cc.

References assert(), edm::errors::Configuration, edm::hlt::Exception, fileIter_, fileIterBegin_, fileIterEnd_, firstFile_, newFWLiteAna::found, initFile(), initialNumberOfEventsToSkip_, edm::IndexIntoFile::invalidEntry, lfnHash_, HLT_25ns14e33_v1_cff::offset, rootFile_, DTTTrigCorrFirst::run, skipBadFiles_, skipToItem(), and skipToItemInNewFile().

                                                                                                                          {
     skipBadFiles_ = false;
     if(firstFile_) {
       firstFile_ = false;
       if(fileIterEnd_ == fileIterBegin_) {
         throw Exception(errors::Configuration) << "RootInputFileSequence::readOneSequential(): no input files specified for secondary input source.\n";
       }
       if(fileIter_ != fileIterBegin_) {
         fileIter_ = fileIterBegin_;
         initFile(false);
       }
       assert(rootFile_);
       rootFile_->setAtEventEntry(IndexIntoFile::invalidEntry);
       int offset = initialNumberOfEventsToSkip_;
       while(offset > 0) {
         bool found = readOneSequentialWithID(cache, fileNameHash, id);
         if(!found) {
           return false;
         }
         --offset;
       }
     }
     assert(rootFile_);
     if(fileIter_ == fileIterEnd_ ||
         rootFile_->indexIntoFileIter().run() != id.run() ||
         rootFile_->indexIntoFileIter().lumi() != id.luminosityBlock()) {
       bool found = skipToItem(id.run(), id.luminosityBlock(), 0, 0, false);
       if(!found) {
         return false;
       }
     }
     assert(rootFile_);
     bool found = rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock());
     if(found) {
       found = rootFile_->readCurrentEvent(cache);
     }
     if(!found) {
       found = skipToItemInNewFile(id.run(), id.luminosityBlock(), 0);
       if(!found) {
         return false;
       }
       return readOneSequentialWithID(cache, fileNameHash, id);
     }
     fileNameHash = lfnHash_;
     return true;
   }

void edm::RootInputFileSequence::readOneSpecified	(	EventPrincipal &	cache,
		size_t &	fileNameHash,
		SecondaryEventIDAndFileInfo const &	id
	)

Definition at line 802 of file RootInputFileSequence.cc.

References assert(), edm::errors::Configuration, event(), edm::SecondaryEventIDAndFileInfo::eventID(), edm::hlt::Exception, fileIterBegin_, fileIterEnd_, edm::SecondaryEventIDAndFileInfo::fileNameHash(), firstFile_, newFWLiteAna::found, lfnHash_, edm::errors::NotFound, rootFile_, DTTTrigCorrFirst::run, skipBadFiles_, and skipToItem().

                                                                                                                              {
     firstFile_ = false;
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneSpecified(): no input files specified for secondary input source.\n";
     }
     skipBadFiles_ = false;
     EventID const& id = idx.eventID();
     bool found = skipToItem(id.run(), id.luminosityBlock(), id.event(), idx.fileNameHash());
     if(!found) {
        throw Exception(errors::NotFound) <<
          "RootInputFileSequence::readOneSpecified(): Secondary Input files" <<
          " do not contain specified event:\n" << id << "\n";
     }
     assert(rootFile_);
     found = rootFile_->readCurrentEvent(cache);
     assert(found);
     fileNameHash = idx.fileNameHash();
     if(fileNameHash == 0U)  {
       fileNameHash = lfnHash_;
     }
   }

void edm::RootInputFileSequence::readRun_ ( RunPrincipal & runPrincipal )

Definition at line 411 of file RootInputFileSequence.cc.

References assert(), and rootFile_.

                                                             {
     assert(rootFile_);
     rootFile_->readRun_(runPrincipal);
   }

std::shared_ptr< RunAuxiliary > edm::RootInputFileSequence::readRunAuxiliary_ ( )

Definition at line 399 of file RootInputFileSequence.cc.

References assert(), and rootFile_.

                                            {
     assert(rootFile_);
     return rootFile_->readRunAuxiliary_();
   }

int edm::RootInputFileSequence::remainingEvents ( ) const

private

Definition at line 672 of file RootInputFileSequence.cc.

References input_, and edm::InputSource::remainingEvents().

Referenced by initFile().

                                                {
     return input_.remainingEvents();
   }

int edm::RootInputFileSequence::remainingLuminosityBlocks ( ) const

private

Definition at line 677 of file RootInputFileSequence.cc.

References input_, and edm::InputSource::remainingLuminosityBlocks().

Referenced by initFile().

                                                          {
     return input_.remainingLuminosityBlocks();
   }

ProcessingController::ReverseState edm::RootInputFileSequence::reverseState ( ) const

Definition at line 956 of file RootInputFileSequence.cc.

References fileIter_, fileIterBegin_, edm::ProcessingController::kAtFirstEvent, edm::ProcessingController::kEventsBackwardsInFile, edm::ProcessingController::kPreviousFileExists, edm::ProcessingController::kUnknownReverse, and rootFile_.

                                             {
     if(rootFile_) {
       if(!rootFile_->wasFirstEventJustRead()) {
         return ProcessingController::kEventsBackwardsInFile;
       }
       if(fileIter_ != fileIterBegin_) {
         return ProcessingController::kPreviousFileExists;
       }
       return ProcessingController::kAtFirstEvent;
     }
     return ProcessingController::kUnknownReverse;
   }

void edm::RootInputFileSequence::rewind_ ( )

Definition at line 474 of file RootInputFileSequence.cc.

References closeFile_(), fileIter_, fileIterBegin_, firstFile_, initFile(), initialNumberOfEventsToSkip_, rewindFile(), rootFile_, and skipEvents().

                                  {
     if(fileIter_ != fileIterBegin_) {
       closeFile_();
       fileIter_ = fileIterBegin_;
     }
     if(!rootFile_) {
       initFile(false);
     }
     rewindFile();
     firstFile_ = true;
     if(rootFile_) {
       if(initialNumberOfEventsToSkip_ != 0) {
         skipEvents(initialNumberOfEventsToSkip_);
       }
     }
   }

void edm::RootInputFileSequence::rewindFile ( )

private

Definition at line 493 of file RootInputFileSequence.cc.

References rootFile_.

Referenced by rewind_().

                                     {
     if(rootFile_) rootFile_->rewind();
   }

void edm::RootInputFileSequence::skipEntries ( unsigned int offset )

Definition at line 705 of file RootInputFileSequence.cc.

References assert(), fileIter_, fileIterBegin_, fileIterEnd_, initFile(), edm::IndexIntoFile::invalidEntry, and rootFile_.

Referenced by readOneSequential().

                                                         {
     // offset is decremented by the number of events actually skipped.
     bool completed = rootFile_->skipEntries(offset);
     while(!completed) {
       ++fileIter_;
       if(fileIter_ == fileIterEnd_) {
         fileIter_ = fileIterBegin_;
       }
       initFile(false);
       assert(rootFile_);
       rootFile_->setAtEventEntry(IndexIntoFile::invalidEntry);
       completed = rootFile_->skipEntries(offset);
     }
   }

bool edm::RootInputFileSequence::skipEvents ( int offset )

Definition at line 499 of file RootInputFileSequence.cc.

References assert(), fileIter_, fileIterEnd_, inputType_, nextFile(), previousFile(), rootFile_, and edm::SecondaryFile.

Referenced by rewind_(), and RootInputFileSequence().

                                               {
     // We never call skipEvents for secondary input files.  If we did,
     // we would have to implement synchronization if a new file is opened.
     // To avoid this, just assert.
     assert(inputType_ != InputType::SecondaryFile);
     assert(rootFile_);
     while(offset != 0) {
       bool atEnd = rootFile_->skipEvents(offset);
       if((offset > 0 || atEnd) && !nextFile()) {
         return false;
       }
       if(offset < 0 && !previousFile()) {
         fileIter_ = fileIterEnd_;
         return false;
       }
     }
     return true;
   }

bool edm::RootInputFileSequence::skipToItem	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event,
		size_t	fileNameHash = `0U`,
		bool	currentFileFirst = `true`
	)

Definition at line 626 of file RootInputFileSequence.cc.

References assert(), fileIter_, fileIterBegin_, newFWLiteAna::found, indexesIntoFiles_, initFile(), rootFile_, and skipToItemInNewFile().

Referenced by readOneRandomWithID(), readOneSequentialWithID(), and readOneSpecified().

                                                                                                                                                   {
     // Attempt to find item in currently open input file.
     bool found = currentFileFirst && rootFile_ && rootFile_->setEntryAtItem(run, lumi, event);
     if(!found) {
       // If only one input file, give up now, to save time.
       if(currentFileFirst && rootFile_ && indexesIntoFiles_.size() == 1) {
         return false;
       }
       // Look for item (run/lumi/event) in files previously opened without reopening unnecessary files.
       typedef std::vector<std::shared_ptr<IndexIntoFile> >::const_iterator Iter;
       for(Iter it = indexesIntoFiles_.begin(), itEnd = indexesIntoFiles_.end(); it != itEnd; ++it) {
         if(*it && (*it)->containsItem(run, lumi, event)) {
           // We found it. Close the currently open file, and open the correct one.
           std::vector<FileCatalogItem>::const_iterator currentIter = fileIter_;
           fileIter_ = fileIterBegin_ + (it - indexesIntoFiles_.begin());
           if(fileIter_ != currentIter) {
             initFile(false);
           }
           // Now get the item from the correct file.
           assert(rootFile_);
           found = rootFile_->setEntryAtItem(run, lumi, event);
           assert(found);
           return true;
         }
       }
       return (fileNameHash != 0U && skipToItemInNewFile(run, lumi, event, fileNameHash)) || skipToItemInNewFile(run, lumi, event);
     }
     return true;
   }

bool edm::RootInputFileSequence::skipToItemInNewFile	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)

Definition at line 606 of file RootInputFileSequence.cc.

References assert(), fileIter_, fileIterBegin_, newFWLiteAna::found, indexesIntoFiles_, initFile(), and rootFile_.

Referenced by readOneSequentialWithID(), and skipToItem().

                                                                                                                {
     // Look for item in files not yet opened.  We do not have a valid hash of the logical file name.
     typedef std::vector<std::shared_ptr<IndexIntoFile> >::const_iterator Iter;
     for(Iter it = indexesIntoFiles_.begin(), itEnd = indexesIntoFiles_.end(); it != itEnd; ++it) {
       if(!*it) {
         // File not yet opened.
         fileIter_ = fileIterBegin_ + (it - indexesIntoFiles_.begin());
         initFile(false);
         assert(rootFile_);
         bool found = rootFile_->setEntryAtItem(run, lumi, event);
         if(found) {
           return true;
         }
       }
     }
     // Not found
     return false;
   }

bool edm::RootInputFileSequence::skipToItemInNewFile	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event,
		size_t	fileNameHash
	)

Definition at line 574 of file RootInputFileSequence.cc.

References assert(), fileIter_, fileIterBegin_, fileIterEnd_, findFileForSpecifiedID_, newFWLiteAna::found, indexesIntoFiles_, initFile(), getDQMSummary::iter, and rootFile_.

                                                                                                                                     {
     // Look for item in files not yet opened. We have a hash of the logical file name
     assert(fileNameHash != 0U);
     // If the lookup table is not yet filled in, fill it. 
     if(!findFileForSpecifiedID_) {
       // We use a multimap because there may be hash collisions (Two different LFNs could have the same hash).
       // We map the hash of the LFN to the index into the list of files.
       findFileForSpecifiedID_.reset(new std::unordered_multimap<size_t, size_t>);
       auto hasher = std::hash<std::string>();
       for(auto fileIter = fileIterBegin_; fileIter != fileIterEnd_; ++fileIter) {
         findFileForSpecifiedID_->insert(std::make_pair(hasher(fileIter->logicalFileName()), fileIter - fileIterBegin_));
       }
     }
     // Look up the logical file name in the table
     auto range = findFileForSpecifiedID_->equal_range(fileNameHash);
     for(auto iter = range.first; iter != range.second; ++iter) {
       // Don't look in files previously opened, because those have already been searched.
       if(!indexesIntoFiles_[iter->second]) {
         fileIter_ = fileIterBegin_ + iter->second;
         initFile(false);
         assert(rootFile_);
         bool found = rootFile_->setEntryAtItem(run, lumi, event);
         if(found) {
           return true;
         }
       }
     }
     // Not found
     return false;
   }