#include <RootInputFileSequence.h>

Classes
struct	Config

Public Types
using	RootInputFileSharedPtr = std::shared_ptr< RootInputFile >

using	EntryNumber = input::EntryNumber

Public Member Functions
	RootInputFileSequence (RootInputFileSequence const &)=delete

RootInputFileSequence &	operator= (RootInputFileSequence const &)=delete

	RootInputFileSequence (fhicl::TableFragment< Config > const &, InputFileCatalog &, FastCloningInfoProvider const &, InputSource::ProcessingMode, UpdateOutputCallbacks &, ProcessConfiguration const &)

void	endJob ()

std::unique_ptr< FileBlock >	readFile_ ()

std::unique_ptr< RootInputFile >	openSecondaryFile (std::string const &name, cet::exempt_ptr< RootInputFile > primaryFile)

void	closeFile_ ()

void	skip (int offset)

void	rewind_ ()

EventID	seekToEvent (EventID const &, bool exact=false)

EventID	seekToEvent (off_t offset, bool exact=false)

input::ItemType	getNextItemType ()

void	readIt (RunID const &)

std::unique_ptr< RunPrincipal >	readRun_ ()

void	readIt (SubRunID const &)

std::unique_ptr< SubRunPrincipal >	readSubRun_ (cet::exempt_ptr< RunPrincipal const >)

void	readIt (EventID const &, bool exact=false)

std::unique_ptr< EventPrincipal >	readEvent_ ()

RootInputFileSharedPtr	rootFileForLastReadEvent () const

RootInputFileSharedPtr	rootFile () const

std::unique_ptr< RangeSetHandler >	runRangeSetHandler ()

std::unique_ptr< RangeSetHandler >	subRunRangeSetHandler ()

std::vector< std::vector< std::string > > const &	secondaryFileNames () const

EventID	origEventID () const

EventNumber_t	eventsToSkip () const

FastCloningInfoProvider const &	fastCloningInfo () const

unsigned int	treeCacheSize () const

int64_t	treeMaxVirtualSize () const

int64_t	saveMemoryObjectThreshold () const

bool	delayedReadEventProducts () const

bool	delayedReadSubRunProducts () const

bool	delayedReadRunProducts () const

InputSource::ProcessingMode const &	processingMode ()

void	finish ()

Private Member Functions
void	initFile (bool skipBadFiles)

bool	nextFile ()

bool	previousFile ()

void	rewindFile ()

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

ProcessConfiguration const &	processConfiguration () const

bool	primary () const

Private Attributes
InputFileCatalog &	catalog_

bool	firstFile_ {true}

bool	seekingFile_ {false}

RootInputFileSharedPtr	rootFile_ {nullptr}

std::vector< std::shared_ptr< FileIndex > >	fileIndexes_

EventID	origEventID_ {}

EventNumber_t	eventsToSkip_

bool const	compactSubRunRanges_

bool const	noEventSort_

bool const	skipBadFiles_

unsigned int const	treeCacheSize_

int64_t const	treeMaxVirtualSize_

int64_t const	saveMemoryObjectThreshold_

bool const	delayedReadEventProducts_

bool const	delayedReadSubRunProducts_

bool const	delayedReadRunProducts_

int	forcedRunOffset_ {}

RunNumber_t	setRun_ {}

GroupSelectorRules	groupSelectorRules_

std::shared_ptr< DuplicateChecker >	duplicateChecker_ {nullptr}

bool const	dropDescendants_

bool const	readParameterSets_

RootInputFileSharedPtr	rootFileForLastReadEvent_

FastCloningInfoProvider	fastCloningInfo_

InputSource::ProcessingMode	processingMode_

ProcessConfiguration const &	processConfiguration_

std::vector< std::vector< std::string > >	secondaryFileNames_ {}

UpdateOutputCallbacks &	outputCallbacks_

bool	pendingClose_ {false}

Detailed Description

Definition at line 36 of file RootInputFileSequence.h.

Member Typedef Documentation

using art::RootInputFileSequence::EntryNumber = input::EntryNumber

Definition at line 40 of file RootInputFileSequence.h.

using art::RootInputFileSequence::RootInputFileSharedPtr = std::shared_ptr<RootInputFile>

Definition at line 39 of file RootInputFileSequence.h.

Constructor & Destructor Documentation

art::RootInputFileSequence::RootInputFileSequence ( RootInputFileSequence const & )

delete

