#include <RootFile.h>

Public Member Functions
std::shared_ptr< BranchIDListHelper const >	branchIDListHelper () const

std::shared_ptr< BranchIDListHelper > &	branchIDListHelper ()

bool	branchListIndexesUnchanged () const

void	close ()

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

std::shared_ptr< FileBlock >	createFileBlock ()

bool	endOfProcessBlocksReached () const

RootTree const &	eventTree () const

std::string const &	file () const

FileFormatVersion	fileFormatVersion () const

void	fillProcessBlockHelper_ ()

IndexIntoFile::EntryType	getNextItemType (RunNumber_t &run, LuminosityBlockNumber_t &lumi, EventNumber_t &event)

bool	goToEvent (EventID const &eventID)

std::array< bool, NumBranchTypes > const &	hasNewlyDroppedBranch () const

IndexIntoFile::IndexIntoFileItr	indexIntoFileIter () const

std::shared_ptr< IndexIntoFile const >	indexIntoFileSharedPtr () const

std::shared_ptr< IndexIntoFile > &	indexIntoFileSharedPtr ()

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

bool	initializeFirstProcessBlockEntry ()

RootTree const &	lumiTree () const

bool	modifiedIDs () const

bool	nextEventEntry ()

bool	nextProcessBlock_ (ProcessBlockPrincipal &)

RootFile &	operator= (RootFile const &)=delete

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

std::tuple< bool, bool >	readCurrentEvent (EventPrincipal &cache, bool assertOnFailure=true)

bool	readEvent (EventPrincipal &cache)

void	readFakeRun_ (RunPrincipal &runPrincipal)

std::shared_ptr< RunAuxiliary >	readFakeRunAuxiliary_ ()

bool	readLuminosityBlock_ (LuminosityBlockPrincipal &lumiPrincipal)

std::shared_ptr< LuminosityBlockAuxiliary >	readLuminosityBlockAuxiliary_ ()

void	readProcessBlock_ (ProcessBlockPrincipal &)

bool	readRun_ (RunPrincipal &runPrincipal)

std::shared_ptr< RunAuxiliary >	readRunAuxiliary_ ()

void	reportOpened (std::string const &inputType)

void	rewind ()

	RootFile (std::string const &fileName, ProcessConfiguration const &processConfiguration, std::string const &logicalFileName, std::shared_ptr< InputFile > filePtr, std::shared_ptr< EventSkipperByID > eventSkipperByID, bool skipAnyEvents, int remainingEvents, int remainingLumis, unsigned int nStreams, unsigned int treeCacheSize, int treeMaxVirtualSize, InputSource::ProcessingMode processingMode, RunHelperBase runHelper, bool noRunLumiSort, bool noEventSort, ProductSelectorRules const &productSelectorRules, InputType inputType, std::shared_ptr< BranchIDListHelper > branchIDListHelper, ProcessBlockHelper , std::shared_ptr< ThinnedAssociationsHelper > thinnedAssociationsHelper, std::vector< BranchID > const *associationsFromSecondary, std::shared_ptr< DuplicateChecker > duplicateChecker, bool dropDescendantsOfDroppedProducts, ProcessHistoryRegistry &processHistoryRegistry, std::vector< std::shared_ptr< IndexIntoFile >> const &indexesIntoFiles, std::vector< std::shared_ptr< IndexIntoFile >>::size_type currentIndexIntoFile, std::vector< ProcessHistoryID > &orderedProcessHistoryIDs, bool bypassVersionCheck, bool labelRawDataLikeMC, bool usingGoToEvent, bool enablePrefetching, bool enforceGUIDInFileName)

	RootFile (std::string const &fileName, ProcessConfiguration const &processConfiguration, std::string const &logicalFileName, std::shared_ptr< InputFile > filePtr, unsigned int nStreams, int treeMaxVirtualSize, InputSource::ProcessingMode processingMode, RunHelperBase runHelper, ProductSelectorRules const &productSelectorRules, InputType inputType, std::shared_ptr< BranchIDListHelper > branchIDListHelper, std::shared_ptr< ThinnedAssociationsHelper > thinnedAssociationsHelper, std::vector< BranchID > const associationsFromSecondary, bool dropDescendantsOfDroppedProducts, ProcessHistoryRegistry &processHistoryRegistry, std::vector< std::shared_ptr< IndexIntoFile >> const &indexesIntoFiles, std::vector< std::shared_ptr< IndexIntoFile >>::size_type currentIndexIntoFile, std::vector< ProcessHistoryID > &orderedProcessHistoryIDs, bool bypassVersionCheck, bool labelRawDataLikeMC, bool enablePrefetching, bool enforceGUIDInFileName)

	RootFile (std::string const &fileName, ProcessConfiguration const &processConfiguration, std::string const &logicalFileName, std::shared_ptr< InputFile > filePtr, unsigned int nStreams, unsigned int treeCacheSize, int treeMaxVirtualSize, RunHelperBase *runHelper, ProductSelectorRules const &productSelectorRules, InputType inputType, ProcessHistoryRegistry &processHistoryRegistry, std::vector< std::shared_ptr< IndexIntoFile >> const &indexesIntoFiles, std::vector< std::shared_ptr< IndexIntoFile >>::size_type currentIndexIntoFile, std::vector< ProcessHistoryID > &orderedProcessHistoryIDs, bool bypassVersionCheck, bool enablePrefetching, bool enforceGUIDInFileName)

	RootFile (RootFile const &)=delete

RootTree const &	runTree () const

void	setAtEventEntry (IndexIntoFile::EntryNumber_t entry)

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

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

bool	setEntryAtLumi (RunNumber_t run, LuminosityBlockNumber_t lumi)

bool	setEntryAtNextEventInLumi (RunNumber_t run, LuminosityBlockNumber_t lumi)

bool	setEntryAtRun (RunNumber_t run)

void	setPosition (IndexIntoFile::IndexIntoFileItr const &position)

void	setSignals (signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const preEventReadSource, signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const postEventReadSource)

void	setToLastEntry ()

bool	skipEntries (unsigned int &offset)

bool	skipEvents (int &offset)

void	updateFileBlock (FileBlock &)

bool	wasFirstEventJustRead () const

bool	wasLastEventJustRead () const

int	whyNotFastClonable () const

	~RootFile ()

Private Member Functions
std::shared_ptr< BranchChildren const >	branchChildren () const

std::shared_ptr< BranchChildren > &	branchChildren ()

void	dropOnInputAndReorder (ProductRegistry &, ProductSelectorRules const &, bool dropDescendants, InputType, StoredProcessBlockHelper &, ProcessBlockHelper const *)

void	dropProcessesAndReorder (StoredProcessBlockHelper &, std::set< std::string > const &processesWithKeptProcessBlockProducts, ProcessBlockHelper const *)

std::shared_ptr< ProductProvenanceRetriever const >	eventProductProvenanceRetriever (size_t index) const

std::shared_ptr< ProductProvenanceRetriever > &	eventProductProvenanceRetriever (size_t index)

EventAuxiliary	fillEventAuxiliary (IndexIntoFile::EntryNumber_t entry)

bool	fillEventHistory (EventAuxiliary &evtAux, EventSelectionIDVector &eventSelectionIDs, BranchListIndexes &branchListIndexes, bool assertOnFailure=true)

void	fillEventToProcessBlockIndexes ()

void	fillIndexIntoFile ()

std::shared_ptr< LuminosityBlockAuxiliary >	fillLumiAuxiliary ()

std::shared_ptr< RunAuxiliary >	fillRunAuxiliary ()

EventAuxiliary const &	fillThisEventAuxiliary ()

void	initializeDuplicateChecker (std::vector< std::shared_ptr< IndexIntoFile >> const &indexesIntoFiles, std::vector< std::shared_ptr< IndexIntoFile >>::size_type currentIndexIntoFile)

bool	isDuplicateEvent ()

void	makeProcessBlockRootTrees (std::shared_ptr< InputFile > filePtr, int treeMaxVirtualSize, bool enablePrefetching, InputType inputType, StoredProcessBlockHelper const &storedProcessBlockHelper)

std::shared_ptr< ProductProvenanceRetriever >	makeProductProvenanceRetriever (unsigned int iStreamIndex)

std::unique_ptr< MakeProvenanceReader >	makeProvenanceReaderMaker (InputType inputType)

void	markBranchToBeDropped (bool dropDescendants, BranchDescription const &branch, std::set< BranchID > &branchesToDrop, std::map< BranchID, BranchID > const &droppedToKeptAlias) const

std::string const &	newBranchToOldBranch (std::string const &newBranch) const

void	readEntryDescriptionTree (EntryDescriptionMap &entryDescriptionMap, InputType inputType)

void	readEventHistoryTree ()

void	readParentageTree (InputType inputType)

std::shared_ptr< RunAuxiliary const >	savedRunAuxiliary () const

std::shared_ptr< RunAuxiliary > &	savedRunAuxiliary ()

void	setIfFastClonable (int remainingEvents, int remainingLumis)

void	setPresenceInProductRegistry (ProductRegistry &, StoredProcessBlockHelper const &)

bool	skipThisEntry ()

void	validateFile (InputType inputType, bool usingGoToEvent)

Private Attributes
edm::propagate_const< std::shared_ptr< BranchChildren > >	branchChildren_

edm::propagate_const< std::shared_ptr< BranchIDListHelper > >	branchIDListHelper_

std::shared_ptr< BranchIDLists const >	branchIDLists_

bool	branchListIndexesUnchanged_

unsigned int	currentProcessBlockTree_ = 0

edm::propagate_const< std::unique_ptr< DaqProvenanceHelper > >	daqProvenanceHelper_

edm::propagate_const< std::shared_ptr< DuplicateChecker > >	duplicateChecker_

edm::propagate_const< TClass * >	edProductClass_

bool	enforceGUIDInFileName_

EventAuxiliary	eventAuxCache_

edm::propagate_const< TTree * >	eventHistoryTree_

std::vector< EventProcessHistoryID >	eventProcessHistoryIDs_

std::vector< EventProcessHistoryID >::const_iterator	eventProcessHistoryIter_

std::vector< edm::propagate_const< std::shared_ptr< ProductProvenanceRetriever > > >	eventProductProvenanceRetrievers_

edm::propagate_const< std::shared_ptr< EventSkipperByID > >	eventSkipperByID_

EventToProcessBlockIndexes	eventToProcessBlockIndexes_

edm::propagate_const< TBranch * >	eventToProcessBlockIndexesBranch_

RootTree	eventTree_

FileID	fid_

std::string const	file_

FileFormatVersion	fileFormatVersion_

edm::propagate_const< std::shared_ptr< InputFile > >	filePtr_

edm::propagate_const< std::unique_ptr< ThinnedAssociationsHelper > >	fileThinnedAssociationsHelper_

std::array< bool, NumBranchTypes >	hasNewlyDroppedBranch_

edm::propagate_const< std::unique_ptr< History > >	history_

IndexIntoFile &	indexIntoFile_

IndexIntoFile::IndexIntoFileItr	indexIntoFileBegin_

IndexIntoFile::IndexIntoFileItr	indexIntoFileEnd_

IndexIntoFile::IndexIntoFileItr	indexIntoFileIter_

edm::propagate_const< std::shared_ptr< IndexIntoFile > >	indexIntoFileSharedPtr_

InputType	inputType_

IndexIntoFile::EntryNumber_t	lastEventEntryNumberRead_

std::string const	logicalFile_

RootTree	lumiTree_

std::map< std::string, std::string >	newBranchToOldBranch_

bool	noEventSort_

bool	noRunLumiSort_

std::vector< ProcessHistoryID > &	orderedProcessHistoryIDs_

std::vector< ParentageID >	parentageIDLookup_

edm::propagate_const< ProcessBlockHelper * >	processBlockHelper_

std::vector< edm::propagate_const< std::unique_ptr< RootTree > > >	processBlockTrees_

ProcessConfiguration const &	processConfiguration_

edm::propagate_const< ProcessHistoryRegistry * >	processHistoryRegistry_

InputSource::ProcessingMode	processingMode_

std::shared_ptr< ProductRegistry const >	productRegistry_

edm::propagate_const< std::unique_ptr< ProvenanceAdaptor > >	provenanceAdaptor_

edm::propagate_const< std::unique_ptr< MakeProvenanceReader > >	provenanceReaderMaker_

edm::propagate_const< RunHelperBase * >	runHelper_

RootTree	runTree_

edm::propagate_const< std::shared_ptr< RunAuxiliary > >	savedRunAuxiliary_

bool	skipAnyEvents_

edm::propagate_const< std::unique_ptr< StoredMergeableRunProductMetadata > >	storedMergeableRunProductMetadata_

edm::propagate_const< std::unique_ptr< StoredProcessBlockHelper > >	storedProcessBlockHelper_

edm::propagate_const< std::shared_ptr< ThinnedAssociationsHelper > >	thinnedAssociationsHelper_

std::vector< edm::propagate_const< RootTree * > >	treePointers_

int	whyNotFastClonable_

Detailed Description

Definition at line 71 of file RootFile.h.

Constructor & Destructor Documentation

◆ RootFile() [1/4]

edm::RootFile::RootFile	(	std::string const &	fileName,
		ProcessConfiguration const &	processConfiguration,
		std::string const &	logicalFileName,
		std::shared_ptr< InputFile >	filePtr,
		std::shared_ptr< EventSkipperByID >	eventSkipperByID,
		bool	skipAnyEvents,
		int	remainingEvents,
		int	remainingLumis,
		unsigned int	nStreams,
		unsigned int	treeCacheSize,
		int	treeMaxVirtualSize,
		InputSource::ProcessingMode	processingMode,
		RunHelperBase *	runHelper,
		bool	noRunLumiSort,
		bool	noEventSort,
		ProductSelectorRules const &	productSelectorRules,
		InputType	inputType,
		std::shared_ptr< BranchIDListHelper >	branchIDListHelper,
		ProcessBlockHelper *	processBlockHelper,
		std::shared_ptr< ThinnedAssociationsHelper >	thinnedAssociationsHelper,
		std::vector< BranchID > const *	associationsFromSecondary,
		std::shared_ptr< DuplicateChecker >	duplicateChecker,
		bool	dropDescendantsOfDroppedProducts,
		ProcessHistoryRegistry &	processHistoryRegistry,
		std::vector< std::shared_ptr< IndexIntoFile >> const &	indexesIntoFiles,
		std::vector< std::shared_ptr< IndexIntoFile >>::size_type	currentIndexIntoFile,
		std::vector< ProcessHistoryID > &	orderedProcessHistoryIDs,
		bool	bypassVersionCheck,
		bool	labelRawDataLikeMC,
		bool	usingGoToEvent,
		bool	enablePrefetching,
		bool	enforceGUIDInFileName
	)

Definition at line 145 of file RootFile.cc.

References cms::cuda::assert(), edm::IndexIntoFile::begin(), branchChildren_, edm::poolNames::branchIDListBranchName(), branchIDListHelper_, branchIDLists_, branchListIndexesUnchanged_, edm::BranchDescription::branchName(), edm::BranchTypeToAuxiliaryBranchName(), edm::ProductRegistry::copyProduct(), daqProvenanceHelper_, edm::roottree::defaultNonEventCacheSize, HLT_2022v14_cff::distance, edm::IndexIntoFile::doneFileInitialization(), dropOnInputAndReorder(), edm::IndexIntoFile::end(), edm::IndexIntoFile::entryOrder, edm::errors::EventCorruption, edm::poolNames::eventHistoryBranchName(), eventProcessHistoryIDs_, eventProcessHistoryIter_, eventSkipperByID_, edm::FileBlock::EventsOrLumisSelectedByID, eventTree_, Exception, fid_, file(), fileFormatVersion(), fileFormatVersion_, edm::poolNames::fileFormatVersionBranchName(), edm::poolNames::fileIdentifierBranchName(), filePtr_, edm::errors::FileReadError, fileThinnedAssociationsHelper_, spr::find(), HLT_2022v14_cff::finder, edm::IndexIntoFile::firstAppearanceOrder, edm::friendlyname::friendlyName(), edm::roottree::getEntry(), hasNewlyDroppedBranch_, edm::FileFormatVersion::hasThinnedAssociations(), mps_fire::i, edm::poolNames::idToParameterSetBlobsBranchName(), indexIntoFile_, indexIntoFileBegin_, edm::poolNames::indexIntoFileBranchName(), indexIntoFileEnd_, indexIntoFileIter_, edm::InEvent, initializeDuplicateChecker(), edm::ProcessBlockHelper::initializeFromPrimaryInput(), edm::InLumi, edm::InProcess, edm::InRun, edm::pset::Registry::insertMapped(), edm::pset::Registry::instance(), lumiTree_, makeProcessBlockRootTrees(), makeProvenanceReaderMaker(), edm::poolNames::mergeableRunProductMetadataBranchName(), edm::poolNames::metaDataTreeName(), edm::poolNames::moduleDescriptionMapBranchName(), newBranchToOldBranch(), newBranchToOldBranch_, edm::numberOfRunLumiEventProductTrees, edm::IndexIntoFile::numericalOrder, edm::poolNames::parameterSetMapBranchName(), edm::poolNames::parameterSetsTreeName(), edm::Primary, edm::poolNames::processBlockHelperBranchName(), processBlockTrees_, edm::poolNames::processConfigurationBranchName(), dqmiodatasetharvest::processes, edm::poolNames::processHistoryBranchName(), edm::poolNames::processHistoryMapBranchName(), dumpMFGeometry_cfg::prod, edm::poolNames::productDependenciesBranchName(), edm::poolNames::productDescriptionBranchName(), edm::ProductRegistry::productList(), edm::ProductRegistry::productListUpdator(), productRegistry(), productRegistry_, provenanceAdaptor_, provenanceReaderMaker_, muonDTDigis_cfi::pset, l1tstage2_dqm_sourceclient-live_cfg::rawData, readEventHistoryTree(), edm::ProcessHistoryRegistry::registerProcessHistory(), edm::RootTree::resetTraining(), edm::IndexIntoFile::IndexIntoFileItr::run(), runHelper_, runTree_, edm::SecondaryFile, edm::SecondarySource, setIfFastClonable(), edm::setIsMergeable(), setPresenceInProductRegistry(), edm::source(), storedMergeableRunProductMetadata_, storedProcessBlockHelper_, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, edm::poolNames::thinnedAssociationsHelperBranchName(), edm::RootTree::trainCache(), edm::roottree::trainCache(), treePointers_, edm::errors::UnimplementedFeature, edm::BranchDescription::updateFriendlyClassName(), validateFile(), and whyNotFastClonable_.

       : file_(fileName),
         logicalFile_(logicalFileName),
         processConfiguration_(processConfiguration),
         processHistoryRegistry_(&processHistoryRegistry),
         filePtr_(filePtr),
         eventSkipperByID_(eventSkipperByID),
         fileFormatVersion_(),
         fid_(),
         indexIntoFileSharedPtr_(new IndexIntoFile),
         indexIntoFile_(*indexIntoFileSharedPtr_),
         orderedProcessHistoryIDs_(orderedProcessHistoryIDs),
         indexIntoFileBegin_(indexIntoFile_.begin(
             noRunLumiSort ? IndexIntoFile::entryOrder
                           : (noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder))),
         indexIntoFileEnd_(indexIntoFileBegin_),
         indexIntoFileIter_(indexIntoFileBegin_),
         storedMergeableRunProductMetadata_((inputType == InputType::Primary) ? new StoredMergeableRunProductMetadata
                                                                              : nullptr),
         eventProcessHistoryIDs_(),
         eventProcessHistoryIter_(eventProcessHistoryIDs_.begin()),
         savedRunAuxiliary_(),
         skipAnyEvents_(skipAnyEvents),
         noRunLumiSort_(noRunLumiSort),
         noEventSort_(noEventSort),
         enforceGUIDInFileName_(enforceGUIDInFileName),
         whyNotFastClonable_(0),
         hasNewlyDroppedBranch_(),
         branchListIndexesUnchanged_(false),
         eventAuxCache_(),
         eventTree_(filePtr,
                    InEvent,
                    nStreams,
                    treeMaxVirtualSize,
                    treeCacheSize,
                    roottree::defaultLearningEntries,
                    enablePrefetching,
                    inputType),
         lumiTree_(filePtr,
                   InLumi,
                   1,
                   treeMaxVirtualSize,
                   roottree::defaultNonEventCacheSize,
                   roottree::defaultNonEventLearningEntries,
                   enablePrefetching,
                   inputType),
         runTree_(filePtr,
                  InRun,
                  1,
                  treeMaxVirtualSize,
                  roottree::defaultNonEventCacheSize,
                  roottree::defaultNonEventLearningEntries,
                  enablePrefetching,
                  inputType),
         treePointers_(),
         lastEventEntryNumberRead_(IndexIntoFile::invalidEntry),
         productRegistry_(),
         branchIDLists_(),
         branchIDListHelper_(branchIDListHelper),
         processBlockHelper_(processBlockHelper),
         fileThinnedAssociationsHelper_(),
         thinnedAssociationsHelper_(thinnedAssociationsHelper),
         processingMode_(processingMode),
         runHelper_(runHelper),
         newBranchToOldBranch_(),
         eventHistoryTree_(nullptr),
         eventToProcessBlockIndexesBranch_(
             inputType == InputType::Primary
                 ? eventTree_.tree()->GetBranch(poolNames::eventToProcessBlockIndexesBranchName().c_str())
                 : nullptr),
         history_(),
         branchChildren_(new BranchChildren),
         duplicateChecker_(duplicateChecker),
         provenanceAdaptor_(),
         provenanceReaderMaker_(),
         eventProductProvenanceRetrievers_(),
         parentageIDLookup_(),
         daqProvenanceHelper_(),
         edProductClass_(TypeWithDict::byName("edm::WrapperBase").getClass()),
         inputType_(inputType) {
     hasNewlyDroppedBranch_.fill(false);
 
     treePointers_.resize(3);
     treePointers_[InEvent] = &eventTree_;
     treePointers_[InLumi] = &lumiTree_;
     treePointers_[InRun] = &runTree_;
 
     // Read the metadata tree.
     // We use a smart pointer so the tree will be deleted after use, and not kept for the life of the file.
     std::unique_ptr<TTree> metaDataTree(dynamic_cast<TTree*>(filePtr_->Get(poolNames::metaDataTreeName().c_str())));
     if (nullptr == metaDataTree.get()) {
       throw Exception(errors::FileReadError)
           << "Could not find tree " << poolNames::metaDataTreeName() << " in the input file.\n";
     }
 
     // To keep things simple, we just read in every possible branch that exists.
     // We don't pay attention to which branches exist in which file format versions
 
     FileFormatVersion* fftPtr = &fileFormatVersion_;
     if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != nullptr) {
       TBranch* fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
       fft->SetAddress(&fftPtr);
       roottree::getEntry(fft, 0);
       metaDataTree->SetBranchAddress(poolNames::fileFormatVersionBranchName().c_str(), &fftPtr);
     }
 
     FileID* fidPtr = &fid_;
     if (metaDataTree->FindBranch(poolNames::fileIdentifierBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
     }
 
     IndexIntoFile* iifPtr = &indexIntoFile_;
     if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::indexIntoFileBranchName().c_str(), &iifPtr);
     }
 
     storedProcessBlockHelper_ = std::make_unique<StoredProcessBlockHelper>();
     StoredProcessBlockHelper& storedProcessBlockHelper = *storedProcessBlockHelper_;
     StoredProcessBlockHelper* pStoredProcessBlockHelper = storedProcessBlockHelper_.get();
     if (inputType == InputType::Primary) {
       if (metaDataTree->FindBranch(poolNames::processBlockHelperBranchName().c_str()) != nullptr) {
         metaDataTree->SetBranchAddress(poolNames::processBlockHelperBranchName().c_str(), &pStoredProcessBlockHelper);
       }
     }
 
     StoredMergeableRunProductMetadata* smrc = nullptr;
     if (inputType == InputType::Primary) {
       smrc = &*storedMergeableRunProductMetadata_;
       if (metaDataTree->FindBranch(poolNames::mergeableRunProductMetadataBranchName().c_str()) != nullptr) {
         metaDataTree->SetBranchAddress(poolNames::mergeableRunProductMetadataBranchName().c_str(), &smrc);
       }
     }
 
     // Need to read to a temporary registry so we can do a translation of the BranchKeys.
     // This preserves backward compatibility against friendly class name algorithm changes.
     ProductRegistry inputProdDescReg;
     ProductRegistry* ppReg = &inputProdDescReg;
     metaDataTree->SetBranchAddress(poolNames::productDescriptionBranchName().c_str(), (&ppReg));
 
     using PsetMap = std::map<ParameterSetID, ParameterSetBlob>;
     PsetMap psetMap;
     PsetMap* psetMapPtr = &psetMap;
     if (metaDataTree->FindBranch(poolNames::parameterSetMapBranchName().c_str()) != nullptr) {
       //backward compatibility
       assert(!fileFormatVersion().parameterSetsTree());
       metaDataTree->SetBranchAddress(poolNames::parameterSetMapBranchName().c_str(), &psetMapPtr);
     } else {
       assert(fileFormatVersion().parameterSetsTree());
       // We use a smart pointer so the tree will be deleted after use, and not kept for the life of the file.
       std::unique_ptr<TTree> psetTree(dynamic_cast<TTree*>(filePtr_->Get(poolNames::parameterSetsTreeName().c_str())));
       if (nullptr == psetTree.get()) {
         throw Exception(errors::FileReadError)
             << "Could not find tree " << poolNames::parameterSetsTreeName() << " in the input file.\n";
       }
 
       using IdToBlobs = std::pair<ParameterSetID, ParameterSetBlob>;
       IdToBlobs idToBlob;
       IdToBlobs* pIdToBlob = &idToBlob;
       psetTree->SetBranchAddress(poolNames::idToParameterSetBlobsBranchName().c_str(), &pIdToBlob);
 
       std::unique_ptr<TTreeCache> psetTreeCache =
           roottree::trainCache(psetTree.get(), *filePtr_, roottree::defaultNonEventCacheSize, "*");
       psetTreeCache->SetEnablePrefetching(false);
       filePtr_->SetCacheRead(psetTreeCache.get());
       for (Long64_t i = 0; i != psetTree->GetEntries(); ++i) {
         psetTree->GetEntry(i);
         psetMap.insert(idToBlob);
       }
       filePtr_->SetCacheRead(nullptr);
     }
 
     // backward compatibility
     ProcessHistoryRegistry::collection_type pHistMap;
     ProcessHistoryRegistry::collection_type* pHistMapPtr = &pHistMap;
     if (metaDataTree->FindBranch(poolNames::processHistoryMapBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::processHistoryMapBranchName().c_str(), &pHistMapPtr);
     }
 
     ProcessHistoryRegistry::vector_type pHistVector;
     ProcessHistoryRegistry::vector_type* pHistVectorPtr = &pHistVector;
     if (metaDataTree->FindBranch(poolNames::processHistoryBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::processHistoryBranchName().c_str(), &pHistVectorPtr);
     }
 
     // backward compatibility
     ProcessConfigurationVector processConfigurations;
     ProcessConfigurationVector* procConfigVectorPtr = &processConfigurations;
     if (metaDataTree->FindBranch(poolNames::processConfigurationBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::processConfigurationBranchName().c_str(), &procConfigVectorPtr);
     }
 
     auto branchIDListsAPtr = std::make_unique<BranchIDLists>();
     BranchIDLists* branchIDListsPtr = branchIDListsAPtr.get();
     if (metaDataTree->FindBranch(poolNames::branchIDListBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::branchIDListBranchName().c_str(), &branchIDListsPtr);
     }
 
     ThinnedAssociationsHelper* thinnedAssociationsHelperPtr;  // must remain in scope through getEntry()
     if (inputType != InputType::SecondarySource) {
       fileThinnedAssociationsHelper_ =
           std::make_unique<ThinnedAssociationsHelper>();  // propagate_const<T> has no reset() function
       thinnedAssociationsHelperPtr = fileThinnedAssociationsHelper_.get();
       if (metaDataTree->FindBranch(poolNames::thinnedAssociationsHelperBranchName().c_str()) != nullptr) {
         metaDataTree->SetBranchAddress(poolNames::thinnedAssociationsHelperBranchName().c_str(),
                                        &thinnedAssociationsHelperPtr);
       }
     }
 
     BranchChildren* branchChildrenBuffer = branchChildren_.get();
     if (metaDataTree->FindBranch(poolNames::productDependenciesBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::productDependenciesBranchName().c_str(), &branchChildrenBuffer);
     }
 
     // backward compatibility
     std::vector<EventProcessHistoryID>* eventHistoryIDsPtr = &eventProcessHistoryIDs_;
     if (metaDataTree->FindBranch(poolNames::eventHistoryBranchName().c_str()) != nullptr) {
       metaDataTree->SetBranchAddress(poolNames::eventHistoryBranchName().c_str(), &eventHistoryIDsPtr);
     }
 
     if (metaDataTree->FindBranch(poolNames::moduleDescriptionMapBranchName().c_str()) != nullptr) {
       if (metaDataTree->GetBranch(poolNames::moduleDescriptionMapBranchName().c_str())->GetSplitLevel() != 0) {
         metaDataTree->SetBranchStatus((poolNames::moduleDescriptionMapBranchName() + ".*").c_str(), false);
       } else {
         metaDataTree->SetBranchStatus(poolNames::moduleDescriptionMapBranchName().c_str(), false);
       }
     }
 
     // Here we read the metadata tree
     roottree::getEntry(metaDataTree.get(), 0);
 
     eventProcessHistoryIter_ = eventProcessHistoryIDs_.begin();
 
     // Here we read the event history tree, if we have one.
     readEventHistoryTree();
 
     ParameterSetConverter::ParameterSetIdConverter psetIdConverter;
     if (!fileFormatVersion().triggerPathsTracked()) {
       ParameterSetConverter converter(psetMap, psetIdConverter, fileFormatVersion().parameterSetsByReference());
     } else {
       // Merge into the parameter set registry.
       pset::Registry& psetRegistry = *pset::Registry::instance();
       for (auto const& psetEntry : psetMap) {
         ParameterSet pset(psetEntry.second.pset());
         pset.setID(psetEntry.first);
         // For thread safety, don't update global registries when a secondary source opens a file.
         if (inputType != InputType::SecondarySource) {
           psetRegistry.insertMapped(pset);
         }
       }
     }
     if (!fileFormatVersion().splitProductIDs()) {
       // Old provenance format input file.  Create a provenance adaptor.
       // propagate_const<T> has no reset() function
       provenanceAdaptor_ = std::make_unique<ProvenanceAdaptor>(
           inputProdDescReg, pHistMap, pHistVector, processConfigurations, psetIdConverter, true);
       // Fill in the branchIDLists branch from the provenance adaptor
       branchIDLists_ = provenanceAdaptor_->branchIDLists();
     } else {
       if (!fileFormatVersion().triggerPathsTracked()) {
         // New provenance format, but change in ParameterSet Format. Create a provenance adaptor.
         // propagate_const<T> has no reset() function
         provenanceAdaptor_ = std::make_unique<ProvenanceAdaptor>(
             inputProdDescReg, pHistMap, pHistVector, processConfigurations, psetIdConverter, false);
       }
       // New provenance format input file. The branchIDLists branch was read directly from the input file.
       if (metaDataTree->FindBranch(poolNames::branchIDListBranchName().c_str()) == nullptr) {
         throw Exception(errors::EventCorruption) << "Failed to find branchIDLists branch in metaData tree.\n";
       }
       branchIDLists_.reset(branchIDListsAPtr.release());
     }
 
     if (fileFormatVersion().hasThinnedAssociations()) {
       if (metaDataTree->FindBranch(poolNames::thinnedAssociationsHelperBranchName().c_str()) == nullptr) {
         throw Exception(errors::EventCorruption)
             << "Failed to find thinnedAssociationsHelper branch in metaData tree.\n";
       }
     }
 
     if (!bypassVersionCheck) {
       checkReleaseVersion(pHistVector, file());
     }
 
     if (labelRawDataLikeMC) {
       std::string const rawData("FEDRawDataCollection");
       std::string const source("source");
       ProductRegistry::ProductList& pList = inputProdDescReg.productListUpdator();
       BranchKey finder(rawData, source, "", "");
       ProductRegistry::ProductList::iterator it = pList.lower_bound(finder);
       if (it != pList.end() && it->first.friendlyClassName() == rawData && it->first.moduleLabel() == source) {
         // We found raw data with a module label of source.
         // We need to change the module label and process name.
         // Create helper.
         it->second.init();
         // propagate_const<T> has no reset() function
         daqProvenanceHelper_ = std::make_unique<DaqProvenanceHelper>(it->second.unwrappedTypeID());
         // Create the new branch description
         BranchDescription const& newBD = daqProvenanceHelper_->branchDescription();
         // Save info from the old and new branch descriptions
         daqProvenanceHelper_->saveInfo(it->second, newBD);
         // Map the new branch name to the old branch name.
         newBranchToOldBranch_.insert(std::make_pair(newBD.branchName(), it->second.branchName()));
         // Remove the old branch description from the product Registry.
         pList.erase(it);
         // Check that there was only one.
         it = pList.lower_bound(finder);
         assert(!(it != pList.end() && it->first.friendlyClassName() == rawData && it->first.moduleLabel() == source));
         // Insert the new branch description into the product registry.
         inputProdDescReg.copyProduct(newBD);
         // Fix up other per file metadata.
         daqProvenanceHelper_->fixMetaData(processConfigurations, pHistVector);
         daqProvenanceHelper_->fixMetaData(*branchIDLists_);
         daqProvenanceHelper_->fixMetaData(*branchChildren_);
       }
     }
 
     for (auto const& history : pHistVector) {
       processHistoryRegistry.registerProcessHistory(history);
     }
 
     eventTree_.trainCache(BranchTypeToAuxiliaryBranchName(InEvent).c_str());
 
     // Update the branch id info. This has to be done before validateFile since
     // depending on the file format, the branchIDListHelper_ may have its fixBranchListIndexes call made
     if (inputType == InputType::Primary) {
       branchListIndexesUnchanged_ = branchIDListHelper_->updateFromInput(*branchIDLists_);
     }
 
     validateFile(inputType, usingGoToEvent);
 
     // Here, we make the class that will make the ProvenanceReader
     // It reads whatever trees it needs.
     // propagate_const<T> has no reset() function
     provenanceReaderMaker_ = std::unique_ptr<MakeProvenanceReader>(makeProvenanceReaderMaker(inputType).release());
 
     // Merge into the hashed registries.
     if (eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
       whyNotFastClonable_ += FileBlock::EventsOrLumisSelectedByID;
     }
 
     initializeDuplicateChecker(indexesIntoFiles, currentIndexIntoFile);
     indexIntoFileIter_ = indexIntoFileBegin_ = indexIntoFile_.begin(
         noRunLumiSort ? IndexIntoFile::entryOrder
                       : (noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder));
     indexIntoFileEnd_ = indexIntoFile_.end(
         noRunLumiSort ? IndexIntoFile::entryOrder
                       : (noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder));
     runHelper_->setForcedRunOffset(indexIntoFileBegin_ == indexIntoFileEnd_ ? 1 : indexIntoFileBegin_.run());
     eventProcessHistoryIter_ = eventProcessHistoryIDs_.begin();
 
     makeProcessBlockRootTrees(filePtr, treeMaxVirtualSize, enablePrefetching, inputType, storedProcessBlockHelper);
 
     setPresenceInProductRegistry(inputProdDescReg, storedProcessBlockHelper);
 
     auto newReg = std::make_unique<ProductRegistry>();
 
     // Do the translation from the old registry to the new one
     {
       ProductRegistry::ProductList const& prodList = inputProdDescReg.productList();
       for (auto const& product : prodList) {
         BranchDescription const& prod = product.second;
         std::string newFriendlyName = friendlyname::friendlyName(prod.className());
         if (newFriendlyName == prod.friendlyClassName()) {
           newReg->copyProduct(prod);
         } else {
           if (fileFormatVersion().splitProductIDs()) {
             throw Exception(errors::UnimplementedFeature)
                 << "Cannot change friendly class name algorithm without more development work\n"
                 << "to update BranchIDLists and ThinnedAssociationsHelper.  Contact the framework group.\n";
           }
           BranchDescription newBD(prod);
           newBD.updateFriendlyClassName();
           newReg->copyProduct(newBD);
           newBranchToOldBranch_.insert(std::make_pair(newBD.branchName(), prod.branchName()));
         }
       }
 
       dropOnInputAndReorder(
           *newReg, productSelectorRules, dropDescendants, inputType, storedProcessBlockHelper, processBlockHelper);
 
       if (inputType == InputType::SecondaryFile) {
         thinnedAssociationsHelper->updateFromSecondaryInput(*fileThinnedAssociationsHelper_,
                                                             *associationsFromSecondary);
       } else if (inputType == InputType::Primary) {
         processBlockHelper->initializeFromPrimaryInput(storedProcessBlockHelper);
         thinnedAssociationsHelper->updateFromPrimaryInput(*fileThinnedAssociationsHelper_);
       }
 
       if (inputType == InputType::Primary) {
         for (auto& product : newReg->productListUpdator()) {
           setIsMergeable(product.second);
         }
       }
       //inform system we want to use DelayedReader
       for (auto& product : newReg->productListUpdator()) {
         product.second.setOnDemand(true);
       }
 
       for (auto& processBlockTree : processBlockTrees_) {
         treePointers_.push_back(processBlockTree.get());
       }
 
       // freeze the product registry
       newReg->setFrozen(inputType != InputType::Primary);
       productRegistry_.reset(newReg.release());
     }
 
     // Set up information from the product registry.
     ProductRegistry::ProductList const& prodList = productRegistry()->productList();
 
     {
       std::vector<size_t> nBranches(treePointers_.size(), 0);
       for (auto const& product : prodList) {
         if (product.second.branchType() == InProcess) {
           std::vector<std::string> const& processes = storedProcessBlockHelper.processesWithProcessBlockProducts();
           auto it = std::find(processes.begin(), processes.end(), product.second.processName());
           if (it != processes.end()) {
             auto index = std::distance(processes.begin(), it);
             ++nBranches[numberOfRunLumiEventProductTrees + index];
           }
         } else {
           ++nBranches[product.second.branchType()];
         }
       }
 
       int i = 0;
       for (auto& t : treePointers_) {
         t->numberOfBranchesToAdd(nBranches[i]);
         ++i;
       }
     }
     for (auto const& product : prodList) {
       BranchDescription const& prod = product.second;
       if (prod.branchType() == InProcess) {
         std::vector<std::string> const& processes = storedProcessBlockHelper.processesWithProcessBlockProducts();
         auto it = std::find(processes.begin(), processes.end(), prod.processName());
         if (it != processes.end()) {
           auto index = std::distance(processes.begin(), it);
           treePointers_[numberOfRunLumiEventProductTrees + index]->addBranch(prod,
                                                                              newBranchToOldBranch(prod.branchName()));
         }
       } else {
         treePointers_[prod.branchType()]->addBranch(prod, newBranchToOldBranch(prod.branchName()));
       }
     }
 
     // Determine if this file is fast clonable.
     setIfFastClonable(remainingEvents, remainingLumis);
 
     // We are done with our initial reading of EventAuxiliary.
     indexIntoFile_.doneFileInitialization();
 
     // Tell the event tree to begin training at the next read.
     eventTree_.resetTraining();
 
     // Train the run and lumi trees.
     runTree_.trainCache("*");
     lumiTree_.trainCache("*");
     for (auto& processBlockTree : processBlockTrees_) {
       processBlockTree->trainCache("*");
     }
   }

◆ RootFile() [2/4]

edm::RootFile::RootFile	(	std::string const &	fileName,
		ProcessConfiguration const &	processConfiguration,
		std::string const &	logicalFileName,
		std::shared_ptr< InputFile >	filePtr,
		unsigned int	nStreams,
		int	treeMaxVirtualSize,
		InputSource::ProcessingMode	processingMode,
		RunHelperBase *	runHelper,
		ProductSelectorRules const &	productSelectorRules,
		InputType	inputType,
		std::shared_ptr< BranchIDListHelper >	branchIDListHelper,
		std::shared_ptr< ThinnedAssociationsHelper >	thinnedAssociationsHelper,
		std::vector< BranchID > const *	associationsFromSecondary,
		bool	dropDescendantsOfDroppedProducts,
		ProcessHistoryRegistry &	processHistoryRegistry,
		std::vector< std::shared_ptr< IndexIntoFile >> const &	indexesIntoFiles,
		std::vector< std::shared_ptr< IndexIntoFile >>::size_type	currentIndexIntoFile,
		std::vector< ProcessHistoryID > &	orderedProcessHistoryIDs,
		bool	bypassVersionCheck,
		bool	labelRawDataLikeMC,
		bool	enablePrefetching,
		bool	enforceGUIDInFileName
	)

inline

Definition at line 108 of file RootFile.h.

         : RootFile(fileName,
                    processConfiguration,
                    logicalFileName,
                    filePtr,
                    nullptr,
                    false,
                    -1,
                    -1,
                    nStreams,
                    0U,
                    treeMaxVirtualSize,
                    processingMode,
                    runHelper,
                    false,
                    false,
                    productSelectorRules,
                    inputType,
                    branchIDListHelper,
                    nullptr,
                    thinnedAssociationsHelper,
                    associationsFromSecondary,
                    nullptr,
                    dropDescendantsOfDroppedProducts,
                    processHistoryRegistry,
                    indexesIntoFiles,
                    currentIndexIntoFile,
                    orderedProcessHistoryIDs,
                    bypassVersionCheck,
                    labelRawDataLikeMC,
                    false,
                    enablePrefetching,
                    enforceGUIDInFileName) {}

◆ RootFile() [3/4]

edm::RootFile::RootFile	(	std::string const &	fileName,
		ProcessConfiguration const &	processConfiguration,
		std::string const &	logicalFileName,
		std::shared_ptr< InputFile >	filePtr,
		unsigned int	nStreams,
		unsigned int	treeCacheSize,
		int	treeMaxVirtualSize,
		RunHelperBase *	runHelper,
		ProductSelectorRules const &	productSelectorRules,
		InputType	inputType,
		ProcessHistoryRegistry &	processHistoryRegistry,
		std::vector< std::shared_ptr< IndexIntoFile >> const &	indexesIntoFiles,
		std::vector< std::shared_ptr< IndexIntoFile >>::size_type	currentIndexIntoFile,
		std::vector< ProcessHistoryID > &	orderedProcessHistoryIDs,
		bool	bypassVersionCheck,
		bool	enablePrefetching,
		bool	enforceGUIDInFileName
	)

inline

Definition at line 164 of file RootFile.h.

         : RootFile(fileName,
                    processConfiguration,
                    logicalFileName,
                    filePtr,
                    nullptr,
                    false,
                    -1,
                    -1,
                    nStreams,
                    treeCacheSize,
                    treeMaxVirtualSize,
                    InputSource::RunsLumisAndEvents,
                    runHelper,
                    false,
                    false,
                    productSelectorRules,
                    inputType,
                    nullptr,
                    nullptr,
                    nullptr,
                    nullptr,
                    nullptr,
                    false,
                    processHistoryRegistry,
                    indexesIntoFiles,
                    currentIndexIntoFile,
                    orderedProcessHistoryIDs,
                    bypassVersionCheck,
                    false,
                    false,
                    enablePrefetching,
                    enforceGUIDInFileName) {}

◆ ~RootFile()

edm::RootFile::~RootFile ( )

Definition at line 638 of file RootFile.cc.

638 {}

◆ RootFile() [4/4]

edm::RootFile::RootFile ( RootFile const & )

delete

Member Function Documentation

◆ branchChildren() [1/2]

std::shared_ptr<BranchChildren const> edm::RootFile::branchChildren ( ) const

inlineprivate

Definition at line 348 of file RootFile.h.

References branchChildren_, and edm::get_underlying_safe().

Referenced by createFileBlock().

348 { return get_underlying_safe(branchChildren_); }

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

edm::RootFile::branchChildren_

edm::propagate_const< std::shared_ptr< BranchChildren > > branchChildren_

Definition: RootFile.h:406

◆ branchChildren() [2/2]

std::shared_ptr<BranchChildren>& edm::RootFile::branchChildren ( )

inlineprivate

Definition at line 349 of file RootFile.h.

References branchChildren_, and edm::get_underlying_safe().

349 { return get_underlying_safe(branchChildren_); }

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

edm::RootFile::branchChildren_

edm::propagate_const< std::shared_ptr< BranchChildren > > branchChildren_

Definition: RootFile.h:406

◆ branchIDListHelper() [1/2]

std::shared_ptr<BranchIDListHelper const> edm::RootFile::branchIDListHelper ( ) const

inline

Definition at line 280 of file RootFile.h.

References branchIDListHelper_, and edm::get_underlying_safe().

                                                                        {
       return get_underlying_safe(branchIDListHelper_);
     }

◆ branchIDListHelper() [2/2]

std::shared_ptr<BranchIDListHelper>& edm::RootFile::branchIDListHelper ( )

inline

Definition at line 283 of file RootFile.h.

References branchIDListHelper_, and edm::get_underlying_safe().

283 { return get_underlying_safe(branchIDListHelper_); }

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

edm::RootFile::branchIDListHelper_

edm::propagate_const< std::shared_ptr< BranchIDListHelper > > branchIDListHelper_

Definition: RootFile.h:394

◆ branchListIndexesUnchanged()

bool edm::RootFile::branchListIndexesUnchanged ( ) const

inline

Definition at line 248 of file RootFile.h.

References branchListIndexesUnchanged_.

Referenced by createFileBlock().

248 { return branchListIndexesUnchanged_; }

edm::RootFile::branchListIndexesUnchanged_

bool branchListIndexesUnchanged_

Definition: RootFile.h:382

◆ close()

void edm::RootFile::close ( void )

Definition at line 1283 of file RootFile.cc.

References eventHistoryTree_, filePtr_, and treePointers_.

Referenced by esMonitoring.AsyncLineReaderMixin::handle_close(), and esMonitoring.FDJsonServer::handle_close().

                        {
     // Just to play it safe, zero all pointers to objects in the InputFile to be closed.
     eventHistoryTree_ = nullptr;
     for (auto& treePointer : treePointers_) {
       treePointer->close();
       treePointer = nullptr;
     }
     filePtr_->Close();
     filePtr_ = nullptr;  // propagate_const<T> has no reset() function
   }

◆ containsItem()

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

Definition at line 880 of file RootFile.cc.

References edm::IndexIntoFile::containsItem(), indexIntoFile_, and writedatasetfile::run.

                                                                                                       {
     return indexIntoFile_.containsItem(run, lumi, event);
   }

◆ createFileBlock()

std::shared_ptr< FileBlock > edm::RootFile::createFileBlock ( )

Definition at line 766 of file RootFile.cc.

References branchChildren(), branchListIndexesUnchanged(), eventTree_, file_, fileFormatVersion(), hasNewlyDroppedBranch(), lumiTree_, edm::RootTree::metaTree(), modifiedIDs(), eostools::move(), processBlockTrees_, runTree_, edm::RootTree::tree(), and whyNotFastClonable().

                                                      {
     std::vector<TTree*> processBlockTrees;
     std::vector<std::string> processesWithProcessBlockTrees;
     processBlockTrees.reserve(processBlockTrees_.size());
     processesWithProcessBlockTrees.reserve(processBlockTrees_.size());
     for (auto& processBlockTree : processBlockTrees_) {
       processBlockTrees.push_back(processBlockTree->tree());
       processesWithProcessBlockTrees.push_back(processBlockTree->processName());
     }
     return std::make_shared<FileBlock>(fileFormatVersion(),
                                        eventTree_.tree(),
                                        eventTree_.metaTree(),
                                        lumiTree_.tree(),
                                        lumiTree_.metaTree(),
                                        runTree_.tree(),
                                        runTree_.metaTree(),
                                        std::move(processBlockTrees),
                                        std::move(processesWithProcessBlockTrees),
                                        whyNotFastClonable(),
                                        hasNewlyDroppedBranch(),
                                        file_,
                                        branchListIndexesUnchanged(),
                                        modifiedIDs(),
                                        branchChildren());
   }

◆ dropOnInputAndReorder()

void edm::RootFile::dropOnInputAndReorder	(	ProductRegistry &	reg,
		ProductSelectorRules const &	rules,
		bool	dropDescendants,
		InputType	inputType,
		StoredProcessBlockHelper &	storedProcessBlockHelper,
		ProcessBlockHelper const *	processBlockHelper
	)

private

Definition at line 1937 of file RootFile.cc.

References edm::ProductRegistry::allBranchDescriptions(), cms::cuda::assert(), HLT_2022v14_cff::distance, drop, dropProcessesAndReorder(), edProductClass_, file_, fileThinnedAssociationsHelper_, spr::find(), edm::getWrapperBasePtr(), hasNewlyDroppedBranch_, edm::InEvent, edm::ProductSelector::initialize(), edm::InProcess, markBranchToBeDropped(), newBranchToOldBranch(), hltrates_dqm_sourceclient-live_cfg::offset, AlCaHLTBitMon_ParallelJobs::p, edm::Primary, processBlockTrees_, dqmiodatasetharvest::processes, edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), dumpMFGeometry_cfg::prod, edm::ProductRegistry::productListUpdator(), cmsCodeRulesChecker::rules, edm::SecondaryFile, edm::SecondarySource, edm::ProductSelector::selected(), groupFilesInBlocks::temp, and treePointers_.

Referenced by RootFile().

                                                                                      {
     ProductRegistry::ProductList& prodList = reg.productListUpdator();
 
     // First fill in a map we will need to navigate to descendants
     // in the case of EDAliases.
     std::map<BranchID, BranchID> droppedToKeptAlias;
     for (auto const& product : prodList) {
       BranchDescription const& prod = product.second;
       if (prod.branchID() != prod.originalBranchID() && prod.present()) {
         droppedToKeptAlias[prod.originalBranchID()] = prod.branchID();
       }
     }
 
     // This object will select products based on the branchName and the
     // keep and drop statements which are in the source configuration.
     ProductSelector productSelector;
     productSelector.initialize(rules, reg.allBranchDescriptions());
 
     // In this pass, fill in a set of branches to be dropped.
     // Don't drop anything yet.
     std::set<BranchID> branchesToDrop;
     std::vector<BranchDescription const*> associationDescriptions;
     for (auto const& product : prodList) {
       BranchDescription const& prod = product.second;
       if (inputType != InputType::Primary && prod.branchType() == InProcess) {
         markBranchToBeDropped(dropDescendants, prod, branchesToDrop, droppedToKeptAlias);
       } else if (prod.unwrappedType() == typeid(ThinnedAssociation) && prod.present()) {
         // Special handling for ThinnedAssociations
         if (inputType != InputType::SecondarySource) {
           associationDescriptions.push_back(&prod);
         } else {
           markBranchToBeDropped(dropDescendants, prod, branchesToDrop, droppedToKeptAlias);
         }
       } else if (!productSelector.selected(prod)) {
         markBranchToBeDropped(dropDescendants, prod, branchesToDrop, droppedToKeptAlias);
       }
     }
 
     if (inputType != InputType::SecondarySource) {
       // Decide whether to keep the thinned associations and corresponding
       // entries in the helper. For secondary source they are all dropped,
       // but in other cases we look for thinned collections the associations
       // redirect a Ref or Ptr to when dereferencing them.
 
       // Need a list of kept products in order to determine which thinned associations
       // are kept.
       std::set<BranchID> keptProductsInEvent;
       for (auto const& product : prodList) {
         BranchDescription const& prod = product.second;
         if (branchesToDrop.find(prod.branchID()) == branchesToDrop.end() && prod.present() &&
             prod.branchType() == InEvent) {
           keptProductsInEvent.insert(prod.branchID());
         }
       }
 
       // Decide which ThinnedAssociations to keep and store the decision in keepAssociation
       std::map<BranchID, bool> keepAssociation;
       fileThinnedAssociationsHelper_->selectAssociationProducts(
           associationDescriptions, keptProductsInEvent, keepAssociation);
 
       for (auto association : associationDescriptions) {
         if (!keepAssociation[association->branchID()]) {
           markBranchToBeDropped(dropDescendants, *association, branchesToDrop, droppedToKeptAlias);
         }
       }
 
       // Also delete the dropped associations from the ThinnedAssociationsHelper
       auto temp = std::make_unique<ThinnedAssociationsHelper>();
       for (auto const& associationBranches : fileThinnedAssociationsHelper_->data()) {
         auto iter = keepAssociation.find(associationBranches.association());
         if (iter != keepAssociation.end() && iter->second) {
           temp->addAssociation(associationBranches);
         }
       }
       // propagate_const<T> has no reset() function
       fileThinnedAssociationsHelper_ = std::unique_ptr<ThinnedAssociationsHelper>(temp.release());
     }
 
     // On this pass, actually drop the branches.
     std::set<std::string> processesWithKeptProcessBlockProducts;
     std::set<BranchID>::const_iterator branchesToDropEnd = branchesToDrop.end();
     for (ProductRegistry::ProductList::iterator it = prodList.begin(), itEnd = prodList.end(); it != itEnd;) {
       BranchDescription const& prod = it->second;
       bool drop = branchesToDrop.find(prod.branchID()) != branchesToDropEnd;
       if (drop) {
         if (!prod.dropped()) {
           if (productSelector.selected(prod) && prod.unwrappedType() != typeid(ThinnedAssociation) &&
               prod.branchType() != InProcess) {
             LogWarning("RootFile") << "Branch '" << prod.branchName() << "' is being dropped from the input\n"
                                    << "of file '" << file_ << "' because it is dependent on a branch\n"
                                    << "that was explicitly dropped.\n";
           }
           if (prod.branchType() == InProcess) {
             std::vector<std::string> const& processes = storedProcessBlockHelper.processesWithProcessBlockProducts();
             auto it = std::find(processes.begin(), processes.end(), prod.processName());
             assert(it != processes.end());
             auto index = std::distance(processes.begin(), it);
             processBlockTrees_[index]->dropBranch(newBranchToOldBranch(prod.branchName()));
           } else {
             treePointers_[prod.branchType()]->dropBranch(newBranchToOldBranch(prod.branchName()));
           }
           hasNewlyDroppedBranch_[prod.branchType()] = true;
         }
         ProductRegistry::ProductList::iterator icopy = it;
         ++it;
         prodList.erase(icopy);
       } else {
         if (prod.branchType() == InProcess && prod.present()) {
           processesWithKeptProcessBlockProducts.insert(prod.processName());
         }
         ++it;
       }
     }
 
     dropProcessesAndReorder(storedProcessBlockHelper, processesWithKeptProcessBlockProducts, processBlockHelper);
 
     // Drop on input mergeable run and lumi products, this needs to be invoked for secondary file input
     if (inputType == InputType::SecondaryFile) {
       TString tString;
       for (ProductRegistry::ProductList::iterator it = prodList.begin(), itEnd = prodList.end(); it != itEnd;) {
         BranchDescription const& prod = it->second;
         if (prod.present() and prod.branchType() != InEvent and prod.branchType() != InProcess) {
           TClass* cp = prod.wrappedType().getClass();
           void* p = cp->New();
           int offset = cp->GetBaseClassOffset(edProductClass_);
           std::unique_ptr<WrapperBase> edp = getWrapperBasePtr(p, offset);
           if (edp->isMergeable()) {
             treePointers_[prod.branchType()]->dropBranch(newBranchToOldBranch(prod.branchName()));
             ProductRegistry::ProductList::iterator icopy = it;
             ++it;
             prodList.erase(icopy);
           } else {
             ++it;
           }
         } else
           ++it;
       }
     }
   }

◆ dropProcessesAndReorder()

void edm::RootFile::dropProcessesAndReorder	(	StoredProcessBlockHelper &	storedProcessBlockHelper,
		std::set< std::string > const &	processesWithKeptProcessBlockProducts,
		ProcessBlockHelper const *	processBlockHelper
	)

private

Definition at line 2082 of file RootFile.cc.

References edm::ProcessBlockHelper::dropProcessesAndReorderStored(), edm::ProcessBlockHelper::firstFileDropProcessesAndReorderStored(), edm::ProcessBlockHelper::initializedFromInput(), dqmiolumiharvest::j, eostools::move(), processBlockTrees_, edm::ProcessBlockHelperBase::processesWithProcessBlockProducts(), and edm::StoredProcessBlockHelper::processesWithProcessBlockProducts().

Referenced by dropOnInputAndReorder().

                                                                                        {
     // Modify storedProcessBlockHelper and processBlockTrees_
     // This should account for dropOnInput and also make the
     // order of process blocks in input files after the first
     // be the same as the first. Processes with no ProcessBlock
     // products should be removed. After this executes,
     // the items in storedProcessBlockHelper
     // and processBlockTrees should be in exact one to one
     // correspondence and in the same order. For input files
     // after the first, these items should be either the same
     // as or a subset of the items in processBlockHelper and in
     // the same order.
 
     if (processBlockTrees_.empty()) {
       return;
     }
 
     std::vector<unsigned int> nEntries;
     nEntries.reserve(processBlockTrees_.size());
     for (auto const& processBlockTree : processBlockTrees_) {
       nEntries.push_back(processBlockTree->entries());
     }
 
     bool firstInputFile = !processBlockHelper->initializedFromInput();
     bool isModified = false;
     std::vector<unsigned int> finalIndexToStoredIndex;
 
     if (firstInputFile) {
       isModified = processBlockHelper->firstFileDropProcessesAndReorderStored(
           storedProcessBlockHelper, processesWithKeptProcessBlockProducts, nEntries, finalIndexToStoredIndex);
     } else {
       isModified =
           processBlockHelper->dropProcessesAndReorderStored(storedProcessBlockHelper,
                                                             processesWithKeptProcessBlockProducts,
                                                             nEntries,
                                                             finalIndexToStoredIndex,
                                                             processBlockHelper->processesWithProcessBlockProducts());
     }
 
     // At this point, any modifications to storedProcessBlockHelper are done.
     // Make consistent changes to processBlockTrees_ and this will cause
     // unneeded RootTrees to be deleted.
     if (isModified) {
       std::vector<edm::propagate_const<std::unique_ptr<RootTree>>> newProcessBlockTrees;
       unsigned int nFinalProducts = storedProcessBlockHelper.processesWithProcessBlockProducts().size();
       for (unsigned int j = 0; j < nFinalProducts; ++j) {
         unsigned int iStored = finalIndexToStoredIndex[j];
         newProcessBlockTrees.push_back(std::move(processBlockTrees_[iStored]));
       }
       processBlockTrees_.swap(newProcessBlockTrees);
     }
   }

◆ endOfProcessBlocksReached()

bool edm::RootFile::endOfProcessBlocksReached ( ) const

Definition at line 1681 of file RootFile.cc.

References currentProcessBlockTree_, and processBlockTrees_.

Referenced by nextProcessBlock_().

1681 { return currentProcessBlockTree_ >= processBlockTrees_.size(); }

edm::RootFile::currentProcessBlockTree_

unsigned int currentProcessBlockTree_

Definition: RootFile.h:388

edm::RootFile::processBlockTrees_

std::vector< edm::propagate_const< std::unique_ptr< RootTree > > > processBlockTrees_

Definition: RootFile.h:387

◆ eventProductProvenanceRetriever() [1/2]

std::shared_ptr<ProductProvenanceRetriever const> edm::RootFile::eventProductProvenanceRetriever ( size_t index ) const

inlineprivate

Definition at line 351 of file RootFile.h.

References eventProductProvenanceRetrievers_, and edm::get_underlying_safe().

Referenced by makeProductProvenanceRetriever().

                                                                                                         {
       return get_underlying_safe(eventProductProvenanceRetrievers_[index]);
     }

◆ eventProductProvenanceRetriever() [2/2]

std::shared_ptr<ProductProvenanceRetriever>& edm::RootFile::eventProductProvenanceRetriever ( size_t index )

inlineprivate

Definition at line 354 of file RootFile.h.

References eventProductProvenanceRetrievers_, and edm::get_underlying_safe().

                                                                                              {
       return get_underlying_safe(eventProductProvenanceRetrievers_[index]);
     }

◆ eventTree()

RootTree const& edm::RootFile::eventTree ( ) const

inline

Definition at line 242 of file RootFile.h.

References eventTree_.

242 { return eventTree_; }

edm::RootFile::eventTree_

RootTree eventTree_

Definition: RootFile.h:384

◆ file()

std::string const& edm::RootFile::file ( ) const

inline

Definition at line 237 of file RootFile.h.

References file_.

Referenced by RootFile().

237 { return file_; }

edm::RootFile::file_

std::string const file_

Definition: RootFile.h:358

◆ fileFormatVersion()

FileFormatVersion edm::RootFile::fileFormatVersion ( ) const

inline

Definition at line 245 of file RootFile.h.

References fileFormatVersion_.

Referenced by createFileBlock(), fillEventHistory(), fillIndexIntoFile(), fillLumiAuxiliary(), fillRunAuxiliary(), fillThisEventAuxiliary(), readCurrentEvent(), readEventHistoryTree(), readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), RootFile(), setIfFastClonable(), and validateFile().

245 { return fileFormatVersion_; }

edm::RootFile::fileFormatVersion_

FileFormatVersion fileFormatVersion_

Definition: RootFile.h:364

◆ fillEventAuxiliary()

EventAuxiliary edm::RootFile::fillEventAuxiliary ( IndexIntoFile::EntryNumber_t entry )

private

Definition at line 1313 of file RootFile.cc.

References mps_splice::entry, eventTree_, fillThisEventAuxiliary(), and edm::RootTree::setEntryNumber().

Referenced by getNextItemType(), isDuplicateEvent(), readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), setEntryAtNextEventInLumi(), skipEvents(), and skipThisEntry().

                                                                               {
     eventTree_.setEntryNumber(entry);
     return fillThisEventAuxiliary();
   }

◆ fillEventHistory()

bool edm::RootFile::fillEventHistory	(	EventAuxiliary &	evtAux,
		EventSelectionIDVector &	eventSelectionIDs,
		BranchListIndexes &	branchListIndexes,
		bool	assertOnFailure = `true`
	)

private

Definition at line 1338 of file RootFile.cc.

References cms::cuda::assert(), branchIDListHelper_, edm::poolNames::branchListIndexesBranchName(), daqProvenanceHelper_, edm::RootTree::entryNumber(), edm::EventID::event(), edm::errors::EventCorruption, edm::poolNames::eventHistoryBranchName(), edm::FileFormatVersion::eventHistoryTree(), eventHistoryTree_, eventProcessHistoryIDs_, eventProcessHistoryIter_, edm::poolNames::eventSelectionsBranchName(), eventTree_, Exception, fileFormatVersion(), edm::RootTree::fillBranchEntry(), edm::roottree::getEntry(), history_, edm::EventAuxiliary::id(), l1ctLayer2EG_cff::id, edm::lower_bound_all(), edm::FileFormatVersion::noMetaDataTrees(), edm::EventAuxiliary::processHistoryID(), provenanceAdaptor_, edm::EventID::run(), edm::EventAuxiliary::setProcessHistoryID(), edm::FileFormatVersion::splitProductIDs(), filterCSVwithJSON::target, and edm::RootTree::tree().

Referenced by fillIndexIntoFile(), readCurrentEvent(), and readRunAuxiliary_().

                                                         {
     // 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.
     if (fileFormatVersion().eventHistoryBranch()) {
       // Lumi block number was not in EventID for the relevant releases.
       EventID id(evtAux.id().run(), 0, evtAux.id().event());
       if (eventProcessHistoryIter_->eventID() != id) {
         EventProcessHistoryID target(id, ProcessHistoryID());
         eventProcessHistoryIter_ = lower_bound_all(eventProcessHistoryIDs_, target);
         assert(eventProcessHistoryIter_->eventID() == id);
       }
       evtAux.setProcessHistoryID(eventProcessHistoryIter_->processHistoryID());
       ++eventProcessHistoryIter_;
     } else if (fileFormatVersion().eventHistoryTree()) {
       // for backward compatibility.
       History* pHistory = history_.get();
       TBranch* eventHistoryBranch = eventHistoryTree_->GetBranch(poolNames::eventHistoryBranchName().c_str());
       if (!eventHistoryBranch) {
         throw Exception(errors::EventCorruption) << "Failed to find history branch in event history tree.\n";
       }
       eventHistoryBranch->SetAddress(&pHistory);
       roottree::getEntry(eventHistoryTree_, eventTree_.entryNumber());
       evtAux.setProcessHistoryID(history_->processHistoryID());
       eventSelectionIDs.swap(history_->eventSelectionIDs());
       branchListIndexes.swap(history_->branchListIndexes());
     } else if (fileFormatVersion().noMetaDataTrees()) {
       // Current format
       EventSelectionIDVector* pESV = &eventSelectionIDs;
       TBranch* eventSelectionIDBranch = eventTree_.tree()->GetBranch(poolNames::eventSelectionsBranchName().c_str());
       assert(eventSelectionIDBranch != nullptr);
       eventTree_.fillBranchEntry(eventSelectionIDBranch, pESV);
       BranchListIndexes* pBLI = &branchListIndexes;
       TBranch* branchListIndexesBranch = eventTree_.tree()->GetBranch(poolNames::branchListIndexesBranchName().c_str());
       assert(branchListIndexesBranch != nullptr);
       eventTree_.fillBranchEntry(branchListIndexesBranch, pBLI);
     }
     if (provenanceAdaptor_) {
       evtAux.setProcessHistoryID(provenanceAdaptor_->convertID(evtAux.processHistoryID()));
       for (auto& esID : eventSelectionIDs) {
         esID = provenanceAdaptor_->convertID(esID);
       }
     }
     if (daqProvenanceHelper_) {
       evtAux.setProcessHistoryID(daqProvenanceHelper_->mapProcessHistoryID(evtAux.processHistoryID()));
     }
     if (!fileFormatVersion().splitProductIDs()) {
       // old format.  branchListIndexes_ must be filled in from the ProvenanceAdaptor.
       provenanceAdaptor_->branchListIndexes(branchListIndexes);
     }
     if (branchIDListHelper_) {
       return branchIDListHelper_->fixBranchListIndexes(branchListIndexes, assertOnFailure);
     }
     return true;
   }

◆ fillEventToProcessBlockIndexes()

void edm::RootFile::fillEventToProcessBlockIndexes ( )

private

Definition at line 1318 of file RootFile.cc.

References eventToProcessBlockIndexes_, eventToProcessBlockIndexesBranch_, eventTree_, edm::RootTree::fillBranchEntry(), edm::get_underlying_safe(), edm::EventToProcessBlockIndexes::index(), processBlockHelper_, and edm::EventToProcessBlockIndexes::setIndex().

Referenced by readCurrentEvent().

                                                 {
     TBranch* eventToProcessBlockIndexesBranch = get_underlying_safe(eventToProcessBlockIndexesBranch_);
     if (eventToProcessBlockIndexesBranch == nullptr) {
       if (processBlockHelper_.get() == nullptr) {
         eventToProcessBlockIndexes_.setIndex(0);
       } else {
         eventToProcessBlockIndexes_.setIndex(processBlockHelper_->outerOffset());
       }
     } else {
       if (processBlockHelper_->cacheIndexVectorsPerFile().back() == 1u) {
         eventToProcessBlockIndexes_.setIndex(processBlockHelper_->outerOffset());
       } else {
         EventToProcessBlockIndexes* pEventToProcessBlockIndexes = &eventToProcessBlockIndexes_;
         eventTree_.fillBranchEntry(eventToProcessBlockIndexesBranch, pEventToProcessBlockIndexes);
         unsigned int updatedIndex = eventToProcessBlockIndexes_.index() + processBlockHelper_->outerOffset();
         eventToProcessBlockIndexes_.setIndex(updatedIndex);
       }
     }
   }

◆ fillIndexIntoFile()

void edm::RootFile::fillIndexIntoFile ( )

private

Definition at line 996 of file RootFile.cc.

References cms::cuda::assert(), edm::RootTree::entries(), edm::RootTree::entryNumber(), eventTree_, fileFormatVersion(), fillEventHistory(), fillLumiAuxiliary(), fillRunAuxiliary(), fillThisEventAuxiliary(), edm::find_in_all(), indexIntoFile_, edm::IndexIntoFile::invalidEntry, edm::RootTree::isValid(), B2GTnPMonitor_cfi::item, lastEventEntryNumberRead_, edmLumisInFiles::lumis, lumiTree_, eostools::move(), edm::RootTree::next(), processHistoryRegistry_, writedatasetfile::run, writedatasetfile::runs, runTree_, edm::second(), edm::RootTree::setEntryNumber(), edm::IndexIntoFile::setProcessHistoryIDs(), edm::IndexIntoFile::setRunOrLumiEntries(), edm::stable_sort_all(), mitigatedMETSequence_cff::U, and edm::IndexIntoFile::unsortedEventNumbers().

Referenced by validateFile().

                                    {
     // This function is for backward compatibility.
     // If reading a current format file, indexIntoFile_ is read from the input
     // file and should always be there. Note that the algorithm below will work
     // sometimes but often fail with the new format introduced in release 3_8_0.
     // If it ever becomes necessary to rebuild IndexIntoFile from the new format,
     // probably a separate function should be written to deal with the task.
     // This is possible just not implemented yet.
     assert(!fileFormatVersion().hasIndexIntoFile());
 
     typedef std::list<LumiItem> LumiList;
     LumiList lumis;  // (declare 1)
 
     typedef std::set<LuminosityBlockID> RunLumiSet;
     RunLumiSet runLumiSet;  // (declare 2)
 
     typedef std::list<RunItem> RunList;
     RunList runs;  // (declare 5)
 
     typedef std::set<RunNumber_t> RunSet;
     RunSet runSet;  // (declare 4)
 
     typedef std::set<RunItem, RunItemSortByRunPhid> RunItemSet;
     RunItemSet runItemSet;  // (declare 3)
 
     typedef std::map<RunNumber_t, ProcessHistoryID> PHIDMap;
     PHIDMap phidMap;
 
     RunNumber_t prevRun = 0;
     LuminosityBlockNumber_t prevLumi = 0;
     ProcessHistoryID prevPhid;
     bool iFirst = true;
 
     indexIntoFile_.unsortedEventNumbers().clear();  // should already be empty, just being careful
     indexIntoFile_.unsortedEventNumbers().reserve(eventTree_.entries());
 
     // First, loop through the event tree.
     EventSelectionIDVector eventSelectionIDs;
     BranchListIndexes branchListIndexes;
     while (eventTree_.next()) {
       bool newRun = false;
       bool newLumi = false;
       auto evtAux = fillThisEventAuxiliary();
       fillEventHistory(evtAux, eventSelectionIDs, branchListIndexes);
 
       // Save the event numbers as we loop through the event auxiliary to avoid
       // having to read through the event auxiliary again later. These event numbers
       // are not actually used in this function, but could be needed elsewhere.
       indexIntoFile_.unsortedEventNumbers().push_back(evtAux.event());
 
       ProcessHistoryID reducedPHID = processHistoryRegistry_->reducedProcessHistoryID(evtAux.processHistoryID());
 
       if (iFirst || prevPhid != reducedPHID || prevRun != evtAux.run()) {
         iFirst = false;
         newRun = newLumi = true;
       } else if (prevLumi != evtAux.luminosityBlock()) {
         newLumi = true;
       }
       prevPhid = reducedPHID;
       prevRun = evtAux.run();
       prevLumi = evtAux.luminosityBlock();
       if (newLumi) {
         lumis.emplace_back(
             reducedPHID, evtAux.run(), evtAux.luminosityBlock(), eventTree_.entryNumber());  // (insert 1)
         runLumiSet.insert(LuminosityBlockID(evtAux.run(), evtAux.luminosityBlock()));        // (insert 2)
       } else {
         LumiItem& currentLumi = lumis.back();
         assert(currentLumi.lastEventEntry_ == eventTree_.entryNumber());
         ++currentLumi.lastEventEntry_;
       }
       if (newRun) {
         // Insert run in list if it is not already there.
         RunItem item(reducedPHID, evtAux.run());
         if (runItemSet.insert(item).second) {  // (check 3, insert 3)
           runs.push_back(std::move(item));     // (insert 5)
           runSet.insert(evtAux.run());         // (insert 4)
           phidMap.insert(std::make_pair(evtAux.run(), reducedPHID));
         }
       }
     }
     // now clean up.
     eventTree_.setEntryNumber(IndexIntoFile::invalidEntry);
     lastEventEntryNumberRead_ = IndexIntoFile::invalidEntry;
 
     // Loop over run entries and fill information.
 
     typedef std::map<RunNumber_t, IndexIntoFile::EntryNumber_t> RunMap;
     RunMap runMap;  // (declare 11)
 
     typedef std::vector<RunItem> RunVector;
     RunVector emptyRuns;  // (declare 12)
 
     if (runTree_.isValid()) {
       while (runTree_.next()) {
         // Note: adjacent duplicates will be skipped without an explicit check.
 
         std::shared_ptr<RunAuxiliary> runAux = fillRunAuxiliary();
         ProcessHistoryID reducedPHID = processHistoryRegistry_->reducedProcessHistoryID(runAux->processHistoryID());
 
         if (runSet.insert(runAux->run()).second) {  // (check 4, insert 4)
           // This run was not associated with any events.
           emptyRuns.emplace_back(reducedPHID, runAux->run());  // (insert 12)
         }
         runMap.insert(std::make_pair(runAux->run(), runTree_.entryNumber()));  // (insert 11)
         phidMap.insert(std::make_pair(runAux->run(), reducedPHID));
       }
       // now clean up.
       runTree_.setEntryNumber(IndexIntoFile::invalidEntry);
     }
 
     // Insert the ordered empty runs into the run list.
     RunItemSortByRun runItemSortByRun;
     stable_sort_all(emptyRuns, runItemSortByRun);
 
     RunList::iterator itRuns = runs.begin(), endRuns = runs.end();
     for (auto const& emptyRun : emptyRuns) {
       for (; itRuns != endRuns; ++itRuns) {
         if (runItemSortByRun(emptyRun, *itRuns)) {
           break;
         }
       }
       runs.insert(itRuns, emptyRun);
     }
 
     // Loop over luminosity block entries and fill information.
 
     typedef std::vector<LumiItem> LumiVector;
     LumiVector emptyLumis;  // (declare 7)
 
     typedef std::map<LuminosityBlockID, IndexIntoFile::EntryNumber_t> RunLumiMap;
     RunLumiMap runLumiMap;  // (declare 6)
 
     if (lumiTree_.isValid()) {
       while (lumiTree_.next()) {
         // Note: adjacent duplicates will be skipped without an explicit check.
         std::shared_ptr<LuminosityBlockAuxiliary> lumiAux = fillLumiAuxiliary();
         LuminosityBlockID lumiID = LuminosityBlockID(lumiAux->run(), lumiAux->luminosityBlock());
         if (runLumiSet.insert(lumiID).second) {  // (check 2, insert 2)
           // This lumi was not associated with any events.
           // Use the process history ID from the corresponding run.  In cases of practical
           // importance, this should be the correct process history ID,  but it is possible
           // to construct files where this is not the correct process history ID ...
           PHIDMap::const_iterator iPhidMap = phidMap.find(lumiAux->run());
           assert(iPhidMap != phidMap.end());
           emptyLumis.emplace_back(
               iPhidMap->second, lumiAux->run(), lumiAux->luminosityBlock(), IndexIntoFile::invalidEntry);  // (insert 7)
         }
         runLumiMap.insert(std::make_pair(lumiID, lumiTree_.entryNumber()));
       }
       // now clean up.
       lumiTree_.setEntryNumber(IndexIntoFile::invalidEntry);
     }
 
     // Insert the ordered empty lumis into the lumi list.
     LumiItemSortByRunLumi lumiItemSortByRunLumi;
     stable_sort_all(emptyLumis, lumiItemSortByRunLumi);
 
     LumiList::iterator itLumis = lumis.begin(), endLumis = lumis.end();
     for (auto const& emptyLumi : emptyLumis) {
       for (; itLumis != endLumis; ++itLumis) {
         if (lumiItemSortByRunLumi(emptyLumi, *itLumis)) {
           break;
         }
       }
       lumis.insert(itLumis, emptyLumi);
     }
 
     // Create a map of RunItems that gives the order of first appearance in the list.
     // Also fill in the vector of process history IDs
     typedef std::map<RunItem, int, RunItemSortByRunPhid> RunCountMap;
     RunCountMap runCountMap;  // Declare (17)
     std::vector<ProcessHistoryID>& phids = indexIntoFile_.setProcessHistoryIDs();
     assert(phids.empty());
     std::vector<IndexIntoFile::RunOrLumiEntry>& entries = indexIntoFile_.setRunOrLumiEntries();
     assert(entries.empty());
     int rcount = 0;
     for (auto& run : runs) {
       RunCountMap::const_iterator countMapItem = runCountMap.find(run);
       if (countMapItem == runCountMap.end()) {
         countMapItem = runCountMap.insert(std::make_pair(run, rcount)).first;  // Insert (17)
         assert(countMapItem != runCountMap.end());
         ++rcount;
       }
       std::vector<ProcessHistoryID>::const_iterator phidItem = find_in_all(phids, run.phid_);
       if (phidItem == phids.end()) {
         phids.push_back(run.phid_);
         phidItem = phids.end() - 1;
       }
       entries.emplace_back(countMapItem->second,  // use (17)
                            IndexIntoFile::invalidEntry,
                            runMap[run.run_],  // use (11)
                            phidItem - phids.begin(),
                            run.run_,
                            0U,
                            IndexIntoFile::invalidEntry,
                            IndexIntoFile::invalidEntry);
     }
 
     // Create a map of LumiItems that gives the order of first appearance in the list.
     typedef std::map<LumiItem, int, LumiItemSortByRunLumiPhid> LumiCountMap;
     LumiCountMap lumiCountMap;  // Declare (19)
     int lcount = 0;
     for (auto& lumi : lumis) {
       RunCountMap::const_iterator runCountMapItem = runCountMap.find(RunItem(lumi.phid_, lumi.run_));
       assert(runCountMapItem != runCountMap.end());
       LumiCountMap::const_iterator countMapItem = lumiCountMap.find(lumi);
       if (countMapItem == lumiCountMap.end()) {
         countMapItem = lumiCountMap.insert(std::make_pair(lumi, lcount)).first;  // Insert (17)
         assert(countMapItem != lumiCountMap.end());
         ++lcount;
       }
       std::vector<ProcessHistoryID>::const_iterator phidItem = find_in_all(phids, lumi.phid_);
       assert(phidItem != phids.end());
       entries.emplace_back(runCountMapItem->second,
                            countMapItem->second,
                            runLumiMap[LuminosityBlockID(lumi.run_, lumi.lumi_)],
                            phidItem - phids.begin(),
                            lumi.run_,
                            lumi.lumi_,
                            lumi.firstEventEntry_,
                            lumi.lastEventEntry_);
     }
     stable_sort_all(entries);
   }

◆ fillLumiAuxiliary()

std::shared_ptr< LuminosityBlockAuxiliary > edm::RootFile::fillLumiAuxiliary ( )

private

Definition at line 1397 of file RootFile.cc.

References edm::conversion(), daqProvenanceHelper_, fileFormatVersion(), edm::RootTree::fillAux(), lumiTree_, edm::FileFormatVersion::newAuxiliary(), provenanceAdaptor_, and edm::FileFormatVersion::runsAndLumis().

Referenced by fillIndexIntoFile(), and readLuminosityBlockAuxiliary_().

                                                                       {
     auto lumiAuxiliary = std::make_shared<LuminosityBlockAuxiliary>();
     if (fileFormatVersion().newAuxiliary()) {
       LuminosityBlockAuxiliary* pLumiAux = lumiAuxiliary.get();
       lumiTree_.fillAux<LuminosityBlockAuxiliary>(pLumiAux);
     } else {
       LuminosityBlockAux lumiAux;
       LuminosityBlockAux* pLumiAux = &lumiAux;
       lumiTree_.fillAux<LuminosityBlockAux>(pLumiAux);
       conversion(lumiAux, *lumiAuxiliary);
     }
     if (provenanceAdaptor_) {
       lumiAuxiliary->setProcessHistoryID(provenanceAdaptor_->convertID(lumiAuxiliary->processHistoryID()));
     }
     if (daqProvenanceHelper_) {
       lumiAuxiliary->setProcessHistoryID(daqProvenanceHelper_->mapProcessHistoryID(lumiAuxiliary->processHistoryID()));
     }
     if (lumiAuxiliary->luminosityBlock() == 0 && !fileFormatVersion().runsAndLumis()) {
       lumiAuxiliary->id() = LuminosityBlockID(RunNumber_t(1), LuminosityBlockNumber_t(1));
     }
     return lumiAuxiliary;
   }

◆ fillProcessBlockHelper_()

void edm::RootFile::fillProcessBlockHelper_ ( )

Definition at line 1660 of file RootFile.cc.

References cms::cuda::assert(), inputType_, edm::Primary, processBlockHelper_, processBlockTrees_, and storedProcessBlockHelper_.

                                          {
     assert(inputType_ == InputType::Primary);
     std::vector<unsigned int> nEntries;
     nEntries.reserve(processBlockTrees_.size());
     for (auto const& processBlockTree : processBlockTrees_) {
       nEntries.push_back(processBlockTree->entries());
     }
     processBlockHelper_->fillFromPrimaryInput(*storedProcessBlockHelper_, nEntries);
     storedProcessBlockHelper_ =
         std::make_unique<StoredProcessBlockHelper>();  // propagate_const<T> has no reset() function
   }

◆ fillRunAuxiliary()

std::shared_ptr< RunAuxiliary > edm::RootFile::fillRunAuxiliary ( )

private

Definition at line 1420 of file RootFile.cc.

References edm::conversion(), daqProvenanceHelper_, fileFormatVersion(), edm::RootTree::fillAux(), edm::FileFormatVersion::newAuxiliary(), provenanceAdaptor_, and runTree_.

Referenced by fillIndexIntoFile(), and readRunAuxiliary_().

                                                          {
     auto runAuxiliary = std::make_shared<RunAuxiliary>();
     if (fileFormatVersion().newAuxiliary()) {
       RunAuxiliary* pRunAux = runAuxiliary.get();
       runTree_.fillAux<RunAuxiliary>(pRunAux);
     } else {
       RunAux runAux;
       RunAux* pRunAux = &runAux;
       runTree_.fillAux<RunAux>(pRunAux);
       conversion(runAux, *runAuxiliary);
     }
     if (provenanceAdaptor_) {
       runAuxiliary->setProcessHistoryID(provenanceAdaptor_->convertID(runAuxiliary->processHistoryID()));
     }
     if (daqProvenanceHelper_) {
       runAuxiliary->setProcessHistoryID(daqProvenanceHelper_->mapProcessHistoryID(runAuxiliary->processHistoryID()));
     }
     return runAuxiliary;
   }

◆ fillThisEventAuxiliary()

EventAuxiliary const & edm::RootFile::fillThisEventAuxiliary ( )

private

Definition at line 1294 of file RootFile.cc.

References edm::conversion(), edm::RootTree::entryNumber(), eventAuxCache_, eventTree_, fileFormatVersion(), edm::RootTree::fillAux(), lastEventEntryNumberRead_, and edm::FileFormatVersion::newAuxiliary().

Referenced by fillEventAuxiliary(), fillIndexIntoFile(), initializeDuplicateChecker(), and readCurrentEvent().

                                                          {
     if (lastEventEntryNumberRead_ == eventTree_.entryNumber()) {
       // Already read.
       return eventAuxCache_;
     }
     if (fileFormatVersion().newAuxiliary()) {
       EventAuxiliary* pEvAux = &eventAuxCache_;
       eventTree_.fillAux<EventAuxiliary>(pEvAux);
     } else {
       // for backward compatibility.
       EventAux eventAux;
       EventAux* pEvAux = &eventAux;
       eventTree_.fillAux<EventAux>(pEvAux);
       conversion(eventAux, eventAuxCache_);
     }
     lastEventEntryNumberRead_ = eventTree_.entryNumber();
     return eventAuxCache_;
   }

◆ getNextItemType()

IndexIntoFile::EntryType edm::RootFile::getNextItemType	(	RunNumber_t &	run,
		LuminosityBlockNumber_t &	lumi,
		EventNumber_t &	event
	)

Definition at line 884 of file RootFile.cc.

                                                                            {
     // First, account for consecutive skipped entries.
     while (skipThisEntry()) {
       if (indexIntoFileIter_.getEntryType() == IndexIntoFile::kRun) {
         indexIntoFileIter_.advanceToNextRun();
       } else if (indexIntoFileIter_.getEntryType() == IndexIntoFile::kLumi) {
         indexIntoFileIter_.advanceToNextLumiOrRun();
       } else {
         ++indexIntoFileIter_;
       }
     }
     // OK, we have an entry that is not skipped.
     IndexIntoFile::EntryType entryType = indexIntoFileIter_.getEntryType();
     if (entryType == IndexIntoFile::kEnd) {
       return IndexIntoFile::kEnd;
     }
     if (entryType == IndexIntoFile::kRun) {
       run = indexIntoFileIter_.run();
       runHelper_->checkForNewRun(run, indexIntoFileIter_.peekAheadAtLumi());
       return IndexIntoFile::kRun;
     } else if (processingMode_ == InputSource::Runs) {
       indexIntoFileIter_.advanceToNextRun();
       return getNextItemType(run, lumi, event);
     }
     if (entryType == IndexIntoFile::kLumi) {
       run = indexIntoFileIter_.run();
       lumi = indexIntoFileIter_.lumi();
       return IndexIntoFile::kLumi;
     } else if (processingMode_ == InputSource::RunsAndLumis) {
       indexIntoFileIter_.advanceToNextLumiOrRun();
       return getNextItemType(run, lumi, event);
     }
     if (isDuplicateEvent()) {
       ++indexIntoFileIter_;
       return getNextItemType(run, lumi, event);
     }
     run = indexIntoFileIter_.run();
     lumi = indexIntoFileIter_.lumi();
     auto eventAux = fillEventAuxiliary(indexIntoFileIter_.entry());
     event = eventAux.event();
     return IndexIntoFile::kEvent;
   }

◆ goToEvent()

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

Definition at line 1496 of file RootFile.cc.

References duplicateChecker_, edm::IndexIntoFile::end(), edm::IndexIntoFile::entryOrder, edm::EventID::event(), edm::IndexIntoFile::fillEventNumbers(), edm::IndexIntoFile::findPosition(), edm::IndexIntoFile::firstAppearanceOrder, indexIntoFile_, indexIntoFileIter_, edm::EventID::luminosityBlock(), noEventSort_, noRunLumiSort_, edm::IndexIntoFile::numericalOrder, and edm::EventID::run().

                                                  {
     indexIntoFile_.fillEventNumbers();
 
     if (duplicateChecker_) {
       duplicateChecker_->disable();
     }
 
     IndexIntoFile::SortOrder sortOrder = IndexIntoFile::numericalOrder;
     if (noEventSort_)
       sortOrder = IndexIntoFile::firstAppearanceOrder;
     if (noRunLumiSort_) {
       sortOrder = IndexIntoFile::entryOrder;
     }
 
     IndexIntoFile::IndexIntoFileItr iter =
         indexIntoFile_.findPosition(sortOrder, eventID.run(), eventID.luminosityBlock(), eventID.event());
 
     if (iter == indexIntoFile_.end(sortOrder)) {
       return false;
     }
     indexIntoFileIter_ = iter;
     return true;
   }

◆ hasNewlyDroppedBranch()

std::array<bool, NumBranchTypes> const& edm::RootFile::hasNewlyDroppedBranch ( ) const

inline

Definition at line 247 of file RootFile.h.

References hasNewlyDroppedBranch_.

Referenced by createFileBlock().

247 { return hasNewlyDroppedBranch_; }

edm::RootFile::hasNewlyDroppedBranch_

std::array< bool, NumBranchTypes > hasNewlyDroppedBranch_

Definition: RootFile.h:381

◆ indexIntoFileIter()

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileIter ( ) const

Definition at line 819 of file RootFile.cc.

References indexIntoFileIter_.

819 { return indexIntoFileIter_; }

edm::RootFile::indexIntoFileIter_

IndexIntoFile::IndexIntoFileItr indexIntoFileIter_

Definition: RootFile.h:371

◆ indexIntoFileSharedPtr() [1/2]

std::shared_ptr<IndexIntoFile const> edm::RootFile::indexIntoFileSharedPtr ( ) const

inline

Definition at line 284 of file RootFile.h.

References edm::get_underlying_safe(), and indexIntoFileSharedPtr_.

                                                                       {
       return get_underlying_safe(indexIntoFileSharedPtr_);
     }

◆ indexIntoFileSharedPtr() [2/2]

std::shared_ptr<IndexIntoFile>& edm::RootFile::indexIntoFileSharedPtr ( )

inline

Definition at line 287 of file RootFile.h.

References edm::get_underlying_safe(), and indexIntoFileSharedPtr_.

287 { return get_underlying_safe(indexIntoFileSharedPtr_); }

edm::RootFile::indexIntoFileSharedPtr_

edm::propagate_const< std::shared_ptr< IndexIntoFile > > indexIntoFileSharedPtr_

Definition: RootFile.h:366

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

◆ initAssociationsFromSecondary()

void edm::RootFile::initAssociationsFromSecondary ( std::vector< BranchID > const & associationsFromSecondary )

Definition at line 825 of file RootFile.cc.

References fileThinnedAssociationsHelper_, and thinnedAssociationsHelper_.

                                                                                                    {
     thinnedAssociationsHelper_->initAssociationsFromSecondary(associationsFromSecondary,
                                                               *fileThinnedAssociationsHelper_);
   }

◆ initializeDuplicateChecker()

void edm::RootFile::initializeDuplicateChecker	(	std::vector< std::shared_ptr< IndexIntoFile >> const &	indexesIntoFiles,
		std::vector< std::shared_ptr< IndexIntoFile >>::size_type	currentIndexIntoFile
	)

private

Definition at line 1879 of file RootFile.cc.

References duplicateChecker_, eventTree_, fillThisEventAuxiliary(), indexIntoFile_, edm::IndexIntoFile::invalidEntry, edm::RootTree::next(), and edm::RootTree::setEntryNumber().

Referenced by RootFile().

                                                                              {
     if (duplicateChecker_ && !duplicateChecker_->checkDisabled()) {
       if (eventTree_.next()) {
         auto const evtAux = fillThisEventAuxiliary();
 
         duplicateChecker_->inputFileOpened(evtAux.isRealData(), indexIntoFile_, indexesIntoFiles, currentIndexIntoFile);
       }
       eventTree_.setEntryNumber(IndexIntoFile::invalidEntry);
     }
   }

◆ initializeFirstProcessBlockEntry()

bool edm::RootFile::initializeFirstProcessBlockEntry ( )

Definition at line 1672 of file RootFile.cc.

References cms::cuda::assert(), currentProcessBlockTree_, edm::IndexIntoFile::invalidEntry, and processBlockTrees_.

Referenced by nextProcessBlock_().

                                                   {
     if (processBlockTrees_[currentProcessBlockTree_]->entryNumber() == IndexIntoFile::invalidEntry) {
       processBlockTrees_[currentProcessBlockTree_]->setEntryNumber(0);
       assert(processBlockTrees_[currentProcessBlockTree_]->current());
       return true;
     }
     return false;
   }

◆ isDuplicateEvent()

bool edm::RootFile::isDuplicateEvent ( )

private

Definition at line 867 of file RootFile.cc.

References cms::cuda::assert(), duplicateChecker_, edm::IndexIntoFile::IndexIntoFileItr::entry(), file_, fillEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileIter_, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::IndexIntoFileItr::lumi(), edm::IndexIntoFile::IndexIntoFileItr::processHistoryIDIndex(), and edm::IndexIntoFile::IndexIntoFileItr::run().

Referenced by getNextItemType().

                                   {
     assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kEvent);
     if (duplicateChecker_.get() == nullptr) {
       return false;
     }
     auto const eventAux = fillEventAuxiliary(indexIntoFileIter_.entry());
     return duplicateChecker_->isDuplicateAndCheckActive(indexIntoFileIter_.processHistoryIDIndex(),
                                                         indexIntoFileIter_.run(),
                                                         indexIntoFileIter_.lumi(),
                                                         eventAux.id().event(),
                                                         file_);
   }

◆ lumiTree()

RootTree const& edm::RootFile::lumiTree ( ) const

inline

Definition at line 243 of file RootFile.h.

References lumiTree_.

243 { return lumiTree_; }

edm::RootFile::lumiTree_

RootTree lumiTree_

Definition: RootFile.h:385

◆ makeProcessBlockRootTrees()

void edm::RootFile::makeProcessBlockRootTrees	(	std::shared_ptr< InputFile >	filePtr,
		int	treeMaxVirtualSize,
		bool	enablePrefetching,
		InputType	inputType,
		StoredProcessBlockHelper const &	storedProcessBlockHelper
	)

private

Definition at line 2143 of file RootFile.cc.

References edm::roottree::defaultNonEventCacheSize, edm::roottree::defaultNonEventLearningEntries, edm::InProcess, LaserDQM_cfg::process, processBlockTrees_, and edm::StoredProcessBlockHelper::processesWithProcessBlockProducts().

Referenced by RootFile().

                                                                                                      {
     // When this functions returns there will be exactly a 1-to-1 correspondence between the
     // processes listed in storedProcessBlockHelper and the RootTree objects created. processBlockTrees_
     // has pointers to the RootTree's and will be filled in the same order. The RootTree constructor
     // will throw an exception if one of these TTree's is not in the file and this should be all of
     // the ProcessBlock TTree's in the file. (later in the RootFile constructor, dropOnInput might
     // remove some and also reordering may occur).
     for (auto const& process : storedProcessBlockHelper.processesWithProcessBlockProducts()) {
       processBlockTrees_.emplace_back(std::make_unique<RootTree>(filePtr,
                                                                  InProcess,
                                                                  process,
                                                                  1,
                                                                  treeMaxVirtualSize,
                                                                  roottree::defaultNonEventCacheSize,
                                                                  roottree::defaultNonEventLearningEntries,
                                                                  enablePrefetching,
                                                                  inputType));
     }
   }

◆ makeProductProvenanceRetriever()

std::shared_ptr< ProductProvenanceRetriever > edm::RootFile::makeProductProvenanceRetriever ( unsigned int iStreamIndex )

private

Definition at line 2183 of file RootFile.cc.

References daqProvenanceHelper_, eventProductProvenanceRetriever(), eventProductProvenanceRetrievers_, eventTree_, and provenanceReaderMaker_.

Referenced by readCurrentEvent().

                                                                                                            {
     if (eventProductProvenanceRetrievers_.size() <= iStreamID) {
       eventProductProvenanceRetrievers_.resize(iStreamID + 1);
     }
     if (!eventProductProvenanceRetrievers_[iStreamID]) {
       // propagate_const<T> has no reset() function
       eventProductProvenanceRetrievers_[iStreamID] = std::make_shared<ProductProvenanceRetriever>(
           provenanceReaderMaker_->makeReader(eventTree_, daqProvenanceHelper_.get()));
     }
     eventProductProvenanceRetrievers_[iStreamID]->reset();
     return eventProductProvenanceRetriever(iStreamID);
   }

◆ makeProvenanceReaderMaker()

std::unique_ptr< MakeProvenanceReader > edm::RootFile::makeProvenanceReaderMaker ( InputType inputType )

private

Definition at line 2167 of file RootFile.cc.

References fileFormatVersion_, eostools::move(), parentageIDLookup_, edm::FileFormatVersion::perEventProductIDs(), readEntryDescriptionTree(), readParentageTree(), edm::FileFormatVersion::splitProductIDs(), and edm::FileFormatVersion::storedProductProvenanceUsed().

Referenced by RootFile().

                                                                                              {
     if (fileFormatVersion_.storedProductProvenanceUsed()) {
       readParentageTree(inputType);
       return std::make_unique<MakeReducedProvenanceReader>(parentageIDLookup_);
     } else if (fileFormatVersion_.splitProductIDs()) {
       readParentageTree(inputType);
       return std::make_unique<MakeFullProvenanceReader>();
     } else if (fileFormatVersion_.perEventProductIDs()) {
       auto entryDescriptionMap = std::make_unique<EntryDescriptionMap>();
       readEntryDescriptionTree(*entryDescriptionMap, inputType);
       return std::make_unique<MakeOldProvenanceReader>(std::move(entryDescriptionMap));
     } else {
       return std::make_unique<MakeDummyProvenanceReader>();
     }
   }

◆ markBranchToBeDropped()

void edm::RootFile::markBranchToBeDropped	(	bool	dropDescendants,
		BranchDescription const &	branch,
		std::set< BranchID > &	branchesToDrop,
		std::map< BranchID, BranchID > const &	droppedToKeptAlias
	)		const

private

Definition at line 1926 of file RootFile.cc.

References MicroEventContent_cff::branch, and branchChildren_.

Referenced by dropOnInputAndReorder().

                                                                                                    {
     if (dropDescendants) {
       branchChildren_->appendToDescendants(branch, branchesToDrop, droppedToKeptAlias);
     } else {
       branchesToDrop.insert(branch.branchID());
     }
   }

◆ modifiedIDs()

bool edm::RootFile::modifiedIDs ( ) const

inline

Definition at line 249 of file RootFile.h.

References daqProvenanceHelper_.

Referenced by createFileBlock().

249 { return daqProvenanceHelper_.get() != nullptr; }

edm::RootFile::daqProvenanceHelper_

edm::propagate_const< std::unique_ptr< DaqProvenanceHelper > > daqProvenanceHelper_

Definition: RootFile.h:412

◆ newBranchToOldBranch()

std::string const & edm::RootFile::newBranchToOldBranch ( std::string const & newBranch ) const

private

Definition at line 811 of file RootFile.cc.

References newBranchToOldBranch_.

Referenced by dropOnInputAndReorder(), RootFile(), and setPresenceInProductRegistry().

                                                                                   {
     std::map<std::string, std::string>::const_iterator it = newBranchToOldBranch_.find(newBranch);
     if (it != newBranchToOldBranch_.end()) {
       return it->second;
     }
     return newBranch;
   }

◆ nextEventEntry()

bool edm::RootFile::nextEventEntry ( )

inline

Definition at line 278 of file RootFile.h.

References eventTree_, and edm::RootTree::nextWithCache().

278 { return eventTree_.nextWithCache(); }

edm::RootFile::eventTree_

RootTree eventTree_

Definition: RootFile.h:384

edm::RootTree::nextWithCache

bool nextWithCache()

Definition: RootTree.cc:211

◆ nextProcessBlock_()

bool edm::RootFile::nextProcessBlock_ ( ProcessBlockPrincipal & )

Definition at line 1683 of file RootFile.cc.

References cms::cuda::assert(), currentProcessBlockTree_, endOfProcessBlocksReached(), initializeFirstProcessBlockEntry(), inputType_, edm::Primary, and processBlockTrees_.

                                                          {
     assert(inputType_ == InputType::Primary);
     if (endOfProcessBlocksReached()) {
       return false;
     }
     if (initializeFirstProcessBlockEntry()) {
       return true;
     }
     // With the current design, the RootFile should always be
     // set to a valid ProcessBlock entry in one of the TTrees
     // if it not at the end.
     assert(processBlockTrees_[currentProcessBlockTree_]->current());
     // Try for next entry in the same TTree
     if (processBlockTrees_[currentProcessBlockTree_]->nextWithCache()) {
       return true;
     }
     // Next ProcessBlock TTree
     ++currentProcessBlockTree_;
     if (endOfProcessBlocksReached()) {
       return false;
     }
     // With current design there should always be at least one entry.
     // Initialize for that entry.
     processBlockTrees_[currentProcessBlockTree_]->setEntryNumber(0);
     assert(processBlockTrees_[currentProcessBlockTree_]->current());
     return true;
   }

◆ operator=()

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

delete

◆ productRegistry()

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

inline

Definition at line 238 of file RootFile.h.

References productRegistry_.

Referenced by RootFile().

238 { return productRegistry_; }

edm::RootFile::productRegistry_

std::shared_ptr< ProductRegistry const > productRegistry_

Definition: RootFile.h:392

◆ readCurrentEvent()

std::tuple< bool, bool > edm::RootFile::readCurrentEvent	(	EventPrincipal &	cache,
		bool	assertOnFailure = `true`
	)

Definition at line 1547 of file RootFile.cc.

References cms::cuda::assert(), edm::RootTree::current(), daqProvenanceHelper_, eventToProcessBlockIndexes_, eventTree_, fileFormatVersion(), filePtr_, fillEventHistory(), edm::EventPrincipal::fillEventPrincipal(), fillEventToProcessBlockIndexes(), fillThisEventAuxiliary(), newFWLiteAna::found, indexIntoFile_, indexIntoFileIter_, edm::RootTree::insertEntryForIndex(), makeProductProvenanceRetriever(), eostools::move(), edm::IndexIntoFile::processHistoryID(), edm::IndexIntoFile::IndexIntoFileItr::processHistoryIDIndex(), processHistoryRegistry_, edm::RootTree::resetAndGetRootDelayedReader(), runHelper_, edm::EventPrincipal::streamID(), summarizeEdmComparisonLogfiles::succeeded, edm::EDProductGetter::transitionIndex(), edm::FileFormatVersion::useReducedProcessHistoryID(), and edm::StreamID::value().

Referenced by readEvent().

                                                                                                  {
     bool found = true;
     bool succeeded = true;
     if (!eventTree_.current()) {
       found = false;
       return {found, succeeded};
     }
     auto evtAux = fillThisEventAuxiliary();
     if (!fileFormatVersion().lumiInEventID()) {
       //ugly, but will disappear when the backward compatibility is done with schema evolution.
       const_cast<EventID&>(evtAux.id()).setLuminosityBlockNumber(evtAux.oldLuminosityBlock());
       evtAux.resetObsoleteInfo();
     }
     fillEventToProcessBlockIndexes();
     EventSelectionIDVector eventSelectionIDs;
     BranchListIndexes branchListIndexes;
     if (!fillEventHistory(evtAux, eventSelectionIDs, branchListIndexes, assertOnFailure)) {
       succeeded = false;
     }
     runHelper_->overrideRunNumber(evtAux.id(), evtAux.isRealData());
 
     // We're not done ... so prepare the EventPrincipal
     eventTree_.insertEntryForIndex(principal.transitionIndex());
     auto history = processHistoryRegistry_->getMapped(evtAux.processHistoryID());
     principal.fillEventPrincipal(evtAux,
                                  history,
                                  std::move(eventSelectionIDs),
                                  std::move(branchListIndexes),
                                  eventToProcessBlockIndexes_,
                                  *(makeProductProvenanceRetriever(principal.streamID().value())),
                                  eventTree_.resetAndGetRootDelayedReader());
 
     // If this next assert shows up in performance profiling or significantly affects memory, then these three lines should be deleted.
     // The IndexIntoFile should guarantee that it never fails.
     ProcessHistoryID idToCheck = (daqProvenanceHelper_ && fileFormatVersion().useReducedProcessHistoryID()
                                       ? *daqProvenanceHelper_->oldProcessHistoryID()
                                       : evtAux.processHistoryID());
     ProcessHistoryID const& reducedPHID = processHistoryRegistry_->reducedProcessHistoryID(idToCheck);
     assert(reducedPHID == indexIntoFile_.processHistoryID(indexIntoFileIter_.processHistoryIDIndex()));
 
     // report event read from file
     filePtr_->eventReadFromFile();
     return {found, succeeded};
   }

◆ readEntryDescriptionTree()

void edm::RootFile::readEntryDescriptionTree	(	EntryDescriptionMap &	entryDescriptionMap,
		InputType	inputType
	)

private

Definition at line 640 of file RootFile.cc.

References daqProvenanceHelper_, edm::poolNames::entryDescriptionBranchName(), edm::poolNames::entryDescriptionIDBranchName(), edm::poolNames::entryDescriptionTreeName(), edm::errors::EventCorruption, Exception, filePtr_, edm::errors::FileReadError, edm::roottree::getEntry(), mps_fire::i, edm::EventEntryDescription::id(), edm::ParentageRegistry::insertMapped(), edm::ParentageRegistry::instance(), edm::numEntries(), parents, edm::EventEntryDescription::parents(), and edm::SecondarySource.

Referenced by makeProvenanceReaderMaker().

                                                                                                        {
     // Called only for old format files.
     // We use a smart pointer so the tree will be deleted after use, and not kept for the life of the file.
     std::unique_ptr<TTree> entryDescriptionTree(
         dynamic_cast<TTree*>(filePtr_->Get(poolNames::entryDescriptionTreeName().c_str())));
     if (nullptr == entryDescriptionTree.get()) {
       throw Exception(errors::FileReadError)
           << "Could not find tree " << poolNames::entryDescriptionTreeName() << " in the input file.\n";
     }
 
     EntryDescriptionID idBuffer;
     EntryDescriptionID* pidBuffer = &idBuffer;
     entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionIDBranchName().c_str(), &pidBuffer);
 
     EventEntryDescription entryDescriptionBuffer;
     EventEntryDescription* pEntryDescriptionBuffer = &entryDescriptionBuffer;
     entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionBranchName().c_str(), &pEntryDescriptionBuffer);
 
     // Fill in the parentage registry.
     ParentageRegistry& registry = *ParentageRegistry::instance();
 
     for (Long64_t i = 0, numEntries = entryDescriptionTree->GetEntries(); i < numEntries; ++i) {
       roottree::getEntry(entryDescriptionTree.get(), i);
       if (idBuffer != entryDescriptionBuffer.id()) {
         throw Exception(errors::EventCorruption) << "Corruption of EntryDescription tree detected.\n";
       }
       entryDescriptionMap.insert(std::make_pair(entryDescriptionBuffer.id(), entryDescriptionBuffer));
       Parentage parents;
       parents.setParents(entryDescriptionBuffer.parents());
       if (daqProvenanceHelper_) {
         ParentageID const oldID = parents.id();
         daqProvenanceHelper_->fixMetaData(parents.parentsForUpdate());
         ParentageID newID = parents.id();
         if (newID != oldID) {
           daqProvenanceHelper_->setOldParentageIDToNew(oldID, newID);
         }
       }
       // For thread safety, don't update global registries when a secondary source opens a file.
       if (inputType != InputType::SecondarySource) {
         registry.insertMapped(parents);
       }
     }
     entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionIDBranchName().c_str(), nullptr);
     entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionBranchName().c_str(), nullptr);
   }

◆ readEvent()

bool edm::RootFile::readEvent ( EventPrincipal & cache )

Definition at line 1532 of file RootFile.cc.

References cms::cuda::assert(), edm::EventPrincipal::aux(), newFWLiteAna::found, edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::IndexIntoFileItr::lumi(), readCurrentEvent(), edm::IndexIntoFile::IndexIntoFileItr::run(), runHelper_, and summarizeEdmComparisonLogfiles::succeeded.

                                                     {
     assert(indexIntoFileIter_ != indexIntoFileEnd_);
     assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kEvent);
     // read the event
     auto [found, succeeded] = readCurrentEvent(principal, false);
     auto const& evtAux = principal.aux();
 
     runHelper_->checkRunConsistency(evtAux.run(), indexIntoFileIter_.run());
     runHelper_->checkLumiConsistency(evtAux.luminosityBlock(), indexIntoFileIter_.lumi());
 
     ++indexIntoFileIter_;
     return succeeded;
   }

◆ readEventHistoryTree()

void edm::RootFile::readEventHistoryTree ( )

private

Definition at line 1868 of file RootFile.cc.

References edm::errors::EventCorruption, eventHistoryTree_, edm::poolNames::eventHistoryTreeName(), Exception, fileFormatVersion(), filePtr_, and history_.

Referenced by RootFile().

                                       {
     // Read in the event history tree, if we have one...
     if (fileFormatVersion().eventHistoryTree()) {
       history_ = std::make_unique<History>();  // propagate_const<T> has no reset() function
       eventHistoryTree_ = dynamic_cast<TTree*>(filePtr_->Get(poolNames::eventHistoryTreeName().c_str()));
       if (!eventHistoryTree_) {
         throw Exception(errors::EventCorruption) << "Failed to find the event history tree.\n";
       }
     }
   }

◆ readFakeRun_()

void edm::RootFile::readFakeRun_ ( RunPrincipal & runPrincipal )

◆ readFakeRunAuxiliary_()

std::shared_ptr<RunAuxiliary> edm::RootFile::readFakeRunAuxiliary_ ( )

◆ readLuminosityBlock_()

bool edm::RootFile::readLuminosityBlock_ ( LuminosityBlockPrincipal & lumiPrincipal )

Definition at line 1797 of file RootFile.cc.

References cms::cuda::assert(), edm::LuminosityBlockPrincipal::aux(), edm::IndexIntoFile::IndexIntoFileItr::entry(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::RootTree::insertEntryForIndex(), edm::RootTree::isValid(), edm::IndexIntoFile::kLumi, edm::LuminosityBlockPrincipal::kNo, edm::LuminosityBlockPrincipal::kYes, lumiTree_, edm::LuminosityBlockAuxiliary::processHistoryID(), processHistoryRegistry_, edm::Principal::readAllFromSourceAndMergeImmediately(), edm::RootTree::resetAndGetRootDelayedReader(), edm::RootTree::setEntryNumber(), edm::LuminosityBlockPrincipal::setShouldWriteLumi(), edm::IndexIntoFile::IndexIntoFileItr::shouldProcessLumi(), and edm::LuminosityBlockPrincipal::shouldWriteLumi().

                                                                              {
     bool shouldProcessLumi = indexIntoFileIter_.shouldProcessLumi();
     assert(indexIntoFileIter_ != indexIntoFileEnd_);
     assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kLumi);
     // Begin code for backward compatibility before the existence of lumi trees.
     if (!lumiTree_.isValid()) {
       ++indexIntoFileIter_;
       return shouldProcessLumi;
     }
     // End code for backward compatibility before the existence of lumi trees.
     if (shouldProcessLumi) {
       lumiTree_.setEntryNumber(indexIntoFileIter_.entry());
       // NOTE: we use 0 for the index since do not do delayed reads for LuminosityBlockPrincipals
       lumiTree_.insertEntryForIndex(0);
       auto history = processHistoryRegistry_->getMapped(lumiPrincipal.aux().processHistoryID());
       lumiPrincipal.fillLuminosityBlockPrincipal(history, lumiTree_.resetAndGetRootDelayedReader());
       // Read in all the products now.
       lumiPrincipal.readAllFromSourceAndMergeImmediately();
       lumiPrincipal.setShouldWriteLumi(LuminosityBlockPrincipal::kYes);
     } else {
       auto history = processHistoryRegistry_->getMapped(lumiPrincipal.aux().processHistoryID());
       lumiPrincipal.fillLuminosityBlockPrincipal(history, nullptr);
       if (lumiPrincipal.shouldWriteLumi() != LuminosityBlockPrincipal::kYes) {
         lumiPrincipal.setShouldWriteLumi(LuminosityBlockPrincipal::kNo);
       }
     }
     ++indexIntoFileIter_;
     return shouldProcessLumi;
   }

◆ readLuminosityBlockAuxiliary_()

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

Definition at line 1759 of file RootFile.cc.

References cms::cuda::assert(), edm::RootTree::current(), edm::IndexIntoFile::IndexIntoFileItr::entry(), eventTree_, fileFormatVersion(), filePtr_, fillEventAuxiliary(), fillLumiAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::firstEventEntryThisLumi(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::IndexIntoFile::invalidEntry, edm::Timestamp::invalidTimestamp(), edm::RootTree::isValid(), edm::IndexIntoFile::kLumi, edm::IndexIntoFile::IndexIntoFileItr::lumi(), lumiTree_, edm::IndexIntoFile::IndexIntoFileItr::run(), runHelper_, savedRunAuxiliary_, and edm::RootTree::setEntryNumber().

                                                                                   {
     assert(indexIntoFileIter_ != indexIntoFileEnd_);
     assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kLumi);
     // Begin code for backward compatibility before the existence of lumi trees.
     if (!lumiTree_.isValid()) {
       IndexIntoFile::EntryNumber_t eventEntry = indexIntoFileIter_.firstEventEntryThisLumi();
       assert(eventEntry != IndexIntoFile::invalidEntry);
       assert(eventTree_.current(eventEntry));
       auto const evtAux = fillEventAuxiliary(eventEntry);
 
       LuminosityBlockID lumi = LuminosityBlockID(indexIntoFileIter_.run(), indexIntoFileIter_.lumi());
       runHelper_->overrideRunNumber(lumi);
       return std::make_shared<LuminosityBlockAuxiliary>(
           lumi.run(), lumi.luminosityBlock(), evtAux.time(), Timestamp::invalidTimestamp());
     }
     // End code for backward compatibility before the existence of lumi trees.
     lumiTree_.setEntryNumber(indexIntoFileIter_.entry());
     std::shared_ptr<LuminosityBlockAuxiliary> lumiAuxiliary = fillLumiAuxiliary();
     assert(lumiAuxiliary->run() == indexIntoFileIter_.run());
     assert(lumiAuxiliary->luminosityBlock() == indexIntoFileIter_.lumi());
     runHelper_->overrideRunNumber(lumiAuxiliary->id());
     filePtr_->reportInputLumiSection(lumiAuxiliary->run(), lumiAuxiliary->luminosityBlock());
     if (lumiAuxiliary->beginTime() == Timestamp::invalidTimestamp()) {
       IndexIntoFile::EntryNumber_t eventEntry = indexIntoFileIter_.firstEventEntryThisLumi();
       if (eventEntry != IndexIntoFile::invalidEntry) {
         assert(eventTree_.current(eventEntry));
         auto const evtAux = fillEventAuxiliary(eventEntry);
 
         lumiAuxiliary->setBeginTime(evtAux.time());
       }
       lumiAuxiliary->setEndTime(Timestamp::invalidTimestamp());
     }
     if (!fileFormatVersion().processHistorySameWithinRun() && savedRunAuxiliary_) {
       lumiAuxiliary->setProcessHistoryID(savedRunAuxiliary_->processHistoryID());
     }
     return lumiAuxiliary;
   }

◆ readParentageTree()

void edm::RootFile::readParentageTree ( InputType inputType )

private

Definition at line 686 of file RootFile.cc.

References daqProvenanceHelper_, Exception, filePtr_, edm::errors::FileReadError, edm::roottree::getEntry(), mps_fire::i, edm::ParentageRegistry::insertMapped(), edm::ParentageRegistry::instance(), edm::numEntries(), edm::poolNames::parentageBranchName(), parentageIDLookup_, edm::poolNames::parentageTreeName(), parents, and edm::SecondarySource.

Referenced by makeProvenanceReaderMaker().

                                                       {
     // New format file
     // We use a smart pointer so the tree will be deleted after use, and not kept for the life of the file.
     std::unique_ptr<TTree> parentageTree(dynamic_cast<TTree*>(filePtr_->Get(poolNames::parentageTreeName().c_str())));
     if (nullptr == parentageTree.get()) {
       throw Exception(errors::FileReadError)
           << "Could not find tree " << poolNames::parentageTreeName() << " in the input file.\n";
     }
 
     Parentage parents;
     Parentage* pParentageBuffer = &parents;
     parentageTree->SetBranchAddress(poolNames::parentageBranchName().c_str(), &pParentageBuffer);
 
     ParentageRegistry& registry = *ParentageRegistry::instance();
 
     parentageIDLookup_.reserve(parentageTree->GetEntries());
     for (Long64_t i = 0, numEntries = parentageTree->GetEntries(); i < numEntries; ++i) {
       roottree::getEntry(parentageTree.get(), i);
       if (daqProvenanceHelper_) {
         ParentageID const oldID = parents.id();
         daqProvenanceHelper_->fixMetaData(parents.parentsForUpdate());
         ParentageID newID = parents.id();
         if (newID != oldID) {
           daqProvenanceHelper_->setOldParentageIDToNew(oldID, newID);
         }
       }
       // For thread safety, don't update global registries when a secondary source opens a file.
       if (inputType != InputType::SecondarySource) {
         registry.insertMapped(parents);
       }
       parentageIDLookup_.push_back(parents.id());
     }
     parentageTree->SetBranchAddress(poolNames::parentageBranchName().c_str(), nullptr);
   }

◆ readProcessBlock_()

void edm::RootFile::readProcessBlock_ ( ProcessBlockPrincipal & processBlockPrincipal )

Definition at line 1711 of file RootFile.cc.

References cms::cuda::assert(), currentProcessBlockTree_, edm::ProcessBlockPrincipal::fillProcessBlockPrincipal(), inputType_, edm::RootTree::insertEntryForIndex(), edm::Primary, processBlockTrees_, edm::RootTree::processName(), and edm::RootTree::resetAndGetRootDelayedReader().

                                                                                {
     assert(inputType_ == InputType::Primary);
     RootTree* rootTree = processBlockTrees_[currentProcessBlockTree_].get();
     rootTree->insertEntryForIndex(0);
     assert(!rootTree->processName().empty());
     processBlockPrincipal.fillProcessBlockPrincipal(rootTree->processName(), rootTree->resetAndGetRootDelayedReader());
   }

◆ readRun_()

bool edm::RootFile::readRun_ ( RunPrincipal & runPrincipal )

Definition at line 1719 of file RootFile.cc.

References cms::cuda::assert(), edm::RootTree::entryNumber(), edm::RunPrincipal::fillRunPrincipal(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, inputType_, edm::RootTree::insertEntryForIndex(), edm::RootTree::isValid(), edm::RunPrincipal::kNo, edm::IndexIntoFile::kRun, edm::RunPrincipal::kYes, edm::RunPrincipal::mergeableRunProductMetadata(), edm::Primary, processHistoryRegistry_, edm::Principal::readAllFromSourceAndMergeImmediately(), edm::MergeableRunProductMetadata::readRun(), edm::RootTree::resetAndGetRootDelayedReader(), runHelper_, runTree_, edm::RunPrincipal::setShouldWriteRun(), edm::IndexIntoFile::IndexIntoFileItr::shouldProcessRun(), edm::RunPrincipal::shouldWriteRun(), and storedMergeableRunProductMetadata_.

                                                     {
     bool shouldProcessRun = indexIntoFileIter_.shouldProcessRun();
 
     MergeableRunProductMetadata* mergeableRunProductMetadata = nullptr;
     if (shouldProcessRun) {
       if (inputType_ == InputType::Primary) {
         mergeableRunProductMetadata = runPrincipal.mergeableRunProductMetadata();
         RootTree::EntryNumber const& entryNumber = runTree_.entryNumber();
         assert(entryNumber >= 0);
         mergeableRunProductMetadata->readRun(
             entryNumber, *storedMergeableRunProductMetadata_, IndexIntoFileItrHolder(indexIntoFileIter_));
       }
     }
 
     if (!runHelper_->fakeNewRun()) {
       assert(indexIntoFileIter_ != indexIntoFileEnd_);
       assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kRun);
       ++indexIntoFileIter_;
     }
     // Begin code for backward compatibility before the existence of run trees.
     if (!runTree_.isValid()) {
       return shouldProcessRun;
     }
     // End code for backward compatibility before the existence of run trees.
     if (shouldProcessRun) {
       // NOTE: we use 0 for the index since do not do delayed reads for RunPrincipals
       runTree_.insertEntryForIndex(0);
       runPrincipal.fillRunPrincipal(*processHistoryRegistry_, runTree_.resetAndGetRootDelayedReader());
       // Read in all the products now.
       runPrincipal.readAllFromSourceAndMergeImmediately(mergeableRunProductMetadata);
       runPrincipal.setShouldWriteRun(RunPrincipal::kYes);
     } else {
       runPrincipal.fillRunPrincipal(*processHistoryRegistry_, nullptr);
       if (runPrincipal.shouldWriteRun() != RunPrincipal::kYes) {
         runPrincipal.setShouldWriteRun(RunPrincipal::kNo);
       }
     }
     return shouldProcessRun;
   }

◆ readRunAuxiliary_()

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

Definition at line 1594 of file RootFile.cc.

References cms::cuda::assert(), edm::RootTree::current(), edm::IndexIntoFile::IndexIntoFileItr::entry(), eventTree_, fileFormatVersion(), filePtr_, fillEventAuxiliary(), fillEventHistory(), fillRunAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::firstEventEntryThisRun(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::IndexIntoFile::invalidEntry, edm::Timestamp::invalidTimestamp(), edm::RootTree::isValid(), edm::IndexIntoFile::kRun, edm::FileFormatVersion::processHistorySameWithinRun(), writedatasetfile::run, edm::IndexIntoFile::IndexIntoFileItr::run(), runHelper_, runTree_, savedRunAuxiliary(), savedRunAuxiliary_, and edm::RootTree::setEntryNumber().

                                                           {
     if (runHelper_->fakeNewRun()) {
       auto runAuxiliary = std::make_shared<RunAuxiliary>(*savedRunAuxiliary());
       runHelper_->overrideRunNumber(runAuxiliary->id());
       return runAuxiliary;
     }
     assert(indexIntoFileIter_ != indexIntoFileEnd_);
     assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kRun);
 
     // Begin code for backward compatibility before the existence of run trees.
     if (!runTree_.isValid()) {
       // prior to the support of run trees.
       // RunAuxiliary did not contain a valid timestamp.  Take it from the next event.
       IndexIntoFile::EntryNumber_t eventEntry = indexIntoFileIter_.firstEventEntryThisRun();
       assert(eventEntry != IndexIntoFile::invalidEntry);
       assert(eventTree_.current(eventEntry));
       auto const evtAux = fillEventAuxiliary(eventEntry);
 
       RunID run = RunID(indexIntoFileIter_.run());
       runHelper_->overrideRunNumber(run);
       savedRunAuxiliary_ = std::make_shared<RunAuxiliary>(run.run(), evtAux.time(), Timestamp::invalidTimestamp());
       return savedRunAuxiliary();
     }
     // End code for backward compatibility before the existence of run trees.
     runTree_.setEntryNumber(indexIntoFileIter_.entry());
     std::shared_ptr<RunAuxiliary> runAuxiliary = fillRunAuxiliary();
     assert(runAuxiliary->run() == indexIntoFileIter_.run());
     runHelper_->overrideRunNumber(runAuxiliary->id());
     filePtr_->reportInputRunNumber(runAuxiliary->run());
     // If RunAuxiliary did not contain a valid begin timestamp, invalidate any end timestamp.
     if (runAuxiliary->beginTime() == Timestamp::invalidTimestamp()) {
       runAuxiliary->setEndTime(Timestamp::invalidTimestamp());
     }
 
     // If RunAuxiliary did not contain a valid timestamp, or if this an old format file from
     // when the Run's ProcessHistory included only processes where products were added to the Run itself,
     // we attempt to read the first event in the run to get appropriate info.
     if (runAuxiliary->beginTime() == Timestamp::invalidTimestamp() ||
         !fileFormatVersion().processHistorySameWithinRun()) {
       IndexIntoFile::EntryNumber_t eventEntry = indexIntoFileIter_.firstEventEntryThisRun();
       // If we have a valid event, use its information.
       if (eventEntry != IndexIntoFile::invalidEntry) {
         assert(eventTree_.current(eventEntry));
         auto evtAux = fillEventAuxiliary(eventEntry);
 
         // RunAuxiliary did not contain a valid timestamp.  Take it from the next event in this run if there is one.
         if (runAuxiliary->beginTime() == Timestamp::invalidTimestamp()) {
           runAuxiliary->setBeginTime(evtAux.time());
         }
 
         // For backwards compatibility when the Run's ProcessHistory included only processes where products were added to the
         // Run, and then the Run and Event auxiliaries could be different.  Use the event ProcessHistoryID if there is one. It should
         // almost always be correct by the current definition (processes included if any products are added. This makes the run, lumi,
         // and event ProcessHistory's always be the same if no file merging occurs).
         if (!fileFormatVersion().processHistorySameWithinRun()) {
           EventSelectionIDVector eventSelectionIDs;
           BranchListIndexes branchListIndexes;
           fillEventHistory(evtAux, eventSelectionIDs, branchListIndexes);
           runAuxiliary->setProcessHistoryID(evtAux.processHistoryID());
         }
       }
     }
     savedRunAuxiliary_ = runAuxiliary;
     return runAuxiliary;
   }

◆ reportOpened()

void edm::RootFile::reportOpened ( std::string const & inputType )

Definition at line 1276 of file RootFile.cc.

References edm::RootTree::branchNames(), eventTree_, edm::FileID::fid(), fid_, filePtr_, label, logicalFile_, edm::moduleName(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                         {
     // Report file opened.
     std::string const label = "source";
     std::string moduleName = "PoolSource";
     filePtr_->inputFileOpened(logicalFile_, inputType, moduleName, label, fid_.fid(), eventTree_.branchNames());
   }

◆ rewind()

void edm::RootFile::rewind ( )

inline

Definition at line 263 of file RootFile.h.

References currentProcessBlockTree_, eventTree_, indexIntoFileBegin_, indexIntoFileIter_, lumiTree_, processBlockTrees_, edm::RootTree::rewind(), and runTree_.

                   {
       indexIntoFileIter_ = indexIntoFileBegin_;
       eventTree_.rewind();
       lumiTree_.rewind();
       runTree_.rewind();
       currentProcessBlockTree_ = 0;
       for (auto& processBlockTree : processBlockTrees_) {
         processBlockTree->rewindToInvalid();
       }
     }

◆ runTree()

RootTree const& edm::RootFile::runTree ( ) const

inline

Definition at line 244 of file RootFile.h.

References runTree_.

Referenced by validateFile().

244 { return runTree_; }

edm::RootFile::runTree_

RootTree runTree_

Definition: RootFile.h:386

◆ savedRunAuxiliary() [1/2]

std::shared_ptr<RunAuxiliary const> edm::RootFile::savedRunAuxiliary ( ) const

inlineprivate

Definition at line 345 of file RootFile.h.

References edm::get_underlying_safe(), and savedRunAuxiliary_.

Referenced by readRunAuxiliary_().

345 { return get_underlying_safe(savedRunAuxiliary_); }

edm::RootFile::savedRunAuxiliary_

edm::propagate_const< std::shared_ptr< RunAuxiliary > > savedRunAuxiliary_

Definition: RootFile.h:375

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

◆ savedRunAuxiliary() [2/2]

std::shared_ptr<RunAuxiliary>& edm::RootFile::savedRunAuxiliary ( )

inlineprivate

Definition at line 346 of file RootFile.h.

References edm::get_underlying_safe(), and savedRunAuxiliary_.

346 { return get_underlying_safe(savedRunAuxiliary_); }

edm::RootFile::savedRunAuxiliary_

edm::propagate_const< std::shared_ptr< RunAuxiliary > > savedRunAuxiliary_

Definition: RootFile.h:375

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

◆ setAtEventEntry()

void edm::RootFile::setAtEventEntry ( IndexIntoFile::EntryNumber_t entry )

Definition at line 1592 of file RootFile.cc.

References mps_splice::entry, eventTree_, and edm::RootTree::setEntryNumber().

1592 { eventTree_.setEntryNumber(entry); }

mps_splice.entry

entry

Definition: mps_splice.py:68

edm::RootFile::eventTree_

RootTree eventTree_

Definition: RootFile.h:384

edm::RootTree::setEntryNumber

void setEntryNumber(EntryNumber theEntryNumber)

Definition: RootTree.cc:219

◆ setEntryAtEvent()

bool edm::RootFile::setEntryAtEvent	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)

Definition at line 1827 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), eventTree_, edm::IndexIntoFile::findEventPosition(), indexIntoFile_, indexIntoFileEnd_, indexIntoFileIter_, writedatasetfile::run, and edm::RootTree::setEntryNumber().

Referenced by setEntryAtItem().

                                                                                                    {
     indexIntoFileIter_ = indexIntoFile_.findEventPosition(run, lumi, event);
     if (indexIntoFileIter_ == indexIntoFileEnd_)
       return false;
     eventTree_.setEntryNumber(indexIntoFileIter_.entry());
     return true;
   }

◆ setEntryAtItem()

bool edm::RootFile::setEntryAtItem	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)

inline

Definition at line 253 of file RootFile.h.

References writedatasetfile::run, setEntryAtEvent(), setEntryAtLumi(), and setEntryAtRun().

                                                                                             {
       return (event != 0) ? setEntryAtEvent(run, lumi, event) : (lumi ? setEntryAtLumi(run, lumi) : setEntryAtRun(run));
     }

◆ setEntryAtLumi()

bool edm::RootFile::setEntryAtLumi	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)

Definition at line 1835 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), edm::IndexIntoFile::findLumiPosition(), indexIntoFile_, indexIntoFileEnd_, indexIntoFileIter_, lumiTree_, writedatasetfile::run, and edm::RootTree::setEntryNumber().

Referenced by setEntryAtItem().

                                                                              {
     indexIntoFileIter_ = indexIntoFile_.findLumiPosition(run, lumi);
     if (indexIntoFileIter_ == indexIntoFileEnd_)
       return false;
     lumiTree_.setEntryNumber(indexIntoFileIter_.entry());
     return true;
   }

◆ setEntryAtNextEventInLumi()

bool edm::RootFile::setEntryAtNextEventInLumi	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)

Definition at line 1851 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToEvent(), edm::IndexIntoFile::IndexIntoFileItr::entry(), fillEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileIter_, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::IndexIntoFileItr::lumi(), writedatasetfile::run, and edm::IndexIntoFile::IndexIntoFileItr::run().

                                                                                         {
     if (indexIntoFileIter_.getEntryType() == IndexIntoFile::kEvent) {
       ++indexIntoFileIter_;
     }
     indexIntoFileIter_.advanceToEvent();
     if (indexIntoFileIter_.getEntryType() != IndexIntoFile::kEvent)
       return false;
     if (run != indexIntoFileIter_.run())
       return false;
     if (lumi != indexIntoFileIter_.lumi())
       return false;
     //The following is used for its side effect of advancing the
     // eventTree entry.
     fillEventAuxiliary(indexIntoFileIter_.entry());
     return true;
   }

◆ setEntryAtRun()

bool edm::RootFile::setEntryAtRun ( RunNumber_t run )

Definition at line 1843 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), edm::IndexIntoFile::findRunPosition(), indexIntoFile_, indexIntoFileEnd_, indexIntoFileIter_, writedatasetfile::run, runTree_, and edm::RootTree::setEntryNumber().

Referenced by setEntryAtItem().

                                               {
     indexIntoFileIter_ = indexIntoFile_.findRunPosition(run);
     if (indexIntoFileIter_ == indexIntoFileEnd_)
       return false;
     runTree_.setEntryNumber(indexIntoFileIter_.entry());
     return true;
   }

◆ setIfFastClonable()

void edm::RootFile::setIfFastClonable	(	int	remainingEvents,
		int	remainingLumis
	)

private

Definition at line 721 of file RootFile.cc.

References duplicateChecker_, edm::FileBlock::DuplicateEventsRemoved, edm::RootTree::entries(), edm::IndexIntoFile::entryOrder, edm::FileBlock::EventsToBeSorted, eventTree_, fileFormatVersion(), edm::FileBlock::FileTooOld, edm::IndexIntoFile::firstAppearanceOrder, edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFile_, indexIntoFileBegin_, indexIntoFileEnd_, edm::FileBlock::InitialEventsSkipped, edm::IndexIntoFile::iterationWillBeInEntryOrder(), edm::IndexIntoFile::kEvent, lumiTree_, edm::FileBlock::MaxEventsTooSmall, edm::FileBlock::MaxLumisTooSmall, edm::FileBlock::NoEventsInFile, noEventSort_, noRunLumiSort_, edm::FileBlock::NotProcessingEvents, edm::IndexIntoFile::numericalOrder, processingMode_, edm::FileBlock::RunOrLumiNotContiguous, edm::InputSource::RunsLumisAndEvents, skipAnyEvents_, and whyNotFastClonable_.

Referenced by RootFile().

                                                                           {
     if (fileFormatVersion().noMetaDataTrees() and !fileFormatVersion().storedProductProvenanceUsed()) {
       //we must avoid copying the old branch which stored the per product per event provenance
       whyNotFastClonable_ += FileBlock::FileTooOld;
       return;
     }
     if (!fileFormatVersion().splitProductIDs()) {
       whyNotFastClonable_ += FileBlock::FileTooOld;
       return;
     }
     if (processingMode_ != InputSource::RunsLumisAndEvents) {
       whyNotFastClonable_ += FileBlock::NotProcessingEvents;
       return;
     }
     // Find entry for first event in file
     IndexIntoFile::IndexIntoFileItr it = indexIntoFileBegin_;
     while (it != indexIntoFileEnd_ && it.getEntryType() != IndexIntoFile::kEvent) {
       ++it;
     }
     if (it == indexIntoFileEnd_) {
       whyNotFastClonable_ += FileBlock::NoEventsInFile;
       return;
     }
 
     // From here on, record all reasons we can't fast clone.
     IndexIntoFile::SortOrder sortOrder =
         (noRunLumiSort_ ? IndexIntoFile::entryOrder
                         : (noEventSort_ ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder));
     if (!indexIntoFile_.iterationWillBeInEntryOrder(sortOrder)) {
       whyNotFastClonable_ += (noEventSort_ ? FileBlock::RunOrLumiNotContiguous : FileBlock::EventsToBeSorted);
     }
     if (skipAnyEvents_) {
       whyNotFastClonable_ += FileBlock::InitialEventsSkipped;
     }
     if (remainingEvents >= 0 && eventTree_.entries() > remainingEvents) {
       whyNotFastClonable_ += FileBlock::MaxEventsTooSmall;
     }
     if (remainingLumis >= 0 && lumiTree_.entries() > remainingLumis) {
       whyNotFastClonable_ += FileBlock::MaxLumisTooSmall;
     }
     if (duplicateChecker_ && !duplicateChecker_->checkDisabled() && !duplicateChecker_->noDuplicatesInFile()) {
       whyNotFastClonable_ += FileBlock::DuplicateEventsRemoved;
     }
   }

◆ setPosition()

void edm::RootFile::setPosition ( IndexIntoFile::IndexIntoFileItr const & position )

Definition at line 821 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::copyPosition(), indexIntoFileIter_, and position.

                                                                           {
     indexIntoFileIter_.copyPosition(position);
   }

◆ setPresenceInProductRegistry()

void edm::RootFile::setPresenceInProductRegistry	(	ProductRegistry &	inputProdDescReg,
		StoredProcessBlockHelper const &	storedProcessBlockHelper
	)

private

Definition at line 1892 of file RootFile.cc.

References HLT_2022v14_cff::distance, spr::find(), edm::InProcess, newBranchToOldBranch(), processBlockTrees_, dqmiodatasetharvest::processes, edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), dumpMFGeometry_cfg::prod, edm::ProductRegistry::productListUpdator(), and treePointers_.

Referenced by RootFile().

                                                                                                         {
     // Set product presence information in the product registry.
     // "Presence" is a boolean that is true if and only if the TBranch exists
     // in the TTree (except it will be false for ProcessBlock products in non-Primary
     // input files).
     ProductRegistry::ProductList& pList = inputProdDescReg.productListUpdator();
     for (auto& product : pList) {
       BranchDescription& prod = product.second;
       // Initialize BranchDescription from dictionary only if the
       // branch is present. This allows a subsequent job to process
       // data where a dictionary of a transient parent branch has been
       // removed from the release after the file has been written.
       prod.initBranchName();
       if (prod.branchType() == InProcess) {
         std::vector<std::string> const& processes = storedProcessBlockHelper.processesWithProcessBlockProducts();
         auto it = std::find(processes.begin(), processes.end(), prod.processName());
         if (it != processes.end()) {
           auto index = std::distance(processes.begin(), it);
           processBlockTrees_[index]->setPresence(prod, newBranchToOldBranch(prod.branchName()));
         } else {
           // Given current rules for saving BranchDescriptions, this case should only occur
           // in non-Primary sequences.
           prod.setDropped(true);
         }
       } else {
         treePointers_[prod.branchType()]->setPresence(prod, newBranchToOldBranch(prod.branchName()));
       }
       if (prod.present()) {
         prod.initFromDictionary();
       }
     }
   }

◆ setSignals()

void edm::RootFile::setSignals	(	signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const *	preEventReadSource,
		signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)> const *	postEventReadSource
	)

Definition at line 2137 of file RootFile.cc.

References eventTree_, and edm::RootTree::setSignals().

                                                                                                             {
     eventTree_.setSignals(preEventReadSource, postEventReadSource);
   }

◆ setToLastEntry()

void edm::RootFile::setToLastEntry ( )

inline

Definition at line 273 of file RootFile.h.

References indexIntoFileEnd_, and indexIntoFileIter_.

273 { indexIntoFileIter_ = indexIntoFileEnd_; }

edm::RootFile::indexIntoFileIter_

IndexIntoFile::IndexIntoFileItr indexIntoFileIter_

Definition: RootFile.h:371

edm::RootFile::indexIntoFileEnd_

IndexIntoFile::IndexIntoFileItr indexIntoFileEnd_

Definition: RootFile.h:370

◆ skipEntries()

bool edm::RootFile::skipEntries ( unsigned int & offset )

inline

Definition at line 275 of file RootFile.h.

References eventTree_, hltrates_dqm_sourceclient-live_cfg::offset, and edm::RootTree::skipEntries().

275 { return eventTree_.skipEntries(offset); }

edm::RootFile::eventTree_

RootTree eventTree_

Definition: RootFile.h:384

edm::RootTree::skipEntries

bool skipEntries(unsigned int &offset)

Definition: RootTree.cc:410

hltrates_dqm_sourceclient-live_cfg.offset

offset

Definition: hltrates_dqm_sourceclient-live_cfg.py:83

◆ skipEvents()

bool edm::RootFile::skipEvents ( int & offset )

Definition at line 1440 of file RootFile.cc.

References duplicateChecker_, eventSkipperByID_, file_, fillEventAuxiliary(), indexIntoFileEnd_, indexIntoFileIter_, edm::IndexIntoFile::invalidEntry, edm::IndexIntoFile::invalidIndex, edm::IndexIntoFile::invalidLumi, edm::IndexIntoFile::invalidRun, hltrates_dqm_sourceclient-live_cfg::offset, edm::IndexIntoFile::IndexIntoFileItr::skipEventBackward(), and edm::IndexIntoFile::IndexIntoFileItr::skipEventForward().

                                        {
     while (offset > 0 && indexIntoFileIter_ != indexIntoFileEnd_) {
       int phIndexOfSkippedEvent = IndexIntoFile::invalidIndex;
       RunNumber_t runOfSkippedEvent = IndexIntoFile::invalidRun;
       LuminosityBlockNumber_t lumiOfSkippedEvent = IndexIntoFile::invalidLumi;
       IndexIntoFile::EntryNumber_t skippedEventEntry = IndexIntoFile::invalidEntry;
 
       indexIntoFileIter_.skipEventForward(
           phIndexOfSkippedEvent, runOfSkippedEvent, lumiOfSkippedEvent, skippedEventEntry);
 
       // At the end of the file and there were no more events to skip
       if (skippedEventEntry == IndexIntoFile::invalidEntry)
         break;
 
       if (eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
         auto const evtAux = fillEventAuxiliary(skippedEventEntry);
         if (eventSkipperByID_->skipIt(runOfSkippedEvent, lumiOfSkippedEvent, evtAux.id().event())) {
           continue;
         }
       }
       if (duplicateChecker_ && !duplicateChecker_->checkDisabled() && !duplicateChecker_->noDuplicatesInFile()) {
         auto const evtAux = fillEventAuxiliary(skippedEventEntry);
         if (duplicateChecker_->isDuplicateAndCheckActive(
                 phIndexOfSkippedEvent, runOfSkippedEvent, lumiOfSkippedEvent, evtAux.id().event(), file_)) {
           continue;
         }
       }
       --offset;
     }
 
     while (offset < 0) {
       if (duplicateChecker_) {
         duplicateChecker_->disable();
       }
 
       int phIndexOfEvent = IndexIntoFile::invalidIndex;
       RunNumber_t runOfEvent = IndexIntoFile::invalidRun;
       LuminosityBlockNumber_t lumiOfEvent = IndexIntoFile::invalidLumi;
       IndexIntoFile::EntryNumber_t eventEntry = IndexIntoFile::invalidEntry;
 
       indexIntoFileIter_.skipEventBackward(phIndexOfEvent, runOfEvent, lumiOfEvent, eventEntry);
 
       if (eventEntry == IndexIntoFile::invalidEntry)
         break;
 
       if (eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
         auto const evtAux = fillEventAuxiliary(eventEntry);
         if (eventSkipperByID_->skipIt(runOfEvent, lumiOfEvent, evtAux.id().event())) {
           continue;
         }
       }
       ++offset;
     }
     return (indexIntoFileIter_ == indexIntoFileEnd_);
   }

◆ skipThisEntry()

bool edm::RootFile::skipThisEntry ( )

private

Definition at line 830 of file RootFile.cc.

Referenced by getNextItemType().

                                {
     if (indexIntoFileIter_ == indexIntoFileEnd_) {
       return false;
     }
 
     if (eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
       // See first if the entire lumi or run is skipped, so we won't have to read the event Auxiliary in that case.
       if (eventSkipperByID_->skipIt(indexIntoFileIter_.run(), indexIntoFileIter_.lumi(), 0U)) {
         return true;
       }
 
       // The Lumi is not skipped.  If this is an event, see if the event is skipped.
       if (indexIntoFileIter_.getEntryType() == IndexIntoFile::kEvent) {
         auto eventAux = fillEventAuxiliary(indexIntoFileIter_.entry());
         if (eventSkipperByID_->skipIt(indexIntoFileIter_.run(), indexIntoFileIter_.lumi(), eventAux.id().event())) {
           return true;
         }
       }
 
       // Skip runs with no lumis if either lumisToSkip or lumisToProcess have been set to select lumis
       if (indexIntoFileIter_.getEntryType() == IndexIntoFile::kRun && eventSkipperByID_->skippingLumis()) {
         // There are no lumis in this run, not even ones we will skip
         if (indexIntoFileIter_.peekAheadAtLumi() == IndexIntoFile::invalidLumi) {
           return true;
         }
         // If we get here there are lumis in the run, check to see if we are skipping all of them
         do {
           if (!eventSkipperByID_->skipIt(indexIntoFileIter_.run(), indexIntoFileIter_.peekAheadAtLumi(), 0U)) {
             return false;
           }
         } while (indexIntoFileIter_.skipLumiInRun());
         return true;
       }
     }
     return false;
   }

◆ updateFileBlock()

void edm::RootFile::updateFileBlock ( FileBlock & fileBlock )

Definition at line 792 of file RootFile.cc.

References eventTree_, lumiTree_, edm::RootTree::metaTree(), eostools::move(), processBlockTrees_, runTree_, edm::RootTree::tree(), and edm::FileBlock::updateTTreePointers().

                                                      {
     std::vector<TTree*> processBlockTrees;
     std::vector<std::string> processesWithProcessBlockTrees;
     processBlockTrees.reserve(processBlockTrees_.size());
     processesWithProcessBlockTrees.reserve(processBlockTrees_.size());
     for (auto& processBlockTree : processBlockTrees_) {
       processBlockTrees.push_back(processBlockTree->tree());
       processesWithProcessBlockTrees.push_back(processBlockTree->processName());
     }
     fileBlock.updateTTreePointers(eventTree_.tree(),
                                   eventTree_.metaTree(),
                                   lumiTree_.tree(),
                                   lumiTree_.metaTree(),
                                   runTree_.tree(),
                                   runTree_.metaTree(),
                                   std::move(processBlockTrees),
                                   std::move(processesWithProcessBlockTrees));
   }

◆ validateFile()

void edm::RootFile::validateFile	(	InputType	inputType,
		bool	usingGoToEvent
	)

private

Definition at line 1221 of file RootFile.cc.

References cms::cuda::assert(), edm::createGlobalIdentifier(), daqProvenanceHelper_, duplicateChecker_, edm::IndexIntoFile::empty(), enforceGUIDInFileName_, edm::RootTree::entries(), edm::errors::EventCorruption, eventTree_, Exception, edm::FileID::fid(), fid_, file_, fileFormatVersion(), edm::errors::FileNameInconsistentWithGUID, edm::IndexIntoFile::fillEventNumbersOrEntries(), fillIndexIntoFile(), edm::IndexIntoFile::fixIndexes(), indexIntoFile_, edm::FileID::isValid(), edm::RootTree::isValid(), noEventSort_, orderedProcessHistoryIDs_, edm::Primary, processHistoryRegistry_, edm::IndexIntoFile::reduceProcessHistoryIDs(), runTree(), edm::IndexIntoFile::setEventFinder(), edm::IndexIntoFile::setNumberOfEvents(), edm::IndexIntoFile::setProcessHistoryIDs(), edm::stemFromPath(), and edm::FileFormatVersion::useReducedProcessHistoryID().

Referenced by RootFile().

                                                                       {
     if (!fid_.isValid()) {
       fid_ = FileID(createGlobalIdentifier());
     }
     if (!eventTree_.isValid()) {
       throw Exception(errors::EventCorruption) << "'Events' tree is corrupted or not present\n"
                                                << "in the input file.\n";
     }
     if (enforceGUIDInFileName_) {
       auto guidFromName = stemFromPath(file_);
       if (guidFromName != fid_.fid()) {
         throw edm::Exception(edm::errors::FileNameInconsistentWithGUID)
             << "GUID " << guidFromName << " extracted from file name " << file_
             << " is inconsistent with the GUID read from the file " << fid_.fid();
       }
     }
 
     if (fileFormatVersion().hasIndexIntoFile()) {
       if (runTree().entries() > 0) {
         assert(!indexIntoFile_.empty());
       }
       if (!fileFormatVersion().useReducedProcessHistoryID()) {
         if (daqProvenanceHelper_) {
           std::vector<ProcessHistoryID>& phidVec = indexIntoFile_.setProcessHistoryIDs();
           for (auto& phid : phidVec) {
             phid = daqProvenanceHelper_->mapProcessHistoryID(phid);
           }
         }
         indexIntoFile_.reduceProcessHistoryIDs(*processHistoryRegistry_);
       }
     } else {
       assert(indexIntoFile_.empty());
       fillIndexIntoFile();
     }
 
     indexIntoFile_.fixIndexes(orderedProcessHistoryIDs_);
     indexIntoFile_.setNumberOfEvents(eventTree_.entries());
     indexIntoFile_.setEventFinder(
         std::shared_ptr<IndexIntoFile::EventFinder>(std::make_shared<RootFileEventFinder>(eventTree_)));
     // We fill the event numbers explicitly if we need to find events in closed files,
     // such as for secondary files (or secondary sources) or if duplicate checking across files.
     bool needEventNumbers = false;
     bool needIndexesForDuplicateChecker =
         duplicateChecker_ && duplicateChecker_->checkingAllFiles() && !duplicateChecker_->checkDisabled();
     if (inputType != InputType::Primary || needIndexesForDuplicateChecker || usingGoToEvent) {
       needEventNumbers = true;
     }
     bool needEventEntries = false;
     if (inputType != InputType::Primary || !noEventSort_) {
       // We need event entries for sorting or for secondary files or sources.
       needEventEntries = true;
     }
     indexIntoFile_.fillEventNumbersOrEntries(needEventNumbers, needEventEntries);
   }

◆ wasFirstEventJustRead()

bool edm::RootFile::wasFirstEventJustRead ( ) const

Definition at line 935 of file RootFile.cc.

References indexIntoFileIter_, edm::IndexIntoFile::invalidEntry, BXlumiParameters_cfi::lumi, writedatasetfile::run, and edm::IndexIntoFile::IndexIntoFileItr::skipEventBackward().

                                              {
     IndexIntoFile::IndexIntoFileItr itr(indexIntoFileIter_);
     int phIndex;
     RunNumber_t run;
     LuminosityBlockNumber_t lumi;
     IndexIntoFile::EntryNumber_t eventEntry;
     itr.skipEventBackward(phIndex, run, lumi, eventEntry);
     itr.skipEventBackward(phIndex, run, lumi, eventEntry);
     return eventEntry == IndexIntoFile::invalidEntry;
   }

◆ wasLastEventJustRead()

bool edm::RootFile::wasLastEventJustRead ( ) const

Definition at line 929 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToEvent(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileIter_, and edm::IndexIntoFile::kEnd.

                                             {
     IndexIntoFile::IndexIntoFileItr itr(indexIntoFileIter_);
     itr.advanceToEvent();
     return itr.getEntryType() == IndexIntoFile::kEnd;
   }