#include "RootInputFile.h"

Public Types
using	RootInputTreePtrArray = std::array< std::unique_ptr< RootInputTree >, NumBranchTypes >

using	EntryNumber = RootInputTree::EntryNumber

using	EntryNumbers = RootInputTree::EntryNumbers

Public Member Functions
	RootInputFile (RootInputFile const &)=delete

RootInputFile &	operator= (RootInputFile const &)=delete

	RootInputFile (std::string const &fileName, std::string const &catalogName, ProcessConfiguration const &processConfiguration, std::string const &logicalFileName, std::unique_ptr< TFile > &&filePtr, EventID const &origEventID, unsigned int eventsToSkip, bool compactSubRunRanges, FastCloningInfoProvider const &fcip, unsigned int treeCacheSize, int64_t treeMaxVirtualSize, int64_t saveMemoryObjectThreashold, bool delayedReadEventProducts, bool delayedReadSubRunProducts, bool delayedReadRunProducts, InputSource::ProcessingMode processingMode, int forcedRunOffset, bool noEventSort, GroupSelectorRules const &groupSelectorRules, std::shared_ptr< DuplicateChecker > duplicateChecker, bool dropDescendantsOfDroppedProducts, bool readIncomingParameterSets, cet::exempt_ptr< RootInputFile > primaryFile, std::vector< std::string > const &secondaryFileNames, RootInputFileSequence *rifSequence, MasterProductRegistry &mpr)

void	reportOpened ()

void	close (bool reallyClose)

std::unique_ptr< ResultsPrincipal >	readResults ()

std::unique_ptr< RunPrincipal >	readRun ()

std::unique_ptr< SubRunPrincipal >	readSubRun (cet::exempt_ptr< RunPrincipal >)

std::unique_ptr< EventPrincipal >	readEvent ()

bool	readRunForSecondaryFile (RunID)

bool	readSubRunForSecondaryFile (SubRunID)

bool	readEventForSecondaryFile (EventID eID)

std::string const &	fileName () const

RunAuxiliary &	runAux ()

ResultsAuxiliary &	resultsAux ()

SubRunAuxiliary &	subRunAux ()

EventAuxiliary &	eventAux ()

FileFormatVersion	fileFormatVersion () const

bool	fastClonable () const

std::unique_ptr< FileBlock >	createFileBlock ()

template<BranchType BT>
void	setEntry (FileIndex::EntryNumber_t entry)

template<BranchType BT, typename ID >
bool	setEntry (ID const &id, bool exact=true)

void	rewind ()

void	setToLastEntry ()

void	nextEntry ()

void	previousEntry ()

void	advanceEntry (std::size_t n)

unsigned int	eventsToSkip () const

int	skipEvents (int offset)

int	setForcedRunOffset (RunNumber_t const &forcedRunNumber)

bool	nextEventEntry ()

FileIndex::EntryType	getEntryType () const

FileIndex::EntryType	getNextEntryTypeWanted ()

std::shared_ptr< FileIndex >	fileIndexSharedPtr () const

EventID	eventIDForFileIndexPosition () const

auto const &	secondaryFileNames () const

auto const &	secondaryFiles () const

void	openSecondaryFile (int const idx)

std::unique_ptr< RangeSetHandler >	runRangeSetHandler ()

std::unique_ptr< RangeSetHandler >	subRunRangeSetHandler ()

Private Member Functions
RootInputTree const &	eventTree () const

RootInputTree const &	subRunTree () const

RootInputTree const &	runTree () const

RootInputTree const &	resultsTree () const

RootInputTree &	eventTree ()

RootInputTree &	subRunTree ()

RootInputTree &	runTree ()

RootInputTree &	resultsTree ()

bool	setIfFastClonable (FastCloningInfoProvider const &fcip) const

void	validateFile ()

void	fillHistory ()

std::array< AvailableProducts_t, NumBranchTypes >	fillPerBranchTypePresenceFlags (ProductList const &)

template<BranchType BT>
void	fillAuxiliary (EntryNumber const entry)

template<BranchType BT>
std::unique_ptr< RangeSetHandler >	fillAuxiliary (EntryNumbers const &entries)

void	overrideRunNumber (RunID &id)

void	overrideRunNumber (SubRunID &id)

void	overrideRunNumber (EventID &id, bool isRealData)

void	dropOnInput (GroupSelectorRules const &rules, bool dropDescendants, ProductList &branchDescriptions)

void	readParentageTree (unsigned int treeCacheSize)

void	readEventHistoryTree (unsigned int treeCacheSize)

void	initializeDuplicateChecker ()

std::pair< EntryNumbers, bool >	getEntryNumbers (BranchType)

std::unique_ptr< RunPrincipal >	readCurrentRun (EntryNumbers const &)

std::unique_ptr< SubRunPrincipal >	readCurrentSubRun (EntryNumbers const &, cet::exempt_ptr< RunPrincipal >)

std::unique_ptr< EventPrincipal >	readCurrentEvent (std::pair< EntryNumbers, bool > const &)

Private Attributes
std::string const	fileName_

std::string const	catalog_

ProcessConfiguration const &	processConfiguration_

std::string const	logicalFileName_

std::unique_ptr< TFile >	filePtr_

cet::sqlite::Connection	sqliteDB_ {}

EventID	origEventID_

EventNumber_t	eventsToSkip_

bool const	compactSubRunRanges_

RootInputTreePtrArray	treePointers_

bool	delayedReadEventProducts_

bool	delayedReadSubRunProducts_

bool	delayedReadRunProducts_

InputSource::ProcessingMode	processingMode_

int	forcedRunOffset_

bool	noEventSort_

std::shared_ptr< DuplicateChecker >	duplicateChecker_

cet::exempt_ptr< RootInputFile >	primaryFile_

std::vector< std::string >	secondaryFileNames_

cet::exempt_ptr< RootInputFileSequence >	rifSequence_

FileFormatVersion	fileFormatVersion_ {}

std::shared_ptr< FileIndex >	fileIndexSharedPtr_ {new FileIndex}

FileIndex &	fileIndex_ {*fileIndexSharedPtr_}

FileIndex::const_iterator	fiBegin_ {fileIndex_.begin()}

FileIndex::const_iterator	fiEnd_ {fileIndex_.end()}

FileIndex::const_iterator	fiIter_ {fiBegin_}

bool	fastClonable_ {false}

std::tuple< EventAuxiliary, SubRunAuxiliary, RunAuxiliary, ResultsAuxiliary >	auxiliaries_ {}

ProductRegistry	productListHolder_ {}

ProductTables	presentProducts_ {ProductTables::invalid()}

std::unique_ptr< BranchIDLists >	branchIDLists_

TTree *	eventHistoryTree_ {nullptr}

std::shared_ptr< History >	history_ {std::make_shared<History>()}

std::vector< std::unique_ptr< RootInputFile > >	secondaryFiles_ {}

cet::exempt_ptr< EventPrincipal >	primaryEP_ {}

cet::exempt_ptr< RunPrincipal >	primaryRP_ {}

cet::exempt_ptr< SubRunPrincipal >	primarySRP_ {}

std::unique_ptr< RangeSetHandler >	subRunRangeSetHandler_ {nullptr}

std::unique_ptr< RangeSetHandler >	runRangeSetHandler_ {nullptr}

Detailed Description

Definition at line 49 of file RootInputFile.h.

Member Typedef Documentation

using art::RootInputFile::EntryNumber = RootInputTree::EntryNumber

Definition at line 54 of file RootInputFile.h.

using art::RootInputFile::EntryNumbers = RootInputTree::EntryNumbers

Definition at line 55 of file RootInputFile.h.

using art::RootInputFile::RootInputTreePtrArray = std::array<std::unique_ptr<RootInputTree>, NumBranchTypes>

Definition at line 53 of file RootInputFile.h.

Constructor & Destructor Documentation

art::RootInputFile::RootInputFile ( RootInputFile const & )

delete

art::RootInputFile::RootInputFile	(	std::string const &	fileName,
		std::string const &	catalogName,
		ProcessConfiguration const &	processConfiguration,
		std::string const &	logicalFileName,
		std::unique_ptr< TFile > &&	filePtr,
		EventID const &	origEventID,
		unsigned int	eventsToSkip,
		bool	compactSubRunRanges,
		FastCloningInfoProvider const &	fcip,
		unsigned int	treeCacheSize,
		int64_t	treeMaxVirtualSize,
		int64_t	saveMemoryObjectThreashold,
		bool	delayedReadEventProducts,
		bool	delayedReadSubRunProducts,
		bool	delayedReadRunProducts,
		InputSource::ProcessingMode	processingMode,
		int	forcedRunOffset,
		bool	noEventSort,
		GroupSelectorRules const &	groupSelectorRules,
		std::shared_ptr< DuplicateChecker >	duplicateChecker,
		bool	dropDescendantsOfDroppedProducts,
		bool	readIncomingParameterSets,
		cet::exempt_ptr< RootInputFile >	primaryFile,
		std::vector< std::string > const &	secondaryFileNames,
		RootInputFileSequence *	rifSequence,
		MasterProductRegistry &	mpr
	)

Member Function Documentation

void art::RootInputFile::advanceEntry ( std::size_t n )

inline

Definition at line 189 of file RootInputFile.h.

References nextEntry().

     {
       while (n-- != 0)
         nextEntry();
     }

void art::RootInputFile::close ( bool reallyClose )

Definition at line 557 of file RootInputFile.cc.

   {
     if (!reallyClose) {
       return;
     }
     filePtr_->Close();
     for (auto const& sf : secondaryFiles_) {
       if (!sf) {
         continue;
       }
       sf->filePtr_->Close();
     }
   }

std::unique_ptr< FileBlock > art::RootInputFile::createFileBlock ( )

Definition at line 446 of file RootInputFile.cc.

Referenced by fastClonable().

   {
     return std::make_unique<RootFileBlock>(
       fileFormatVersion_,
       fileName_,
       readResults(),
       cet::make_exempt_ptr(eventTree().tree()),
       fastClonable());
   }

void art::RootInputFile::dropOnInput	(	GroupSelectorRules const &	rules,
		bool	dropDescendants,
		ProductList &	branchDescriptions
	)

private

Definition at line 1025 of file RootInputFile.cc.

References art::BranchChildren::appendToDescendants(), art::checkDictionaries(), and E.

Referenced by fillAuxiliary().

   {
     // This is the selector for drop on input.
     GroupSelector const groupSelector{rules, prodList};
     // Do drop on input. On the first pass, just fill in a set of
     // branches to be dropped.  Use the BranchChildren class to
     // assemble list of children to drop.
     BranchChildren children;
     set<ProductID> branchesToDrop;
     for (auto const& prod : prodList) {
       auto const& pd = prod.second;
       if (!groupSelector.selected(pd)) {
         if (dropDescendants) {
           children.appendToDescendants(pd.productID(), branchesToDrop);
         } else {
           branchesToDrop.insert(pd.productID());
         }
       }
     }
     // On this pass, actually drop the branches.
     auto branchesToDropEnd = branchesToDrop.cend();
     for (auto I = prodList.begin(), E = prodList.end(); I != E;) {
       auto const& pd = I->second;
       bool drop = branchesToDrop.find(pd.productID()) != branchesToDropEnd;
       if (!drop) {
         ++I;
         checkDictionaries(pd);
         continue;
       }
       if (groupSelector.selected(pd)) {
         mf::LogWarning("RootInputFile")
           << "Branch '" << pd.branchName()
           << "' is being dropped from the input\n"
           << "of file '" << fileName_
           << "' because it is dependent on a branch\n"
           << "that was explicitly dropped.\n";
       }
       treePointers_[pd.branchType()]->dropBranch(pd.branchName());
       auto icopy = I++;
       prodList.erase(icopy);
     }
   }

EventAuxiliary& art::RootInputFile::eventAux ( )

inline

Definition at line 124 of file RootInputFile.h.

References auxiliaries_.

     {
       return std::get<EventAuxiliary>(auxiliaries_);
     }

EventID art::RootInputFile::eventIDForFileIndexPosition ( ) const

Definition at line 377 of file RootInputFile.cc.

Referenced by fileIndexSharedPtr().

   {
     if (fiIter_ == fiEnd_) {
       return EventID{};
     }
     return fiIter_->eventID_;
   }

unsigned int art::RootInputFile::eventsToSkip ( ) const

inline

Definition at line 196 of file RootInputFile.h.

References eventsToSkip_, setForcedRunOffset(), and skipEvents().

     {
       return eventsToSkip_;
     }

RootInputTree const& art::RootInputFile::eventTree ( ) const

inlineprivate

Definition at line 239 of file RootInputFile.h.

References art::InEvent, and treePointers_.

Referenced by nextEventEntry(), and rewind().

     {
       return *treePointers_[InEvent];
     }

RootInputTree& art::RootInputFile::eventTree ( )

inlineprivate

Definition at line 261 of file RootInputFile.h.

References art::InEvent, and treePointers_.

     {
       return *treePointers_[InEvent];
     }

bool art::RootInputFile::fastClonable ( ) const

inline

Definition at line 136 of file RootInputFile.h.

References createFileBlock(), and fastClonable_.

     {
       return fastClonable_;
     }

FileFormatVersion art::RootInputFile::fileFormatVersion ( ) const

inline

Definition at line 130 of file RootInputFile.h.

References fileFormatVersion_.

     {
       return fileFormatVersion_;
     }

std::shared_ptr<FileIndex> art::RootInputFile::fileIndexSharedPtr ( ) const

inline

Definition at line 213 of file RootInputFile.h.

References eventIDForFileIndexPosition(), and fileIndexSharedPtr_.

     {
       return fileIndexSharedPtr_;
     }

std::string const& art::RootInputFile::fileName ( ) const

inline

Definition at line 103 of file RootInputFile.h.

References fileName_.

     {
       return fileName_;
     }

template<BranchType BT>

void art::RootInputFile::fillAuxiliary ( EntryNumber const entry )

inlineprivate

Definition at line 291 of file RootInputFile.h.

References auxiliaries_, and treePointers_.

     {
       using AUX = std::tuple_element_t<BT, decltype(auxiliaries_)>;
       auto& aux = std::get<BT>(auxiliaries_);
       aux = treePointers_[BT]->getAux<AUX>(entry);
     }

template<BranchType BT>

std::unique_ptr<RangeSetHandler> art::RootInputFile::fillAuxiliary ( EntryNumbers const & entries )

inlineprivate

Definition at line 300 of file RootInputFile.h.

References auxiliaries_, dropOnInput(), fileFormatVersion_, fileIndex_, fileName_, getEntryNumbers(), initializeDuplicateChecker(), overrideRunNumber(), readCurrentEvent(), readCurrentRun(), readCurrentSubRun(), readEventHistoryTree(), readParentageTree(), sqliteDB_, and treePointers_.

     {
       using AUX = std::tuple_element_t<BT, decltype(auxiliaries_)>;
       auto& aux = std::get<BT>(auxiliaries_);
       return treePointers_[BT]->fillAux<AUX>(
         fileFormatVersion_, entries, fileIndex_, sqliteDB_, fileName_, aux);
     }

void art::RootInputFile::fillHistory ( )

private

Definition at line 572 of file RootInputFile.cc.

References art::errors::DataCorruption, art::rootNames::eventHistoryBranchName(), and art::input::getEntry().

Referenced by resultsTree().

   {
     // We could consider doing delayed reading, but because we have to
     // store this History object in a different tree than the event
     // data tree, this is too hard to do in this first version.
     auto pHistory = history_.get();
     auto eventHistoryBranch =
       eventHistoryTree_->GetBranch(rootNames::eventHistoryBranchName().c_str());
     if (!eventHistoryBranch) {
       throw art::Exception{errors::DataCorruption}
         << "Failed to find history branch in event history tree.\n";
     }
     eventHistoryBranch->SetAddress(&pHistory);
     input::getEntry(eventHistoryTree_, eventTree().entryNumber());
   }

std::array< AvailableProducts_t, NumBranchTypes > art::RootInputFile::fillPerBranchTypePresenceFlags ( ProductList const & prodList )

private

Definition at line 1012 of file RootInputFile.cc.

Referenced by resultsTree().

   {
     std::array<AvailableProducts_t, NumBranchTypes> result{{}};
     for (auto const& prodpr : prodList) {
       auto const& desc = prodpr.second;
       if (treePointers_[desc.branchType()]->hasBranch(desc.branchName())) {
         result[desc.branchType()].emplace(desc.productID());
       }
     }
     return result;
   }

std::pair< RootInputFile::EntryNumbers, bool > art::RootInputFile::getEntryNumbers ( BranchType t )

private

Definition at line 988 of file RootInputFile.cc.

References art::errors::FileReadError, and art::InEvent.

Referenced by fillAuxiliary().

   {
     EntryNumbers entries;
     auto it = fiIter_;
     if (it == fiEnd_)
       return std::pair<EntryNumbers, bool>{entries, true};
 
     auto const eid = it->eventID_;
     auto const subrun = eid.subRun();
     for (; it != fiEnd_ && eid == it->eventID_; ++it) {
       entries.push_back(it->entry_);
     }
 
     if (t == InEvent && entries.size() > 1ul) {
       throw Exception{errors::FileReadError} << "File " << fileName_
                                              << " has multiple entries for\n"
                                              << eid << '\n';
     }
 
     bool const lastInSubRun{it == fiEnd_ || it->eventID_.subRun() != subrun};
     return std::pair<EntryNumbers, bool>{entries, lastInSubRun};
   }

FileIndex::EntryType art::RootInputFile::getEntryType ( ) const

Definition at line 457 of file RootInputFile.cc.

References art::FileIndex::kEnd.

Referenced by nextEventEntry().

   {
     if (fiIter_ == fiEnd_) {
       return FileIndex::kEnd;
     }
     return fiIter_->getEntryType();
   }

FileIndex::EntryType art::RootInputFile::getNextEntryTypeWanted ( )

Definition at line 466 of file RootInputFile.cc.

References art::FileIndex::kEnd, art::FileIndex::kEvent, art::FileIndex::kRun, art::FileIndex::kSubRun, art::SubRunID::next(), art::DecrepitRelicInputSourceImplementation::processingMode_, art::InputSource::Runs, and art::InputSource::RunsAndSubRuns.

Referenced by nextEventEntry().

   {
     auto entryType = getEntryType();
     if (entryType == FileIndex::kEnd) {
       return FileIndex::kEnd;
     }
     RunID currentRun(fiIter_->eventID_.runID());
     if (!currentRun.isValid()) {
       return FileIndex::kEnd;
     }
     if (entryType == FileIndex::kRun) {
       // Skip any runs before the first run specified
       if (currentRun < origEventID_.runID()) {
         fiIter_ = fileIndex_.findPosition(origEventID_.runID(), false);
         return getNextEntryTypeWanted();
       }
       return FileIndex::kRun;
     }
     if (processingMode_ == InputSource::Runs) {
       fiIter_ = fileIndex_.findPosition(
         currentRun.isValid() ? currentRun.next() : currentRun, false);
       return getNextEntryTypeWanted();
     }
     SubRunID const& currentSubRun = fiIter_->eventID_.subRunID();
     if (entryType == FileIndex::kSubRun) {
       // Skip any subRuns before the first subRun specified
       if ((currentRun == origEventID_.runID()) &&
           (currentSubRun < origEventID_.subRunID())) {
         fiIter_ = fileIndex_.findSubRunOrRunPosition(origEventID_.subRunID());
         return getNextEntryTypeWanted();
       }
       return FileIndex::kSubRun;
     }
     if (processingMode_ == InputSource::RunsAndSubRuns) {
       fiIter_ = fileIndex_.findSubRunOrRunPosition(currentSubRun.next());
       return getNextEntryTypeWanted();
     }
     assert(entryType == FileIndex::kEvent);
     // Skip any events before the first event specified
     if (fiIter_->eventID_ < origEventID_) {
       fiIter_ = fileIndex_.findPosition(origEventID_);
       return getNextEntryTypeWanted();
     }
     if (duplicateChecker_.get() && duplicateChecker_->isDuplicateAndCheckActive(
                                      fiIter_->eventID_, fileName_)) {
       nextEntry();
       return getNextEntryTypeWanted();
     }
     if (eventsToSkip_ == 0) {
       return FileIndex::kEvent;
     }
     // We have specified a count of events to skip, keep skipping
     // events in this subRun block until we reach the end of the
     // subRun block or the full count of the number of events to skip.
     while ((eventsToSkip_ != 0) && (fiIter_ != fiEnd_) &&
            (getEntryType() == FileIndex::kEvent)) {
       nextEntry();
       --eventsToSkip_;
       while ((eventsToSkip_ != 0) && (fiIter_ != fiEnd_) &&
              (fiIter_->getEntryType() == FileIndex::kEvent) &&
              duplicateChecker_.get() &&
              duplicateChecker_->isDuplicateAndCheckActive(fiIter_->eventID_,
                                                           fileName_)) {
         nextEntry();
       }
     }
     return getNextEntryTypeWanted();
   }

void art::RootInputFile::initializeDuplicateChecker ( )

private

Definition at line 975 of file RootInputFile.cc.

Referenced by fillAuxiliary().

   {
     if (duplicateChecker_.get() == nullptr) {
       return;
     }
     if (eventTree().next()) {
       fillAuxiliary<InEvent>(eventTree().entryNumber());
       duplicateChecker_->init(eventAux().isRealData(), fileIndex_);
     }
     eventTree().setEntryNumber(-1);
   }

void art::RootInputFile::nextEntry ( )

inline

Definition at line 179 of file RootInputFile.h.

References fiIter_.

Referenced by advanceEntry().

     {
       ++fiIter_;
     }

bool art::RootInputFile::nextEventEntry ( )

inline

Definition at line 204 of file RootInputFile.h.

References eventTree(), getEntryType(), getNextEntryTypeWanted(), and art::RootInputTree::next().

     {
       return eventTree().next();
     }

void art::RootInputFile::openSecondaryFile ( int const idx )

Definition at line 1071 of file RootInputFile.cc.

Referenced by secondaryFiles().

   {
     secondaryFiles_[idx] =
       rifSequence_->openSecondaryFile(secondaryFileNames_[idx], this);
   }

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

delete

void art::RootInputFile::overrideRunNumber ( RunID & id )

private

Definition at line 928 of file RootInputFile.cc.

References art::RunID::firstRun().

Referenced by fillAuxiliary().

   {
     if (forcedRunOffset_ != 0) {
       id = RunID(id.run() + forcedRunOffset_);
     }
     if (id < RunID::firstRun()) {
       id = RunID::firstRun();
     }
   }

void art::RootInputFile::overrideRunNumber ( SubRunID & id )

private

Definition at line 939 of file RootInputFile.cc.

   {
     if (forcedRunOffset_ != 0) {
       id = SubRunID(id.run() + forcedRunOffset_, id.subRun());
     }
   }

void art::RootInputFile::overrideRunNumber	(	EventID &	id,
		bool	isRealData
	)

private

Definition at line 947 of file RootInputFile.cc.

References art::errors::Configuration.

   {
     if (forcedRunOffset_ == 0) {
       return;
     }
     if (isRealData) {
       throw art::Exception{errors::Configuration,
                            "RootInputFile::overrideRunNumber()"}
         << "The 'setRunNumber' parameter of RootInput cannot "
         << "be used with real data.\n";
     }
     id = EventID(id.run() + forcedRunOffset_, id.subRun(), id.event());
   }

void art::RootInputFile::previousEntry ( )

inline

Definition at line 184 of file RootInputFile.h.

References fiIter_.

     {
       --fiIter_;
     }

unique_ptr< EventPrincipal > art::RootInputFile::readCurrentEvent ( std::pair< EntryNumbers, bool > const & entryNumbers )

private

Definition at line 647 of file RootInputFile.cc.

References art::InEvent.

Referenced by fillAuxiliary().

   {
     assert(entryNumbers.first.size() == 1ull);
     fillAuxiliary<InEvent>(entryNumbers.first.front());
     assert(eventAux().id() == fiIter_->eventID_);
     fillHistory();
     overrideRunNumber(const_cast<EventID&>(eventAux().id()),
                       eventAux().isRealData());
     auto ep = std::make_unique<EventPrincipal>(
       eventAux(),
       processConfiguration_,
       &presentProducts_.get(InEvent),
       history_,
       eventTree().makeBranchMapper(),
       eventTree().makeDelayedReader(
         fileFormatVersion_,
         branchIDLists_.get(), // Only for backwards compatibility
         InEvent,
         entryNumbers.first,
         eventAux().id()),
       entryNumbers.second);
     eventTree().fillGroups(*ep);
     if (!delayedReadEventProducts_) {
       ep->readImmediate();
     }
     primaryEP_ = make_exempt_ptr(ep.get());
     return ep;
   }

unique_ptr< RunPrincipal > art::RootInputFile::readCurrentRun ( EntryNumbers const & entryNumbers )

private

Definition at line 736 of file RootInputFile.cc.

References art::InRun, and art::Timestamp::invalidTimestamp().

Referenced by fillAuxiliary().

   {
     runRangeSetHandler_ = fillAuxiliary<InRun>(entryNumbers);
     assert(runAux().id() == fiIter_->eventID_.runID());
     overrideRunNumber(runAux().id_);
     if (runAux().beginTime() == Timestamp::invalidTimestamp()) {
       // RunAuxiliary did not contain a valid timestamp.
       // Take it from the next event.
       if (eventTree().next()) {
         fillAuxiliary<InEvent>(eventTree().entryNumber());
         // back up, so event will not be skipped.
         eventTree().previous();
       }
       runAux().beginTime_ = eventAux().time();
       runAux().endTime_ = Timestamp::invalidTimestamp();
     }
     auto rp = std::make_unique<RunPrincipal>(
       runAux(),
       processConfiguration_,
       &presentProducts_.get(InRun),
       runTree().makeBranchMapper(),
       runTree().makeDelayedReader(fileFormatVersion_,
                                   sqliteDB_,
                                   nullptr,
                                   InRun,
                                   entryNumbers,
                                   fiIter_->eventID_));
     runTree().fillGroups(*rp);
     if (!delayedReadRunProducts_) {
       rp->readImmediate();
     }
     primaryRP_ = make_exempt_ptr(rp.get());
     return rp;
   }

unique_ptr< SubRunPrincipal > art::RootInputFile::readCurrentSubRun	(	EntryNumbers const &	,
		cet::exempt_ptr< RunPrincipal >
	)

private

Definition at line 842 of file RootInputFile.cc.

References art::InSubRun, and art::Timestamp::invalidTimestamp().

Referenced by fillAuxiliary().

   {
     subRunRangeSetHandler_ = fillAuxiliary<InSubRun>(entryNumbers);
     assert(subRunAux().id() == fiIter_->eventID_.subRunID());
     overrideRunNumber(subRunAux().id_);
     assert(subRunAux().runID() == rp->id());
     if (subRunAux().beginTime() == Timestamp::invalidTimestamp()) {
       // SubRunAuxiliary did not contain a timestamp.
       // Take it from the next event.
       if (eventTree().next()) {
         fillAuxiliary<InEvent>(eventTree().entryNumber());
         // back up, so event will not be skipped.
         eventTree().previous();
       }
       subRunAux().beginTime_ = eventAux().time();
       subRunAux().endTime_ = Timestamp::invalidTimestamp();
     }
 
     auto srp = std::make_unique<SubRunPrincipal>(
       subRunAux(),
       processConfiguration_,
       &presentProducts_.get(InSubRun),
       subRunTree().makeBranchMapper(),
       subRunTree().makeDelayedReader(fileFormatVersion_,
                                      sqliteDB_,
                                      nullptr,
                                      InSubRun,
                                      entryNumbers,
                                      fiIter_->eventID_));
     subRunTree().fillGroups(*srp);
     if (!delayedReadSubRunProducts_) {
       srp->readImmediate();
     }
     primarySRP_ = make_exempt_ptr(srp.get());
     return srp;
   }

unique_ptr< EventPrincipal > art::RootInputFile::readEvent ( )

Definition at line 624 of file RootInputFile.cc.

References art::InEvent, and art::FileIndex::kEvent.

   {
     assert(fiIter_ != fiEnd_);
     assert(fiIter_->getEntryType() == FileIndex::kEvent);
     assert(fiIter_->eventID_.runID().isValid());
 
     auto const& entryNumbers = getEntryNumbers(InEvent);
     if (!eventTree().current(entryNumbers.first)) {
       // The supplied entry numbers are not valid.
       return nullptr;
     }
 
     auto ep = readCurrentEvent(entryNumbers);
     assert(ep);
     assert(eventAux().run() == fiIter_->eventID_.run() + forcedRunOffset_);
     assert(eventAux().subRunID() == fiIter_->eventID_.subRunID());
     nextEntry();
     return ep;
   }

bool art::RootInputFile::readEventForSecondaryFile ( EventID eID )

Definition at line 678 of file RootInputFile.cc.

References art::InEvent.

   {
     // Used just after opening a new secondary file in response to a failed
     // product lookup.  Synchronize the file index to the event needed and
     // create a secondary EventPrincipal for it.
     if (!setEntry<InEvent>(eID, /*exact=*/true)) {
       // Error, could not find specified event in file.
       return false;
     }
     auto const& entryNumbers = getEntryNumbers(InEvent);
     assert(entryNumbers.first.size() == 1ull);
     fillAuxiliary<InEvent>(entryNumbers.first.front());
     fillHistory();
     overrideRunNumber(const_cast<EventID&>(eventAux().id()),
                       eventAux().isRealData());
     auto ep = std::make_unique<EventPrincipal>(
       eventAux(),
       processConfiguration_,
       &presentProducts_.get(InEvent),
       history_,
       eventTree().makeBranchMapper(),
       eventTree().makeDelayedReader(
         fileFormatVersion_,
         branchIDLists_.get(), // Only for backwards compatibility
         InEvent,
         entryNumbers.first,
         eventAux().id()),
       entryNumbers.second);
     eventTree().fillGroups(*ep);
     primaryFile_->primaryEP_->addSecondaryPrincipal(move(ep));
     return true;
   }

void art::RootInputFile::readEventHistoryTree ( unsigned int treeCacheSize )

private

Definition at line 962 of file RootInputFile.cc.

References art::errors::DataCorruption, and art::rootNames::eventHistoryTreeName().

Referenced by fillAuxiliary().

   {
     // Read in the event history tree, if we have one...
     eventHistoryTree_ = static_cast<TTree*>(
       filePtr_->Get(rootNames::eventHistoryTreeName().c_str()));
     if (!eventHistoryTree_) {
       throw art::Exception{errors::DataCorruption}
         << "Failed to find the event history tree.\n";
     }
     eventHistoryTree_->SetCacheSize(static_cast<Long64_t>(treeCacheSize));
   }

void art::RootInputFile::readParentageTree ( unsigned int treeCacheSize )

private

Definition at line 336 of file RootInputFile.cc.

References art::couldNotFindTree(), art::errors::DataCorruption, art::thread_safe_registry_via_id< K, M >::emplace(), art::errors::FileReadError, art::input::getEntry(), art::rootNames::parentageBranchName(), art::rootNames::parentageIDBranchName(), and art::rootNames::parentageTreeName().

Referenced by fillAuxiliary().

   {
     //
     //  Auxiliary routine for the constructor.
     //
     auto parentageTree = static_cast<TTree*>(
       filePtr_->Get(rootNames::parentageTreeName().c_str()));
     if (!parentageTree) {
       throw art::Exception{errors::FileReadError}
         << couldNotFindTree(rootNames::parentageTreeName());
     }
     parentageTree->SetCacheSize(static_cast<Long64_t>(treeCacheSize));
     auto idBuffer = root::getObjectRequireDict<ParentageID>();
     auto pidBuffer = &idBuffer;
     parentageTree->SetBranchAddress(rootNames::parentageIDBranchName().c_str(),
                                     &pidBuffer);
 
     auto parentageBuffer = root::getObjectRequireDict<Parentage>();
     auto pParentageBuffer = &parentageBuffer;
     parentageTree->SetBranchAddress(rootNames::parentageBranchName().c_str(),
                                     &pParentageBuffer);
 
     // Fill the registry
     for (EntryNumber i = 0, numEntries = parentageTree->GetEntries();
          i < numEntries;
          ++i) {
       input::getEntry(parentageTree, i);
       if (idBuffer != parentageBuffer.id()) {
         throw art::Exception{errors::DataCorruption}
           << "Corruption of Parentage tree detected.\n";
       }
       ParentageRegistry::emplace(parentageBuffer.id(), parentageBuffer);
     }
 
     parentageTree->SetBranchAddress(rootNames::parentageIDBranchName().c_str(),
                                     nullptr);
     parentageTree->SetBranchAddress(rootNames::parentageBranchName().c_str(),
                                     nullptr);
   }

std::unique_ptr< art::ResultsPrincipal > art::RootInputFile::readResults ( )

Definition at line 1078 of file RootInputFile.cc.

References art::InResults.

   {
     std::unique_ptr<art::ResultsPrincipal> resp;
     if (resultsTree()) {
       resultsTree().rewind();
       EntryNumbers const& entryNumbers{resultsTree().entryNumber()};
       assert(entryNumbers.size() == 1ull);
       fillAuxiliary<InResults>(entryNumbers.front());
       resp = std::make_unique<ResultsPrincipal>(
         resultsAux(),
         processConfiguration_,
         &presentProducts_.get(InResults),
         resultsTree().makeBranchMapper(),
         resultsTree().makeDelayedReader(
           fileFormatVersion_, nullptr, InResults, entryNumbers, EventID{}));
       resultsTree().fillGroups(*resp);
     } else { // Empty
       resp = std::make_unique<ResultsPrincipal>(
         ResultsAuxiliary{}, processConfiguration_, nullptr);
     }
     return resp;
   }

unique_ptr< RunPrincipal > art::RootInputFile::readRun ( )

Definition at line 718 of file RootInputFile.cc.

References art::InRun, and art::FileIndex::kRun.

   {
     assert(fiIter_ != fiEnd_);
     assert(fiIter_->getEntryType() == FileIndex::kRun);
     assert(fiIter_->eventID_.runID().isValid());
 
     auto const& entryNumbers = getEntryNumbers(InRun).first;
     if (!runTree().current(entryNumbers)) {
       // The supplied entry numbers are not valid.
       return nullptr;
     }
 
     auto rp = readCurrentRun(entryNumbers);
     advanceEntry(entryNumbers.size());
     return rp;
   }

bool art::RootInputFile::readRunForSecondaryFile ( RunID rID )

Definition at line 772 of file RootInputFile.cc.

References art::InRun, art::Timestamp::invalidTimestamp(), and art::FileIndex::kRun.

   {
     // Used just after opening a new secondary file in response to a failed
     // product lookup.  Synchronize the file index to the run needed and
     // create a secondary RunPrincipal for it.
     if (!setEntry<InRun>(rID)) {
       // Error, could not find specified run in file.
       return false;
     }
     auto const& entryNumbers = getEntryNumbers(InRun).first;
     assert(fiIter_ != fiEnd_);
     assert(fiIter_->getEntryType() == FileIndex::kRun);
     assert(fiIter_->eventID_.runID().isValid());
     runRangeSetHandler_ = fillAuxiliary<InRun>(entryNumbers);
     assert(runAux().id() == fiIter_->eventID_.runID());
     overrideRunNumber(runAux().id_);
     if (runAux().beginTime() == Timestamp::invalidTimestamp()) {
       // RunAuxiliary did not contain a valid timestamp.
       // Take it from the next event.
       if (eventTree().next()) {
         fillAuxiliary<InEvent>(eventTree().entryNumber());
         // back up, so event will not be skipped.
         eventTree().previous();
       }
       runAux().beginTime_ = eventAux().time();
       runAux().endTime_ = Timestamp::invalidTimestamp();
     }
     auto rp = std::make_unique<RunPrincipal>(
       runAux(),
       processConfiguration_,
       &presentProducts_.get(InRun),
       runTree().makeBranchMapper(),
       runTree().makeDelayedReader(fileFormatVersion_,
                                   sqliteDB_,
                                   nullptr,
                                   InRun,
                                   entryNumbers,
                                   fiIter_->eventID_));
     runTree().fillGroups(*rp);
     if (!delayedReadRunProducts_) {
       rp->readImmediate();
     }
     primaryFile_->primaryRP_->addSecondaryPrincipal(move(rp));
     return true;
   }

unique_ptr< SubRunPrincipal > art::RootInputFile::readSubRun ( cet::exempt_ptr< RunPrincipal > rp )

Definition at line 825 of file RootInputFile.cc.

References art::InSubRun, and art::FileIndex::kSubRun.

   {
     assert(fiIter_ != fiEnd_);
     assert(fiIter_->getEntryType() == FileIndex::kSubRun);
 
     auto const& entryNumbers = getEntryNumbers(InSubRun).first;
     if (!subRunTree().current(entryNumbers)) {
       // The supplied entry numbers are not valid.
       return nullptr;
     }
 
     auto srp = readCurrentSubRun(entryNumbers, rp);
     advanceEntry(entryNumbers.size());
     return srp;
   }

bool art::RootInputFile::readSubRunForSecondaryFile ( SubRunID srID )

Definition at line 882 of file RootInputFile.cc.

References art::InSubRun, art::Timestamp::invalidTimestamp(), and art::FileIndex::kSubRun.

   {
     // Used just after opening a new secondary file in response to a failed
     // product lookup.  Synchronize the file index to the subRun needed and
     // create a secondary SubRunPrincipal for it.
     if (!setEntry<InSubRun>(srID)) {
       // Error, could not find specified subRun in file.
       return false;
     }
     auto const& entryNumbers = getEntryNumbers(InSubRun).first;
     assert(fiIter_ != fiEnd_);
     assert(fiIter_->getEntryType() == FileIndex::kSubRun);
     subRunRangeSetHandler_ = fillAuxiliary<InSubRun>(entryNumbers);
     assert(subRunAux().id() == fiIter_->eventID_.subRunID());
     overrideRunNumber(subRunAux().id_);
     if (subRunAux().beginTime() == Timestamp::invalidTimestamp()) {
       // SubRunAuxiliary did not contain a timestamp.
       // Take it from the next event.
       if (eventTree().next()) {
         fillAuxiliary<InEvent>(eventTree().entryNumber());
         // back up, so event will not be skipped.
         eventTree().previous();
       }
       subRunAux().beginTime_ = eventAux().time();
       subRunAux().endTime_ = Timestamp::invalidTimestamp();
     }
     auto srp = std::make_unique<SubRunPrincipal>(
       subRunAux(),
       processConfiguration_,
       &presentProducts_.get(InSubRun),
       subRunTree().makeBranchMapper(),
       subRunTree().makeDelayedReader(fileFormatVersion_,
                                      sqliteDB_,
                                      nullptr,
                                      InSubRun,
                                      entryNumbers,
                                      fiIter_->eventID_));
     subRunTree().fillGroups(*srp);
     if (!delayedReadSubRunProducts_) {
       srp->readImmediate();
     }
     primaryFile_->primarySRP_->addSecondaryPrincipal(move(srp));
     return true;
   }

void art::RootInputFile::reportOpened ( )

Definition at line 553 of file RootInputFile.cc.

554 {}

ResultsAuxiliary& art::RootInputFile::resultsAux ( )

inline

Definition at line 114 of file RootInputFile.h.

References auxiliaries_.

     {
       return std::get<ResultsAuxiliary>(auxiliaries_);
     }

RootInputTree const& art::RootInputFile::resultsTree ( ) const

inlineprivate

Definition at line 254 of file RootInputFile.h.

References art::InResults, and treePointers_.

     {
       return *treePointers_[InResults];
     }

RootInputTree& art::RootInputFile::resultsTree ( )

inlineprivate

Definition at line 276 of file RootInputFile.h.

References fillHistory(), fillPerBranchTypePresenceFlags(), art::InResults, setIfFastClonable(), treePointers_, and validateFile().

     {
       return *treePointers_[InResults];
     }

void art::RootInputFile::rewind ( )

inline

Definition at line 163 of file RootInputFile.h.

References eventTree(), fiBegin_, fiIter_, art::RootInputTree::rewind(), runTree(), and subRunTree().

     {
       fiIter_ = fiBegin_;
       // FIXME: Rewinding the trees is suspicious!
       // FIXME: They should be positioned based on the new iter pos.
       eventTree().rewind();
       subRunTree().rewind();
       runTree().rewind();
     }

RunAuxiliary& art::RootInputFile::runAux ( )

inline

Definition at line 109 of file RootInputFile.h.

References auxiliaries_.

     {
       return std::get<RunAuxiliary>(auxiliaries_);
     }

unique_ptr< RangeSetHandler > art::RootInputFile::runRangeSetHandler ( )

Definition at line 712 of file RootInputFile.cc.

Referenced by secondaryFiles().

   {
     return std::move(runRangeSetHandler_);
   }

RootInputTree const& art::RootInputFile::runTree ( ) const

inlineprivate

Definition at line 249 of file RootInputFile.h.

References art::InRun, and treePointers_.

Referenced by rewind().

     {
       return *treePointers_[InRun];
     }

RootInputTree& art::RootInputFile::runTree ( )

inlineprivate

Definition at line 271 of file RootInputFile.h.

References art::InRun, and treePointers_.

     {
       return *treePointers_[InRun];
     }

auto const& art::RootInputFile::secondaryFileNames ( ) const

inline

Definition at line 221 of file RootInputFile.h.

References secondaryFileNames_.

     {
       return secondaryFileNames_;
     }

auto const& art::RootInputFile::secondaryFiles ( ) const

inline

Definition at line 226 of file RootInputFile.h.

References openSecondaryFile(), runRangeSetHandler(), secondaryFiles_, and subRunRangeSetHandler().

     {
       return secondaryFiles_;
     }

template<BranchType BT>

void art::RootInputFile::setEntry ( FileIndex::EntryNumber_t entry )

inline

Definition at line 145 of file RootInputFile.h.

References treePointers_.

     {
       treePointers_[BT]->setEntryNumber(entry);
     }

template<BranchType BT, typename ID >

bool art::RootInputFile::setEntry	(	ID const &	id,
		bool	exact = `true`
	)

inline

Definition at line 152 of file RootInputFile.h.

References fiEnd_, fiIter_, fileIndex_, and art::FileIndex::findPosition().

     {
       fiIter_ = fileIndex_.findPosition(id, exact);
       if (fiIter_ == fiEnd_) {
         return false;
       }
       setEntry<BT>(fiIter_->entry_);
       return true;
     }

int art::RootInputFile::setForcedRunOffset ( RunNumber_t const & forcedRunNumber )

Definition at line 429 of file RootInputFile.cc.

Referenced by eventsToSkip().

   {
     if (fiBegin_ == fiEnd_) {
       return 0;
     }
     forcedRunOffset_ = 0;
     if (!RunID(forcedRunNumber).isValid()) {
       return 0;
     }
     forcedRunOffset_ = forcedRunNumber - fiBegin_->eventID_.run();
     if (forcedRunOffset_ != 0) {
       fastClonable_ = false;
     }
     return forcedRunOffset_;
   }

bool art::RootInputFile::setIfFastClonable ( FastCloningInfoProvider const & fcip ) const

private

Definition at line 386 of file RootInputFile.cc.

References art::FastCloningInfoProvider::fastCloningPermitted(), art::FileIndex::kEvent, art::DecrepitRelicInputSourceImplementation::processingMode_, art::FastCloningInfoProvider::remainingEvents(), art::FastCloningInfoProvider::remainingSubRuns(), and art::InputSource::RunsSubRunsAndEvents.

Referenced by resultsTree().

   {
     if (!fcip.fastCloningPermitted()) {
       return false;
     }
     if (secondaryFileNames_.size() != 0) {
       return false;
     }
     if (!fileIndex_.allEventsInEntryOrder()) {
       return false;
     }
     if (eventsToSkip_ != 0) {
       return false;
     }
     if ((fcip.remainingEvents() >= 0) &&
         (eventTree().entries() > fcip.remainingEvents())) {
       return false;
     }
     if ((fcip.remainingSubRuns() >= 0) &&
         (subRunTree().entries() > fcip.remainingSubRuns())) {
       return false;
     }
     if (processingMode_ != InputSource::RunsSubRunsAndEvents) {
       return false;
     }
     if (forcedRunOffset_ != 0) {
       return false;
     }
     // Find entry for first event in file.
     auto it = fiBegin_;
     while ((it != fiEnd_) && (it->getEntryType() != FileIndex::kEvent)) {
       ++it;
     }
     if (it == fiEnd_) {
       return false;
     }
     if (it->eventID_ < origEventID_) {
       return false;
     }
     return true;
   }

void art::RootInputFile::setToLastEntry ( )

inline

Definition at line 174 of file RootInputFile.h.

References fiEnd_, and fiIter_.

     {
       fiIter_ = fiEnd_;
     }

int art::RootInputFile::skipEvents ( int offset )

Definition at line 589 of file RootInputFile.cc.

References art::FileIndex::kEvent.

Referenced by eventsToSkip().

   {
     while ((offset > 0) && (fiIter_ != fiEnd_)) {
       if (fiIter_->getEntryType() == FileIndex::kEvent) {
         --offset;
       }
       nextEntry();
     }
     while ((offset < 0) && (fiIter_ != fiBegin_)) {
       previousEntry();
       if (fiIter_->getEntryType() == FileIndex::kEvent) {
         ++offset;
       }
     }
     while ((fiIter_ != fiEnd_) &&
            (fiIter_->getEntryType() != FileIndex::kEvent)) {
       nextEntry();
     }
     return offset;
   }

SubRunAuxiliary& art::RootInputFile::subRunAux ( )

inline

Definition at line 119 of file RootInputFile.h.

References auxiliaries_.

     {
       return std::get<SubRunAuxiliary>(auxiliaries_);
     }

unique_ptr< RangeSetHandler > art::RootInputFile::subRunRangeSetHandler ( )

Definition at line 819 of file RootInputFile.cc.

Referenced by secondaryFiles().

   {
     return std::move(subRunRangeSetHandler_);
   }

RootInputTree const& art::RootInputFile::subRunTree ( ) const

inlineprivate

Definition at line 244 of file RootInputFile.h.

References art::InSubRun, and treePointers_.

Referenced by rewind().

     {
       return *treePointers_[InSubRun];
     }

RootInputTree& art::RootInputFile::subRunTree ( )

inlineprivate

Definition at line 266 of file RootInputFile.h.

References art::InSubRun, and treePointers_.

     {
       return *treePointers_[InSubRun];
     }

void art::RootInputFile::validateFile ( )

private

Definition at line 536 of file RootInputFile.cc.

References art::errors::DataCorruption, and art::errors::FileReadError.

Referenced by resultsTree().

   {
     if (!fileFormatVersion_.isValid()) {
       fileFormatVersion_.value_ = 0;
     }
     if (!eventTree().isValid()) {
       throw art::Exception{errors::DataCorruption}
         << "'Events' tree is corrupted or not present\n"
         << "in the input file.\n";
     }
     if (fileIndex_.empty()) {
       throw art::Exception{art::errors::FileReadError}
         << "FileIndex information is missing for the input file.\n";
     }
   }

Member Data Documentation

std::tuple<EventAuxiliary, SubRunAuxiliary, RunAuxiliary, ResultsAuxiliary> art::RootInputFile::auxiliaries_ {}

private

Definition at line 359 of file RootInputFile.h.

Referenced by eventAux(), fillAuxiliary(), resultsAux(), runAux(), and subRunAux().

std::unique_ptr<BranchIDLists> art::RootInputFile::branchIDLists_

private

Initial value:

{

nullptr}

Definition at line 365 of file RootInputFile.h.

std::string const art::RootInputFile::catalog_

private

Definition at line 331 of file RootInputFile.h.

bool const art::RootInputFile::compactSubRunRanges_

private

Definition at line 338 of file RootInputFile.h.

bool art::RootInputFile::delayedReadEventProducts_

private

Definition at line 340 of file RootInputFile.h.

bool art::RootInputFile::delayedReadRunProducts_

private

Definition at line 342 of file RootInputFile.h.

bool art::RootInputFile::delayedReadSubRunProducts_

private

Definition at line 341 of file RootInputFile.h.

std::shared_ptr<DuplicateChecker> art::RootInputFile::duplicateChecker_

private

Definition at line 346 of file RootInputFile.h.

TTree* art::RootInputFile::eventHistoryTree_ {nullptr}

private

Definition at line 368 of file RootInputFile.h.

EventNumber_t art::RootInputFile::eventsToSkip_

private

Definition at line 337 of file RootInputFile.h.

Referenced by eventsToSkip().

bool art::RootInputFile::fastClonable_ {false}

private

Definition at line 357 of file RootInputFile.h.

Referenced by fastClonable().

FileIndex::const_iterator art::RootInputFile::fiBegin_ {fileIndex_.begin()}

private

Definition at line 354 of file RootInputFile.h.

Referenced by rewind().

FileIndex::const_iterator art::RootInputFile::fiEnd_ {fileIndex_.end()}

private

Definition at line 355 of file RootInputFile.h.

Referenced by setEntry(), and setToLastEntry().

FileIndex::const_iterator art::RootInputFile::fiIter_ {fiBegin_}

private

Definition at line 356 of file RootInputFile.h.

Referenced by nextEntry(), previousEntry(), rewind(), setEntry(), and setToLastEntry().

FileFormatVersion art::RootInputFile::fileFormatVersion_ {}

private

Definition at line 351 of file RootInputFile.h.

Referenced by fileFormatVersion(), and fillAuxiliary().

FileIndex& art::RootInputFile::fileIndex_ {*fileIndexSharedPtr_}

private

Definition at line 353 of file RootInputFile.h.

Referenced by fillAuxiliary(), and setEntry().

std::shared_ptr<FileIndex> art::RootInputFile::fileIndexSharedPtr_ {new FileIndex}

private

Definition at line 352 of file RootInputFile.h.

Referenced by fileIndexSharedPtr().

std::string const art::RootInputFile::fileName_

private

Definition at line 330 of file RootInputFile.h.

Referenced by fileName(), and fillAuxiliary().

std::unique_ptr<TFile> art::RootInputFile::filePtr_

private

Definition at line 334 of file RootInputFile.h.

int art::RootInputFile::forcedRunOffset_

private

Definition at line 344 of file RootInputFile.h.

std::shared_ptr<History> art::RootInputFile::history_ {std::make_shared<History>()}

private

Definition at line 369 of file RootInputFile.h.

std::string const art::RootInputFile::logicalFileName_

private

Definition at line 333 of file RootInputFile.h.

bool art::RootInputFile::noEventSort_

private

Definition at line 345 of file RootInputFile.h.

EventID art::RootInputFile::origEventID_

private

Definition at line 336 of file RootInputFile.h.

ProductTables art::RootInputFile::presentProducts_ {ProductTables::invalid()}

private

Definition at line 364 of file RootInputFile.h.

cet::exempt_ptr<EventPrincipal> art::RootInputFile::primaryEP_ {}

private

Definition at line 375 of file RootInputFile.h.

cet::exempt_ptr<RootInputFile> art::RootInputFile::primaryFile_

private

Definition at line 347 of file RootInputFile.h.

cet::exempt_ptr<RunPrincipal> art::RootInputFile::primaryRP_ {}

private

Definition at line 376 of file RootInputFile.h.

cet::exempt_ptr<SubRunPrincipal> art::RootInputFile::primarySRP_ {}

private

Definition at line 377 of file RootInputFile.h.

ProcessConfiguration const& art::RootInputFile::processConfiguration_

private

Definition at line 332 of file RootInputFile.h.

InputSource::ProcessingMode art::RootInputFile::processingMode_

private

Definition at line 343 of file RootInputFile.h.

ProductRegistry art::RootInputFile::productListHolder_ {}

private

Definition at line 363 of file RootInputFile.h.

cet::exempt_ptr<RootInputFileSequence> art::RootInputFile::rifSequence_

private

Definition at line 349 of file RootInputFile.h.

std::unique_ptr<RangeSetHandler> art::RootInputFile::runRangeSetHandler_ {nullptr}

private

Definition at line 379 of file RootInputFile.h.

std::vector<std::string> art::RootInputFile::secondaryFileNames_

private

Definition at line 348 of file RootInputFile.h.

Referenced by secondaryFileNames().

std::vector<std::unique_ptr<RootInputFile> > art::RootInputFile::secondaryFiles_ {}

private

Definition at line 370 of file RootInputFile.h.

Referenced by secondaryFiles().

cet::sqlite::Connection art::RootInputFile::sqliteDB_ {}

private

Definition at line 335 of file RootInputFile.h.

Referenced by fillAuxiliary().

std::unique_ptr<RangeSetHandler> art::RootInputFile::subRunRangeSetHandler_ {nullptr}

private

Definition at line 378 of file RootInputFile.h.

RootInputTreePtrArray art::RootInputFile::treePointers_

private

Definition at line 339 of file RootInputFile.h.

Referenced by eventTree(), fillAuxiliary(), resultsTree(), runTree(), setEntry(), and subRunTree().

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

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation