#include <RootInputFileSequence.h>

Public Types
typedef boost::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 ()

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

boost::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)

RootInputFileSequence &	operator= (RootInputFileSequence const &)=delete

ProcessHistoryRegistry const &	processHistoryRegistry () const

ProcessHistoryRegistry &	processHistoryRegistryForUpdate ()

void	readEvent (EventPrincipal &cache)

std::unique_ptr< FileBlock >	readFile_ ()

void	readLuminosityBlock_ (LuminosityBlockPrincipal &lumiPrincipal)

boost::shared_ptr < LuminosityBlockAuxiliary >	readLuminosityBlockAuxiliary_ ()

void	readOneRandom (EventPrincipal &cache)

bool	readOneRandomWithID (EventPrincipal &cache, LuminosityBlockID const &id)

bool	readOneSequential (EventPrincipal &cache)

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

void	readOneSpecified (EventPrincipal &cache, EventID const &id)

void	readRun_ (RunPrincipal &runPrincipal)

boost::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

bool	skipEvents (int offset)

bool	skipToItem (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event, bool currentFileFirst=true)

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

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

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

ProductRegistry &	productRegistryUpdate () const

int	remainingEvents () const

int	remainingLuminosityBlocks () const

void	rewindFile ()

Private Attributes
BranchDescription::MatchMode	branchesMustMatch_

InputFileCatalog const &	catalog_

bool	dropDescendants_

boost::shared_ptr < DuplicateChecker >	duplicateChecker_

bool	enablePrefetching_

boost::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_

bool	firstFile_

std::unique_ptr< CLHEP::RandFlat >	flatDistribution_

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

int	initialNumberOfEventsToSkip_

PoolSource &	input_

InputType	inputType_

bool	labelRawDataLikeMC_

std::string	lfn_

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 37 of file RootInputFileSequence.h.

Member Typedef Documentation

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

Definition at line 49 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 28 of file RootInputFileSequence.cc.

References StorageFactory::activateTimeout(), branchesMustMatch_, enablePrefetching_, fileIter_, fileIterBegin_, fileIterEnd_, StorageFactory::get(), edm::ParameterSet::getUntrackedParameter(), initFile(), initialNumberOfEventsToSkip_, inputType_, edm::Service< T >::isAvailable(), edm::Primary, productRegistryUpdate(), rootFile_, edm::SecondarySource, 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"),
     fileIterBegin_(fileCatalogItems().begin()),
     fileIterEnd_(fileCatalogItems().end()),
     fileIter_(fileIterEnd_),
     fileIterLastOpened_(fileIterEnd_),
     rootFile_(),
     branchesMustMatch_(BranchDescription::Permissive),
     flatDistribution_(),
     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::Primary ? pset.getUntrackedParameter<unsigned int>("skipEvents", 0U) : 0U),
     noEventSort_(inputType == InputType::Primary ? pset.getUntrackedParameter<bool>("noEventSort", true) : false),
     skipBadFiles_(pset.getUntrackedParameter<bool>("skipBadFiles", 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();
     }
 
     StorageFactory *factory = StorageFactory::get();
     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;
       }
     }
 
     std::string branchesMustMatch = pset.getUntrackedParameter<std::string>("branchesMustMatch", std::string("permissive"));
     if(branchesMustMatch == std::string("strict")) branchesMustMatch_ = BranchDescription::Strict;
 
     for(fileIter_ = fileIterBegin_; fileIter_ != fileIterEnd_; ++fileIter_) {
       initFile(skipBadFiles_);
       if(rootFile_) break;
     }
     if(rootFile_) {
       productRegistryUpdate().updateFromInput(rootFile_->productRegistry()->productList());
       if(initialNumberOfEventsToSkip_ != 0) {
         skipEvents(initialNumberOfEventsToSkip_);
       }
     }
   }

edm::RootInputFileSequence::~RootInputFileSequence ( )

virtual

Definition at line 353 of file RootInputFileSequence.cc.

353 {

354 }

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

delete

Member Function Documentation

void edm::RootInputFileSequence::closeFile_ ( )

Definition at line 137 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 420 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 607 of file RootInputFileSequence.cc.

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

                                                                                          {
     std::vector<std::string> rules;
     rules.reserve(wantedBranches.size() + 1);
     rules.emplace_back("drop *");
     for(std::vector<std::string>::const_iterator it = wantedBranches.begin(), itEnd = wantedBranches.end();
         it != itEnd; ++it) {
       rules.push_back("keep " + *it + "_*");
     }
     ParameterSet pset;
     pset.addUntrackedParameter("inputCommands", rules);
     productSelectorRules_ = ProductSelectorRules(pset, "inputCommands", "InputSource");
   }

void edm::RootInputFileSequence::endJob ( void )

Definition at line 114 of file RootInputFileSequence.cc.

References closeFile_().

                                 {
     closeFile_();
   }

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

Definition at line 299 of file RootInputFileSequence.cc.

References rootFile_.

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

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

private

Definition at line 109 of file RootInputFileSequence.cc.

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

Referenced by readOneRandom().

                                                 {
     return catalog_.fileCatalogItems();
   }

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

Definition at line 293 of file RootInputFileSequence.cc.

References rootFile_.

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

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

static

Definition at line 771 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<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 804 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 395 of file RootInputFileSequence.cc.

References 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 471 of file RootInputFileSequence.cc.

References 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<boost::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.
           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())) {
             if  (rootFile_->goToEvent(eventID)) {
               return true;
             }
           }
         }
       }
       if(closedOriginalFile) {
         fileIter_ = originalFile;
         initFile(false);
         rootFile_->setPosition(originalPosition);
       }
     }
     return false;
   }

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

private

Definition at line 150 of file RootInputFileSequence.cc.

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

Referenced by goToEvent(), nextFile(), previousFile(), readFile_(), readOneRandom(), readOneSequential(), rewind_(), RootInputFileSequence(), 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();
     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();
 
     boost::shared_ptr<InputFile> filePtr;
     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());
         } 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);
         filePtr.reset(new InputFile(gSystem->ExpandPathName(fallbackName.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.";
           ex.addAdditionalInfo(out.str());
           throw ex;
         }
       }
     }
     if(filePtr) {
       std::vector<boost::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 ?  boost::shared_ptr<BranchIDListHelper>(new BranchIDListHelper()) :  input_.branchIDListHelper()),
           duplicateChecker_,
           dropDescendants_,
           processHistoryRegistryForUpdate(),
           indexesIntoFiles_,
           currentIndexIntoFile,
           orderedProcessHistoryIDs_,
           labelRawDataLikeMC_,
           usingGoToEvent_,
           enablePrefetching_));
 
       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 304 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 328 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 582 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 572 of file RootInputFileSequence.cc.

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

                                                       {
     return input_.processHistoryRegistry();
   }

ProcessHistoryRegistry & edm::RootInputFileSequence::processHistoryRegistryForUpdate ( )

Definition at line 577 of file RootInputFileSequence.cc.

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

Referenced by initFile().

                                                          {
     return input_.processHistoryRegistryForUpdate();
   }

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

private

Definition at line 602 of file RootInputFileSequence.cc.

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

                                               {
     return input_.productRegistry();
   }

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

private

Definition at line 597 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 390 of file RootInputFileSequence.cc.

References rootFile_.

                                                                  {
     rootFile_->readEvent(eventPrincipal);
   }

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

Definition at line 119 of file RootInputFileSequence.cc.

References 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 372 of file RootInputFileSequence.cc.

References rootFile_.

                                                                                      {
     rootFile_->readLuminosityBlock_(lumiPrincipal);
   }

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

Definition at line 362 of file RootInputFileSequence.cc.

References rootFile_.

                                                        {
     return rootFile_->readLuminosityBlockAuxiliary_();
   }

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

Definition at line 690 of file RootInputFileSequence.cc.

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

                                                             {
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneRandom(): no input files specified for secondary input source.\n";
     }
     if(!flatDistribution_) {
       Service<RandomNumberGenerator> rng;
       CLHEP::HepRandomEngine& engine = rng->getEngine();
       flatDistribution_.reset(new CLHEP::RandFlat(engine));
     }
     skipBadFiles_ = false;
     unsigned int currentSeqNumber = fileIter_ - fileIterBegin_;
     while(eventsRemainingInFile_ == 0) {
       fileIter_ = fileIterBegin_ + flatDistribution_->fireInt(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(flatDistribution_->fireInt(eventsRemainingInFile_) - 1);
     }
     rootFile_->nextEventEntry();
 
     bool found = rootFile_->readCurrentEvent(cache);
     if(!found) {
       rootFile_->setAtEventEntry(0);
       bool found = rootFile_->readCurrentEvent(cache);
       assert(found);
     }
     --eventsRemainingInFile_;
   }

bool edm::RootInputFileSequence::readOneRandomWithID	(	EventPrincipal &	cache,
		LuminosityBlockID const &	id
	)

Definition at line 729 of file RootInputFileSequence.cc.

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

                                                                                                {
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneRandomWithID(): no input files specified for secondary input source.\n";
     }
     if(!flatDistribution_) {
       Service<RandomNumberGenerator> rng;
       CLHEP::HepRandomEngine& engine = rng->getEngine();
       flatDistribution_.reset(new CLHEP::RandFlat(engine));
     }
     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;
       while(rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock())) ++eventsInLumi;
       found = skipToItem(id.run(), id.luminosityBlock(), 0);
       assert(found);
       int eventInLumi = flatDistribution_->fireInt(eventsInLumi);
       for(int i = 0; i < eventInLumi; ++i) {
         bool found = rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock());
         assert(found);
       }
     }
     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, id);
     }
     return true;
   }

bool edm::RootInputFileSequence::readOneSequential ( EventPrincipal & cache )

Definition at line 621 of file RootInputFileSequence.cc.

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

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

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

Definition at line 646 of file RootInputFileSequence.cc.

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

                                                                                                    {
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneSequentialWithID(): 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, false);
       if(!found) {
         return false;
       }
     }
     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, id);
     }
     return true;
   }

void edm::RootInputFileSequence::readOneSpecified	(	EventPrincipal &	cache,
		EventID const &	id
	)

Definition at line 674 of file RootInputFileSequence.cc.

References edm::errors::Configuration, event(), edm::hlt::Exception, fileIterBegin_, fileIterEnd_, newFWLiteAna::found, edm::errors::NotFound, rootFile_, DTTTrigCorrFirst::run, skipBadFiles_, and skipToItem().

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

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

Definition at line 367 of file RootInputFileSequence.cc.

References rootFile_.

                                                             {
     rootFile_->readRun_(runPrincipal);
   }

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

Definition at line 357 of file RootInputFileSequence.cc.

References rootFile_.

                                            {
     return rootFile_->readRunAuxiliary_();
   }

int edm::RootInputFileSequence::remainingEvents ( ) const

private

Definition at line 587 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 592 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 820 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 427 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 446 of file RootInputFileSequence.cc.

References rootFile_.

Referenced by rewind_().

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

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

Definition at line 452 of file RootInputFileSequence.cc.

References 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);
     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,
		bool	currentFileFirst = `true`
	)

Definition at line 541 of file RootInputFileSequence.cc.

References 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<boost::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.
           found = rootFile_->setEntryAtItem(run, lumi, event);
           assert(found);
           return true;
         }
       }
       // Look for item in files not yet opened.
       return skipToItemInNewFile(run, lumi, event);
     }
     return true;
   }

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

Definition at line 523 of file RootInputFileSequence.cc.

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

Referenced by readOneSequentialWithID(), and skipToItem().

                                                                                                                {
     // Look for item in files not yet opened.
     typedef std::vector<boost::shared_ptr<IndexIntoFile> >::const_iterator Iter;
     for(Iter it = indexesIntoFiles_.begin(), itEnd = indexesIntoFiles_.end(); it != itEnd; ++it) {
       if(!*it) {
         fileIter_ = fileIterBegin_ + (it - indexesIntoFiles_.begin());
         initFile(false);
         bool found = rootFile_->setEntryAtItem(run, lumi, event);
         if(found) {
           return true;
         }
       }
     }
     // Not found
     return false;
   }