art::RootInputFileSequence::RootInputFileSequence	(	fhicl::TableFragment< Config > const &	config,
		InputFileCatalog &	catalog,
		FastCloningInfoProvider const &	fcip,
		InputSource::ProcessingMode	pMode,
		UpdateOutputCallbacks &	outputCallbacks,
		ProcessConfiguration const &	processConfig
	)

Definition at line 30 of file RootInputFileSequence.cc.

     : catalog_{catalog}
     , firstFile_{true}
     , seekingFile_{false}
     , fileIndexes_(fileCatalogItems().size())
     , eventsToSkip_{config().skipEvents()}
     , compactSubRunRanges_{config().compactSubRunRanges()}
     , noEventSort_{config().noEventSort()}
     , skipBadFiles_{config().skipBadFiles()}
     , treeCacheSize_{config().cacheSize()}
     , treeMaxVirtualSize_{config().treeMaxVirtualSize()}
     , saveMemoryObjectThreshold_{config().saveMemoryObjectThreshold()}
     , delayedReadEventProducts_{config().delayedReadEventProducts()}
     , delayedReadSubRunProducts_{config().delayedReadSubRunProducts()}
     , delayedReadRunProducts_{config().delayedReadRunProducts()}
     , groupSelectorRules_{config().inputCommands(),
                           "inputCommands",
                           "InputSource"}
     , dropDescendants_{config().dropDescendantsOfDroppedBranches()}
     , readParameterSets_{config().readParameterSets()}
     , fastCloningInfo_{fcip}
     , processingMode_{pMode}
     , processConfiguration_{processConfig}
     , outputCallbacks_{outputCallbacks}
   {
     auto const& primaryFileNames = catalog_.fileSources();
 
     map<string const, vector<string> const> secondaryFilesMap;
 
     std::vector<Config::SecondaryFile> secondaryFiles;
     if (config().secondaryFileNames(secondaryFiles)) {
       // Until we can find a way to atomically update the
       // 'selectedProducts' list for output modules, secondary input
       // files can be used only in single-threaded, single-schedule
       // execution.
       auto const& globals = *Globals::instance();
       if (globals.nthreads() != 1 && globals.nschedules() != 1) {
         throw Exception{
           errors::Configuration,
           "An error occurred while creating the RootInput source.\n"}
           << "This art process is using " << globals.nthreads()
           << " thread(s) and " << globals.nschedules() << " schedule(s).\n"
           << "Secondary file names can be used only when 1 thread and 1 "
              "schedule are specified.\n"
           << "This is done by specifying '-j=1' at the command line.\n";
       }
 
       for (auto const& val : secondaryFiles) {
         auto const a = val.a();
         auto const b = val.b();
         if (a.empty()) {
           throw art::Exception(errors::Configuration)
             << "Empty filename found as value of an \"a\" parameter!\n";
         }
         for (auto const& name : b) {
           if (name.empty()) {
             throw art::Exception(errors::Configuration)
               << "Empty secondary filename found as value of an \"b\" "
                  "parameter!\n";
           }
         }
         secondaryFilesMap.emplace(a, b);
       }
     }
 
     vector<pair<vector<string>::const_iterator, vector<string>::const_iterator>>
       stk;
     for (auto const& primaryFileName : primaryFileNames) {
       vector<string> secondaries;
       auto SFMI = secondaryFilesMap.find(primaryFileName);
       if (SFMI == secondaryFilesMap.end()) {
         // This primary has no secondaries.
         secondaryFileNames_.push_back(std::move(secondaries));
         continue;
       }
       if (!SFMI->second.size()) {
         // Has an empty secondary list.
         secondaryFileNames_.push_back(std::move(secondaries));
         continue;
       }
       stk.emplace_back(SFMI->second.cbegin(), SFMI->second.cend());
       while (stk.size()) {
         auto val = stk.back();
         stk.pop_back();
         if (val.first == val.second) {
           // Reached end of this filename list.
           continue;
         }
         auto const& fn = *val.first;
         ++val.first;
         secondaries.push_back(fn);
         auto SI = secondaryFilesMap.find(fn);
         if (SI == secondaryFilesMap.end()) {
           // Has no secondary list.
           if (val.first == val.second) {
             // Reached end of this filename list.
             continue;
           }
           stk.emplace_back(val.first, val.second);
           continue;
         }
         if (!SI->second.size()) {
           // Has an empty secondary list.
           if (val.first == val.second) {
             // Reached end of this filename list.
             continue;
           }
           stk.emplace_back(val.first, val.second);
           continue;
         }
         stk.emplace_back(val.first, val.second);
         stk.emplace_back(SI->second.cbegin(), SI->second.cend());
       }
       secondaryFileNames_.push_back(std::move(secondaries));
     }
     RunNumber_t firstRun{};
     bool const haveFirstRun{config().hasFirstRun(firstRun)};
     SubRunNumber_t firstSubRun{};
     bool const haveFirstSubRun{config().hasFirstSubRun(firstSubRun)};
     EventNumber_t firstEvent{};
     bool const haveFirstEvent{config().hasFirstEvent(firstEvent)};
 
     RunID const firstRunID{haveFirstRun ? RunID{firstRun} : RunID::firstRun()};
     SubRunID const firstSubRunID{haveFirstSubRun ?
                                    SubRunID{firstRunID.run(), firstSubRun} :
                                    SubRunID::firstSubRun(firstRunID)};
 
     origEventID_ = haveFirstEvent ? EventID{firstSubRunID, firstEvent} :
                                     EventID::firstEvent(firstSubRunID);
 
     if (noEventSort_ && haveFirstEvent) {
       throw art::Exception(errors::Configuration)
         << "Illegal configuration options passed to RootInput\n"
         << "You cannot request \"noEventSort\" and also set \"firstEvent\".\n";
     }
     if (primary()) {
       duplicateChecker_ = std::make_shared<DuplicateChecker>(config().dc);
     }
     if (pendingClose_) {
       throw Exception(errors::LogicError)
         << "RootInputFileSequence looking for next file with a pending close!";
     }
 
     while (catalog_.getNextFile()) {
       initFile(skipBadFiles_);
       if (rootFile_) {
         // We found one, good, stop now.
         break;
       }
     }
 
     if (!rootFile_) {
       // We could not open any input files, stop.
       return;
     }
     if (config().setRunNumber(setRun_)) {
       try {
         forcedRunOffset_ = rootFile_->setForcedRunOffset(setRun_);
       }
       catch (art::Exception& e) {
         if (e.categoryCode() == errors::InvalidNumber) {
           throw Exception(errors::Configuration)
             << "setRunNumber " << setRun_
             << " does not correspond to a valid run number in ["
             << RunID::firstRun().run() << ", " << RunID::maxRun().run()
             << "]\n";
         } else {
           throw; // Rethrow.
         }
       }
       if (forcedRunOffset_ < 0) {
         throw art::Exception(errors::Configuration)
           << "The value of the 'setRunNumber' parameter must not be\n"
           << "less than the first run number in the first input file.\n"
           << "'setRunNumber' was " << setRun_ << ", while the first run was "
           << setRun_ - forcedRunOffset_ << ".\n";
       }
     }
     if (!readParameterSets_) {
       mf::LogWarning("PROVENANCE")
         << "Source parameter readParameterSets was set to false: parameter set "
            "provenance\n"
         << "will NOT be available in this or subsequent jobs using output from "
            "this job.\n"
         << "Check your experiment's policy on this issue  to avoid future "
            "problems\n"
         << "with analysis reproducibility.\n";
     }
     if (compactSubRunRanges_) {
       mf::LogWarning("PROVENANCE")
         << "Source parameter compactEventRanges was set to true: enabling "
            "compact event ranges\n"
         << "creates a history that can cause file concatenation problems if a "
            "given SubRun spans\n"
         << "multiple input files.  Use with care.\n";
     }
   }

Member Function Documentation

void art::RootInputFileSequence::closeFile_ ( )

Definition at line 356 of file RootInputFileSequence.cc.

   {
     if (!rootFile_) {
       return;
     }
     // Account for events skipped in the file.
     eventsToSkip_ = rootFile_->eventsToSkip();
     rootFile_->close(primary());
     detail::logFileAction("Closed input file ", rootFile_->fileName());
     rootFile_.reset();
     if (duplicateChecker_.get() != nullptr) {
       duplicateChecker_->inputFileClosed();
     }
   }

bool art::RootInputFileSequence::delayedReadEventProducts ( ) const

inline

Definition at line 207 of file RootInputFileSequence.h.

     {
       return delayedReadEventProducts_;
     }

bool art::RootInputFileSequence::delayedReadRunProducts ( ) const

inline

Definition at line 219 of file RootInputFileSequence.h.

     {
       return delayedReadRunProducts_;
     }

bool art::RootInputFileSequence::delayedReadSubRunProducts ( ) const

inline

Definition at line 213 of file RootInputFileSequence.h.

     {
       return delayedReadSubRunProducts_;
     }

void art::RootInputFileSequence::endJob ( )

Definition at line 290 of file RootInputFileSequence.cc.

   {
     closeFile_();
   }

EventNumber_t art::RootInputFileSequence::eventsToSkip ( ) const

inline

Definition at line 177 of file RootInputFileSequence.h.

     {
       return eventsToSkip_;
     }

FastCloningInfoProvider const& art::RootInputFileSequence::fastCloningInfo ( ) const

inline

Definition at line 183 of file RootInputFileSequence.h.

     {
       return fastCloningInfo_;
     }

vector< FileCatalogItem > const & art::RootInputFileSequence::fileCatalogItems ( ) const

private

Definition at line 284 of file RootInputFileSequence.cc.

   {
     return catalog_.fileCatalogItems();
   }

void art::RootInputFileSequence::finish ( )

Definition at line 372 of file RootInputFileSequence.cc.

   {
     pendingClose_ = true;
   }

input::ItemType art::RootInputFileSequence::getNextItemType ( )

Definition at line 693 of file RootInputFileSequence.cc.

   {
     if (firstFile_) {
       return input::IsFile;
     }
     if (rootFile_) {
       auto const entryType = rootFile_->getNextEntryTypeWanted();
       if (entryType == FileIndex::kEvent) {
         return input::IsEvent;
       } else if (entryType == FileIndex::kSubRun) {
         return input::IsSubRun;
       } else if (entryType == FileIndex::kRun) {
         return input::IsRun;
       }
       assert(entryType == FileIndex::kEnd);
     }
     // now we are either at the end of a root file
     // or the current file is not a root file
     if (!catalog_.hasNextFile()) {
       return input::IsStop;
     }
     return input::IsFile;
   }

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

private

Definition at line 378 of file RootInputFileSequence.cc.

   {
     // close the currently open file, any, and delete the RootInputFile object.
     closeFile_();
     std::unique_ptr<TFile> filePtr;
     try {
       detail::logFileAction("Initiating request to open input file ",
                             catalog_.currentFile().fileName());
       filePtr.reset(TFile::Open(catalog_.currentFile().fileName().c_str()));
     }
     catch (cet::exception e) {
       if (!skipBadFiles) {
         throw art::Exception(art::errors::FileOpenError)
           << e.explain_self()
           << "\nRootInputFileSequence::initFile(): Input file "
           << catalog_.currentFile().fileName()
           << " was not found or could not be opened.\n";
       }
     }
     if (!filePtr || filePtr->IsZombie()) {
       if (!skipBadFiles) {
         throw art::Exception(art::errors::FileOpenError)
           << "RootInputFileSequence::initFile(): Input file "
           << catalog_.currentFile().fileName()
           << " was not found or could not be opened.\n";
       }
       mf::LogWarning("")
         << "Input file: " << catalog_.currentFile().fileName()
         << " was not found or could not be opened, and will be skipped.\n";
       return;
     }
     detail::logFileAction("Opened input file ",
                           catalog_.currentFile().fileName());
     vector<string> empty_vs;
     rootFile_ = make_shared<RootInputFile>(
       catalog_.currentFile().fileName(),
       catalog_.url(),
       processConfiguration(),
       catalog_.currentFile().logicalFileName(),
       std::move(filePtr),
       origEventID_,
       eventsToSkip_,
       compactSubRunRanges_,
       fastCloningInfo_,
       treeCacheSize_,
       treeMaxVirtualSize_,
       saveMemoryObjectThreshold_,
       delayedReadEventProducts_,
       delayedReadSubRunProducts_,
       delayedReadRunProducts_,
       processingMode_,
       forcedRunOffset_,
       noEventSort_,
       groupSelectorRules_,
       duplicateChecker_,
       dropDescendants_,
       readParameterSets_,
       /*primaryFile*/ exempt_ptr<RootInputFile>{nullptr},
       secondaryFileNames_.empty() ?
         empty_vs :
         secondaryFileNames_.at(catalog_.currentIndex()),
       this,
       outputCallbacks_);
 
     assert(catalog_.currentIndex() != InputFileCatalog::indexEnd);
     if (catalog_.currentIndex() + 1 > fileIndexes_.size()) {
       fileIndexes_.resize(catalog_.currentIndex() + 1);
     }
     fileIndexes_[catalog_.currentIndex()] = rootFile_->fileIndexSharedPtr();
   }

bool art::RootInputFileSequence::nextFile ( )

private

Definition at line 501 of file RootInputFileSequence.cc.

   {
     if (!catalog_.getNextFile()) {
       // no more files
       return false;
     }
     initFile(skipBadFiles_);
     return true;
   }

std::unique_ptr< RootInputFile > art::RootInputFileSequence::openSecondaryFile	(	std::string const &	name,
		cet::exempt_ptr< RootInputFile >	primaryFile
	)

Definition at line 450 of file RootInputFileSequence.cc.

   {
     std::unique_ptr<TFile> filePtr;
     try {
       detail::logFileAction("Attempting  to open secondary input file ", name);
       filePtr.reset(TFile::Open(name.c_str()));
     }
     catch (cet::exception e) {
       throw art::Exception(art::errors::FileOpenError)
         << e.explain_self()
         << "\nRootInputFileSequence::openSecondaryFile(): Input file " << name
         << " was not found or could not be opened.\n";
     }
     if (!filePtr || filePtr->IsZombie()) {
       throw art::Exception(art::errors::FileOpenError)
         << "RootInputFileSequence::openSecondaryFile(): Input file " << name
         << " was not found or could not be opened.\n";
     }
     detail::logFileAction("Opened secondary input file ", name);
     vector<string> empty_secondary_filenames;
     return std::make_unique<RootInputFile>(name,
                                            /*url*/ "",
                                            processConfiguration(),
                                            /*logicalFileName*/ "",
                                            std::move(filePtr),
                                            origEventID_,
                                            eventsToSkip_,
                                            compactSubRunRanges_,
                                            fastCloningInfo_,
                                            treeCacheSize_,
                                            treeMaxVirtualSize_,
                                            saveMemoryObjectThreshold_,
                                            delayedReadEventProducts_,
                                            delayedReadSubRunProducts_,
                                            delayedReadRunProducts_,
                                            processingMode_,
                                            forcedRunOffset_,
                                            noEventSort_,
                                            groupSelectorRules_,
                                            /*duplicateChecker_*/ nullptr,
                                            dropDescendants_,
                                            readParameterSets_,
                                            primaryFile,
                                            empty_secondary_filenames,
                                            this,
                                            outputCallbacks_);
   }

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

delete

EventID art::RootInputFileSequence::origEventID ( ) const

inline

Definition at line 171 of file RootInputFileSequence.h.

     {
       return origEventID_;
     }

bool art::RootInputFileSequence::previousFile ( )

private

Definition at line 512 of file RootInputFileSequence.cc.

   {
     // no going back for non-persistent files
     if (!catalog_.isSearchable()) {
       return false;
     }
     // no file in the catalog
     if (catalog_.currentIndex() == InputFileCatalog::indexEnd) {
       return false;
     }
     // first file in the catalog, move to the last file in the list
     if (catalog_.currentIndex() == 0) {
       return false;
     } else {
       catalog_.rewindTo(catalog_.currentIndex() - 1);
     }
     initFile(/*skipBadFiles=*/false);
     if (rootFile_) {
       rootFile_->setToLastEntry();
     }
     return true;
   }

bool art::RootInputFileSequence::primary ( ) const

private

Definition at line 757 of file RootInputFileSequence.cc.

   {
     return true;
   }

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

private

Definition at line 763 of file RootInputFileSequence.cc.

   {
     return processConfiguration_;
   }

InputSource::ProcessingMode const& art::RootInputFileSequence::processingMode ( )

inline

Definition at line 225 of file RootInputFileSequence.h.

     {
       return processingMode_;
     }

unique_ptr< EventPrincipal > art::RootInputFileSequence::readEvent_ ( )

Definition at line 575 of file RootInputFileSequence.cc.

   {
     // Create and setup the EventPrincipal.
     //
     //   1. create an EventPrincipal with a unique EventID
     //   2. For each entry in the provenance, put in one Group,
     //      holding the Provenance for the corresponding EDProduct.
     //   3. set up the caches in the EventPrincipal to know about this
     //      Group.
     //
     // We do *not* create the EDProduct instance (the equivalent of reading
     // the branch containing this EDProduct. That will be done by the
     // Delayed Reader when it is asked to do so.
     //
     rootFileForLastReadEvent_ = rootFile_;
     return rootFile_->readEvent();
   }

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

Definition at line 296 of file RootInputFileSequence.cc.

   {
     std::unique_ptr<FileBlock> result;
     if (firstFile_ && rootFile_) {
       firstFile_ = false;
       result = rootFile_->createFileBlock();
       return result;
     }
     if (firstFile_) {
       // We are at the first file in the sequence of files.
       firstFile_ = false;
       while (catalog_.getNextFile()) {
         initFile(skipBadFiles_);
         if (rootFile_) {
           // We found one, good, stop now.
           break;
         }
       }
       if (!rootFile_) {
         // We could not open any input files, stop.
         return result;
       }
       if (setRun_) {
         try {
           forcedRunOffset_ = rootFile_->setForcedRunOffset(setRun_);
         }
         catch (art::Exception& e) {
           if (e.categoryCode() == errors::InvalidNumber) {
             throw Exception(errors::Configuration)
               << "setRunNumber " << setRun_
               << " does not correspond to a valid run number in ["
               << RunID::firstRun().run() << ", " << RunID::maxRun().run()
               << "]\n";
           } else {
             throw; // Rethrow.
           }
         }
         if (forcedRunOffset_ < 0) {
           throw art::Exception(errors::Configuration)
             << "The value of the 'setRunNumber' parameter must not be\n"
             << "less than the first run number in the first input file.\n"
             << "'setRunNumber' was " << setRun_ << ", while the first run was "
             << setRun_ - forcedRunOffset_ << ".\n";
         }
       }
     } else if (seekingFile_) {
       seekingFile_ = false;
       initFile(/*skipBadFiles=*/false);
     } else if (!nextFile()) {
       // FIXME: Turn this into a throw!
       assert(false);
     }
     if (!rootFile_) {
       return result;
     }
     result = rootFile_->createFileBlock();
     return result;
   }

void art::RootInputFileSequence::readIt ( RunID const & id )

Definition at line 650 of file RootInputFileSequence.cc.

   {
     // Attempt to find run in current file.
     bool found = rootFile_->setEntry_Run(id);
     if (found) {
       // Got it, done.
       return;
     }
     if (!catalog_.isSearchable()) {
       // Cannot random access files, give up.
       return;
     }
     // Look for the run in the opened files.
     for (auto B = fileIndexes_.cbegin(), E = fileIndexes_.cend(), I = B; I != E;
          ++I) {
       if (*I && (*I)->contains(id, true)) {
         // We found it, open the file.
         catalog_.rewindTo(std::distance(B, I));
         initFile(/*skipBadFiles=*/false);
         found = rootFile_->setEntry_Run(id);
         assert(found);
         return;
       }
     }
     // Look for run in files not yet opened.
     while (catalog_.getNextFile()) {
       initFile(/*skipBadFiles=*/false);
       found = rootFile_->setEntry_Run(id);
       if (found) {
         return;
       }
     }
     // Not found.
     return;
   }

void art::RootInputFileSequence::readIt ( SubRunID const & id )

Definition at line 606 of file RootInputFileSequence.cc.

   {
     // Attempt to find subRun in currently open input file.
     bool found = rootFile_->setEntry_SubRun(id);
     if (found) {
       return;
     }
     if (!catalog_.isSearchable()) {
       return;
     }
     // Look for event in cached files
     for (auto itBegin = fileIndexes_.begin(),
               itEnd = fileIndexes_.end(),
               it = itBegin;
          it != itEnd;
          ++it) {
       if (*it && (*it)->contains(id, true)) {
         // We found it. Close the currently open file, and open the correct one.
         catalog_.rewindTo(std::distance(itBegin, it));
         initFile(/*skipBadFiles=*/false);
         found = rootFile_->setEntry_SubRun(id);
         assert(found);
         return;
       }
     }
     // Look for subRun in files not yet opened.
     while (catalog_.getNextFile()) {
       initFile(/*skipBadFiles=*/false);
       found = rootFile_->setEntry_SubRun(id);
       if (found) {
         return;
       }
     }
     // not found
     return;
   }

void art::RootInputFileSequence::readIt	(	EventID const &	id,
		bool	exact = `false`
	)

Definition at line 536 of file RootInputFileSequence.cc.

   {
     // Attempt to find event in currently open input file.
     bool found = rootFile_->setEntry_Event(id, exact);
     if (found) {
       rootFileForLastReadEvent_ = rootFile_;
       return;
     }
     if (!catalog_.isSearchable()) {
       return;
     }
     // Look for event in cached files
     for (auto IB = fileIndexes_.cbegin(), IE = fileIndexes_.cend(), I = IB;
          I != IE;
          ++I) {
       if (*I && (*I)->contains(id, exact)) {
         // We found it. Close the currently open file, and open the correct one.
         catalog_.rewindTo(std::distance(IB, I));
         initFile(/*skipBadFiles=*/false);
         found = rootFile_->setEntry_Event(id, exact);
         assert(found);
         rootFileForLastReadEvent_ = rootFile_;
         return;
       }
     }
     // Look for event in files not yet opened.
     while (catalog_.getNextFile()) {
       initFile(/*skipBadFiles=*/false);
       found = rootFile_->setEntry_Event(id, exact);
       if (found) {
         rootFileForLastReadEvent_ = rootFile_;
         return;
       }
     }
     // Not found
     return;
   }

std::unique_ptr< RunPrincipal > art::RootInputFileSequence::readRun_ ( )

Definition at line 687 of file RootInputFileSequence.cc.

   {
     return rootFile_->readRun();
   }

std::unique_ptr< SubRunPrincipal > art::RootInputFileSequence::readSubRun_ ( cet::exempt_ptr< RunPrincipal const > rp )

Definition at line 644 of file RootInputFileSequence.cc.

   {
     return rootFile_->readSubRun(rp);
   }

void art::RootInputFileSequence::rewind_ ( )

Definition at line 719 of file RootInputFileSequence.cc.

   {
     if (!catalog_.isSearchable()) {
       throw art::Exception(errors::FileOpenError)
         << "RootInputFileSequence::rewind_() "
         << "cannot rollback on non-searchable file catalogs.";
     }
     firstFile_ = true;
     catalog_.rewind();
     if (duplicateChecker_.get() != nullptr) {
       duplicateChecker_->rewind();
     }
   }

void art::RootInputFileSequence::rewindFile ( )

private

Definition at line 735 of file RootInputFileSequence.cc.

   {
     rootFile_->rewind();
   }

RootInputFileSharedPtr art::RootInputFileSequence::rootFile ( ) const

inline

Definition at line 156 of file RootInputFileSequence.h.

     {
       return rootFile_;
     }

RootInputFileSharedPtr art::RootInputFileSequence::rootFileForLastReadEvent ( ) const

inline

Definition at line 150 of file RootInputFileSequence.h.

     {
       return rootFileForLastReadEvent_;
     }

std::unique_ptr< RangeSetHandler > art::RootInputFileSequence::runRangeSetHandler ( )

Definition at line 594 of file RootInputFileSequence.cc.

   {
     return rootFile_->runRangeSetHandler();
   }

int64_t art::RootInputFileSequence::saveMemoryObjectThreshold ( ) const

inline

Definition at line 201 of file RootInputFileSequence.h.

     {
       return saveMemoryObjectThreshold_;
     };

std::vector<std::vector<std::string> > const& art::RootInputFileSequence::secondaryFileNames ( ) const

inline

Definition at line 165 of file RootInputFileSequence.h.

     {
       return secondaryFileNames_;
     }

EventID art::RootInputFileSequence::seekToEvent	(	EventID const &	eID,
		bool	exact = `false`
	)

Definition at line 235 of file RootInputFileSequence.cc.

   {
     // Attempt to find event in currently open input file.
     bool found = rootFile_->setEntry_Event(eID, true);
     // found in the current file
     if (found) {
       return rootFile_->eventIDForFileIndexPosition();
     }
     // fail if not searchable
     if (!catalog_.isSearchable()) {
       return EventID();
     }
     // Look for event in files previously opened without reopening unnecessary
     // files.
     for (auto itBegin = fileIndexes_.cbegin(),
               itEnd = fileIndexes_.cend(),
               it = itBegin;
          (!found) && it != itEnd;
          ++it) {
       if (*it && (*it)->contains(eID, exact)) {
         // We found it. Close the currently open file, and open the correct one.
         catalog_.rewindTo(std::distance(itBegin, it));
         initFile(/*skipBadFiles=*/false);
         // Now get the event from the correct file.
         found = rootFile_->setEntry_Event(eID, exact);
         assert(found);
         seekingFile_ = true;
       }
     }
     // Look for event in files not yet opened.
     while (catalog_.getNextFile()) {
       initFile(/*skipBadFiles=*/false);
       found = rootFile_->setEntry_Event(eID, exact);
       if (found) {
         seekingFile_ = true;
         return rootFile_->eventIDForFileIndexPosition();
       }
     }
     return EventID();
   }

EventID art::RootInputFileSequence::seekToEvent	(	off_t	offset,
		bool	exact = `false`
	)

Definition at line 277 of file RootInputFileSequence.cc.

   {
     skip(offset);
     return rootFile_->eventIDForFileIndexPosition();
   }

void art::RootInputFileSequence::skip ( int offset )

Definition at line 742 of file RootInputFileSequence.cc.

   {
     while (offset != 0) {
       offset = rootFile_->skipEvents(offset);
       if (offset > 0 && !nextFile()) {
         return;
       }
       if (offset < 0 && !previousFile()) {
         return;
       }
     }
     rootFile_->skipEvents(0);
   }

std::unique_ptr< RangeSetHandler > art::RootInputFileSequence::subRunRangeSetHandler ( )

Definition at line 600 of file RootInputFileSequence.cc.

   {
     return rootFile_->subRunRangeSetHandler();
   }

unsigned int art::RootInputFileSequence::treeCacheSize ( ) const

inline

Definition at line 189 of file RootInputFileSequence.h.

     {
       return treeCacheSize_;
     }

int64_t art::RootInputFileSequence::treeMaxVirtualSize ( ) const

inline

Definition at line 195 of file RootInputFileSequence.h.

     {
       return treeMaxVirtualSize_;
     }

Member Data Documentation

InputFileCatalog& art::RootInputFileSequence::catalog_

private

Definition at line 248 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::compactSubRunRanges_

private

Definition at line 255 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::delayedReadEventProducts_

private

Definition at line 261 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::delayedReadRunProducts_

private

Definition at line 263 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::delayedReadSubRunProducts_

private

Definition at line 262 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::dropDescendants_

private

Definition at line 268 of file RootInputFileSequence.h.

std::shared_ptr<DuplicateChecker> art::RootInputFileSequence::duplicateChecker_ {nullptr}

private

Definition at line 267 of file RootInputFileSequence.h.

EventNumber_t art::RootInputFileSequence::eventsToSkip_

private

Definition at line 254 of file RootInputFileSequence.h.

FastCloningInfoProvider art::RootInputFileSequence::fastCloningInfo_

private

Definition at line 271 of file RootInputFileSequence.h.

std::vector<std::shared_ptr<FileIndex> > art::RootInputFileSequence::fileIndexes_

private

Definition at line 252 of file RootInputFileSequence.h.

bool art::RootInputFileSequence::firstFile_ {true}

private

Definition at line 249 of file RootInputFileSequence.h.

int art::RootInputFileSequence::forcedRunOffset_ {}

private

Definition at line 264 of file RootInputFileSequence.h.

GroupSelectorRules art::RootInputFileSequence::groupSelectorRules_

private

Definition at line 266 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::noEventSort_

private

Definition at line 256 of file RootInputFileSequence.h.

EventID art::RootInputFileSequence::origEventID_ {}

private

Definition at line 253 of file RootInputFileSequence.h.

UpdateOutputCallbacks& art::RootInputFileSequence::outputCallbacks_

private

Definition at line 275 of file RootInputFileSequence.h.

bool art::RootInputFileSequence::pendingClose_ {false}

private

Definition at line 276 of file RootInputFileSequence.h.

ProcessConfiguration const& art::RootInputFileSequence::processConfiguration_

private

Definition at line 273 of file RootInputFileSequence.h.

InputSource::ProcessingMode art::RootInputFileSequence::processingMode_

private

Definition at line 272 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::readParameterSets_

private

Definition at line 269 of file RootInputFileSequence.h.

RootInputFileSharedPtr art::RootInputFileSequence::rootFile_ {nullptr}

private

Definition at line 251 of file RootInputFileSequence.h.

RootInputFileSharedPtr art::RootInputFileSequence::rootFileForLastReadEvent_

private

Definition at line 270 of file RootInputFileSequence.h.

int64_t const art::RootInputFileSequence::saveMemoryObjectThreshold_

private

Definition at line 260 of file RootInputFileSequence.h.

std::vector<std::vector<std::string> > art::RootInputFileSequence::secondaryFileNames_ {}

private

Definition at line 274 of file RootInputFileSequence.h.

bool art::RootInputFileSequence::seekingFile_ {false}

private

Definition at line 250 of file RootInputFileSequence.h.

RunNumber_t art::RootInputFileSequence::setRun_ {}

private

Definition at line 265 of file RootInputFileSequence.h.

bool const art::RootInputFileSequence::skipBadFiles_

private

Definition at line 257 of file RootInputFileSequence.h.

unsigned int const art::RootInputFileSequence::treeCacheSize_

private

Definition at line 258 of file RootInputFileSequence.h.

int64_t const art::RootInputFileSequence::treeMaxVirtualSize_

private

Definition at line 259 of file RootInputFileSequence.h.

The documentation for this class was generated from the following files:

art/art/Framework/IO/Root/RootInputFileSequence.h
art/art/Framework/IO/Root/RootInputFileSequence.cc

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation