edm::RootFile Class Reference

#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_ ()
void	readLuminosityBlock_ (LuminosityBlockPrincipal &lumiPrincipal)
std::shared_ptr < LuminosityBlockAuxiliary >	readLuminosityBlockAuxiliary_ ()
void	readProcessBlock_ (ProcessBlockPrincipal &)
void	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

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::BranchDescription::branchType(), edm::BranchTypeToAuxiliaryBranchName(), edm::BranchDescription::className(), edm::ProductRegistry::copyProduct(), daqProvenanceHelper_, edm::roottree::defaultNonEventCacheSize, HLT_FULL_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(), edm::IndexIntoFile::firstAppearanceOrder, edm::BranchDescription::friendlyClassName(), edm::friendlyname::friendlyName(), edm::roottree::getEntry(), hasNewlyDroppedBranch_, edm::FileFormatVersion::hasThinnedAssociations(), isotrackTrainRegressor::history, 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(), parallelization::processes, edm::poolNames::processHistoryBranchName(), edm::poolNames::processHistoryMapBranchName(), edm::BranchDescription::processName(), edm::poolNames::productDependenciesBranchName(), edm::poolNames::productDescriptionBranchName(), edm::ProductRegistry::productList(), edm::ProductRegistry::productListUpdator(), productRegistry(), productRegistry_, provenanceAdaptor_, provenanceReaderMaker_, TrackValidation_cff::pset, 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("*");
    }
  }

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) {}

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) {}

edm::RootFile::~RootFile

(

)

Definition at line 638 of file RootFile.cc.

{}

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

delete

Member Function Documentation

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().

{ return get_underlying_safe(branchChildren_); }

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

inlineprivate

Definition at line 349 of file RootFile.h.

References branchChildren_, and edm::get_underlying_safe().

{ return get_underlying_safe(branchChildren_); }

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_);
    }

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

inline

Definition at line 283 of file RootFile.h.

References branchIDListHelper_, and edm::get_underlying_safe().

{ return get_underlying_safe(branchIDListHelper_); }

bool edm::RootFile::branchListIndexesUnchanged ( ) const

inline

Definition at line 248 of file RootFile.h.

References branchListIndexesUnchanged_.

Referenced by createFileBlock().

{ return branchListIndexesUnchanged_; }

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
  }

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(), and indexIntoFile_.

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

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());
  }

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

private

Definition at line 1912 of file RootFile.cc.

References edm::ProductRegistry::allBranchDescriptions(), cms::cuda::assert(), edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), CommonMethods::cp(), HLT_FULL_cff::distance, drop, edm::BranchDescription::dropped(), dropProcessesAndReorder(), edProductClass_, file_, fileThinnedAssociationsHelper_, spr::find(), edm::TypeWithDict::getClass(), edm::getWrapperBasePtr(), hasNewlyDroppedBranch_, edm::InEvent, edm::ProductSelector::initialize(), edm::InProcess, markBranchToBeDropped(), newBranchToOldBranch(), hltrates_dqm_sourceclient-live_cfg::offset, edm::BranchDescription::originalBranchID(), AlCaHLTBitMon_ParallelJobs::p, edm::BranchDescription::present(), edm::Primary, processBlockTrees_, parallelization::processes, edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), edm::BranchDescription::processName(), edm::ProductRegistry::productListUpdator(), edm::SecondaryFile, edm::SecondarySource, edm::ProductSelector::selected(), groupFilesInBlocks::temp, treePointers_, edm::BranchDescription::unwrappedType(), and edm::BranchDescription::wrappedType().

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.branchType() != InEvent && 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;
      }
    }
  }

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

private

Definition at line 2057 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);
    }
  }

bool edm::RootFile::endOfProcessBlocksReached

(

)

const

Definition at line 1681 of file RootFile.cc.

References currentProcessBlockTree_, and processBlockTrees_.

Referenced by nextProcessBlock_().

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

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]);
    }

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]);
    }

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

inline

Definition at line 242 of file RootFile.h.

References eventTree_.

{ return eventTree_; }

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

inline

Definition at line 237 of file RootFile.h.

References file_.

Referenced by RootFile().

{ return file_; }

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().

{ return fileFormatVersion_; }

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

private

Definition at line 1313 of file RootFile.cc.

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

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

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

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_, gpuClustering::id, edm::EventAuxiliary::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;
  }

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);
      }
    }
  }

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_, dqmdumpme::lumi, edmLumisInFiles::lumis, lumiTree_, eostools::move(), edm::RootTree::next(), processHistoryRegistry_, submitPVValidationJobs::run, gather_cfg::runs, runTree_, edm::second(), edm::RootTree::setEntryNumber(), edm::IndexIntoFile::setProcessHistoryIDs(), edm::IndexIntoFile::setRunOrLumiEntries(), edm::stable_sort_all(), 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);
  }

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;
  }

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
  }

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;
  }

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_;
  }

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

Definition at line 884 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToNextLumiOrRun(), edm::IndexIntoFile::IndexIntoFileItr::advanceToNextRun(), edm::IndexIntoFile::IndexIntoFileItr::entry(), edm::EventAuxiliary::event(), fillEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileIter_, isDuplicateEvent(), edm::IndexIntoFile::kEnd, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, edm::IndexIntoFile::IndexIntoFileItr::lumi(), edm::IndexIntoFile::IndexIntoFileItr::peekAheadAtLumi(), processingMode_, edm::IndexIntoFile::IndexIntoFileItr::run(), runHelper_, edm::InputSource::Runs, edm::InputSource::RunsAndLumis, and skipThisEntry().

                                                                           {
    // 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;
  }

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;
  }

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

inline

Definition at line 247 of file RootFile.h.

References hasNewlyDroppedBranch_.

Referenced by createFileBlock().

{ return hasNewlyDroppedBranch_; }

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileIter

(

)

const

Definition at line 819 of file RootFile.cc.

References indexIntoFileIter_.

{ return indexIntoFileIter_; }

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_);
    }

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

inline

Definition at line 287 of file RootFile.h.

References edm::get_underlying_safe(), and indexIntoFileSharedPtr_.

{ return get_underlying_safe(indexIntoFileSharedPtr_); }

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_);
  }

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 1861 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);
    }
  }

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;
  }

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_);
  }

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

inline

Definition at line 243 of file RootFile.h.

References lumiTree_.

{ return lumiTree_; }

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

private

Definition at line 2118 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));
    }
  }

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

private

Definition at line 2158 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);
  }

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

private

Definition at line 2142 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>();
    }
  }

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

private

Definition at line 1901 of file RootFile.cc.

References branchChildren_, and edm::BranchDescription::branchID().

Referenced by dropOnInputAndReorder().

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

bool edm::RootFile::modifiedIDs ( ) const

inline

Definition at line 249 of file RootFile.h.

References daqProvenanceHelper_.

Referenced by createFileBlock().

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

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;
  }

bool edm::RootFile::nextEventEntry ( )

inline

Definition at line 278 of file RootFile.h.

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

{ return eventTree_.nextWithCache(); }

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;
  }

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

delete

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

inline

Definition at line 238 of file RootFile.h.

References productRegistry_.

Referenced by RootFile().

{ return productRegistry_; }

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, isotrackTrainRegressor::history, 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};
  }

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::Parentage::id(), edm::ParentageRegistry::insertMapped(), edm::ParentageRegistry::instance(), edm::numEntries(), parents, edm::EventEntryDescription::parents(), edm::Parentage::parentsForUpdate(), edm::SecondarySource, and edm::Parentage::setParents().

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);
  }

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;
  }

void edm::RootFile::readEventHistoryTree ( )

private

Definition at line 1850 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";
      }
    }
  }

void edm::RootFile::readFakeRun_

(

RunPrincipal &

runPrincipal

)

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

(

)

void edm::RootFile::readLuminosityBlock_

(

LuminosityBlockPrincipal &

lumiPrincipal

)

Definition at line 1784 of file RootFile.cc.

References cms::cuda::assert(), edm::LuminosityBlockPrincipal::aux(), edm::IndexIntoFile::IndexIntoFileItr::entry(), edm::IndexIntoFile::IndexIntoFileItr::entryContinues(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), isotrackTrainRegressor::history, indexIntoFileEnd_, indexIntoFileIter_, edm::RootTree::insertEntryForIndex(), edm::RootTree::isValid(), edm::IndexIntoFile::kLumi, lumiTree_, edm::LuminosityBlockAuxiliary::processHistoryID(), processHistoryRegistry_, edm::Principal::readAllFromSourceAndMergeImmediately(), edm::RootTree::resetAndGetRootDelayedReader(), edm::RootTree::setEntryNumber(), and edm::LuminosityBlockPrincipal::setWillBeContinued().

                                                                             {
    assert(indexIntoFileIter_ != indexIntoFileEnd_);
    assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kLumi);
    // Begin code for backward compatibility before the existence of lumi trees.
    if (!lumiTree_.isValid()) {
      ++indexIntoFileIter_;
      return;
    }
    // End code for backward compatibility before the existence of lumi trees.
    if (not indexIntoFileIter_.entryContinues()) {
      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();
    } else {
      auto history = processHistoryRegistry_->getMapped(lumiPrincipal.aux().processHistoryID());
      lumiPrincipal.fillLuminosityBlockPrincipal(history, nullptr);
      lumiPrincipal.setWillBeContinued(true);
    }
    ++indexIntoFileIter_;
  }

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

(

)

Definition at line 1746 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, dqmdumpme::lumi, edm::IndexIntoFile::IndexIntoFileItr::lumi(), edm::LuminosityBlockID::luminosityBlock(), lumiTree_, edm::LuminosityBlockID::run(), 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;
  }

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::Parentage::id(), edm::ParentageRegistry::insertMapped(), edm::ParentageRegistry::instance(), edm::numEntries(), edm::poolNames::parentageBranchName(), parentageIDLookup_, edm::poolNames::parentageTreeName(), parents, edm::Parentage::parentsForUpdate(), 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);
  }

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());
  }

void 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::IndexIntoFile::kRun, edm::RunPrincipal::mergeableRunProductMetadata(), edm::Primary, processHistoryRegistry_, edm::Principal::readAllFromSourceAndMergeImmediately(), edm::MergeableRunProductMetadata::readRun(), edm::RootTree::resetAndGetRootDelayedReader(), runHelper_, runTree_, and storedMergeableRunProductMetadata_.

                                                    {
    MergeableRunProductMetadata* mergeableRunProductMetadata = nullptr;
    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;
    }
    // End code for backward compatibility before the existence of run trees.
    // 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);
  }

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(), edm::RunID::run(), submitPVValidationJobs::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;
  }

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());
  }

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();
      }
    }

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

inline

Definition at line 244 of file RootFile.h.

References runTree_.

Referenced by validateFile().

{ return runTree_; }

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_().

{ return get_underlying_safe(savedRunAuxiliary_); }

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

inlineprivate

Definition at line 346 of file RootFile.h.

References edm::get_underlying_safe(), and savedRunAuxiliary_.

{ return get_underlying_safe(savedRunAuxiliary_); }

void edm::RootFile::setAtEventEntry

(

IndexIntoFile::EntryNumber_t

entry

)

Definition at line 1592 of file RootFile.cc.

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

{ eventTree_.setEntryNumber(entry); }

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

Definition at line 1809 of file RootFile.cc.

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

Referenced by setEntryAtItem().

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

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

inline

Definition at line 253 of file RootFile.h.

References setEntryAtEvent(), setEntryAtLumi(), and setEntryAtRun().

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

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

Definition at line 1817 of file RootFile.cc.

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

Referenced by setEntryAtItem().

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

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

Definition at line 1833 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(), 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;
  }

bool edm::RootFile::setEntryAtRun

(

RunNumber_t

run

)

Definition at line 1825 of file RootFile.cc.

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

Referenced by setEntryAtItem().

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

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;
    }
  }

void edm::RootFile::setPosition

(

IndexIntoFile::IndexIntoFileItr const &

position

)

Definition at line 821 of file RootFile.cc.

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

                                                                          {
    indexIntoFileIter_.copyPosition(position);
  }

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

private

Definition at line 1874 of file RootFile.cc.

References edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), HLT_FULL_cff::distance, spr::find(), edm::BranchDescription::init(), edm::InProcess, newBranchToOldBranch(), processBlockTrees_, parallelization::processes, edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), edm::BranchDescription::processName(), edm::ProductRegistry::productListUpdator(), edm::BranchDescription::setDropped(), 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;
      prod.init();
      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()));
      }
    }
  }

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 2112 of file RootFile.cc.

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

                                                                                                            {
    eventTree_.setSignals(preEventReadSource, postEventReadSource);
  }

void edm::RootFile::setToLastEntry ( )

inline

Definition at line 273 of file RootFile.h.

References indexIntoFileEnd_, and indexIntoFileIter_.

{ indexIntoFileIter_ = indexIntoFileEnd_; }

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

inline

Definition at line 275 of file RootFile.h.

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

{ return eventTree_.skipEntries(offset); }

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_);
  }

bool edm::RootFile::skipThisEntry ( )

private

Definition at line 830 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), eventSkipperByID_, fillEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::IndexIntoFile::invalidLumi, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kRun, edm::IndexIntoFile::IndexIntoFileItr::lumi(), edm::IndexIntoFile::IndexIntoFileItr::peekAheadAtLumi(), edm::IndexIntoFile::IndexIntoFileItr::run(), and edm::IndexIntoFile::IndexIntoFileItr::skipLumiInRun().

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;
  }

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));
  }

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);
  }

bool edm::RootFile::wasFirstEventJustRead

(

)

const

Definition at line 935 of file RootFile.cc.

References indexIntoFileIter_, edm::IndexIntoFile::invalidEntry, dqmdumpme::lumi, submitPVValidationJobs::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;
  }

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;
  }

int edm::RootFile::whyNotFastClonable ( ) const

inline

Definition at line 246 of file RootFile.h.

References whyNotFastClonable_.

Referenced by createFileBlock().

{ return whyNotFastClonable_; }

Member Data Documentation

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

private

Definition at line 406 of file RootFile.h.

Referenced by branchChildren(), markBranchToBeDropped(), and RootFile().

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

private

Definition at line 394 of file RootFile.h.

Referenced by branchIDListHelper(), fillEventHistory(), and RootFile().

std::shared_ptr<BranchIDLists const> edm::RootFile::branchIDLists_

private

Definition at line 393 of file RootFile.h.

Referenced by RootFile().

bool edm::RootFile::branchListIndexesUnchanged_

private

Definition at line 382 of file RootFile.h.

Referenced by branchListIndexesUnchanged(), and RootFile().

unsigned int edm::RootFile::currentProcessBlockTree_ = 0

private

Definition at line 388 of file RootFile.h.

Referenced by endOfProcessBlocksReached(), initializeFirstProcessBlockEntry(), nextProcessBlock_(), readProcessBlock_(), and rewind().

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

private

Definition at line 412 of file RootFile.h.

Referenced by fillEventHistory(), fillLumiAuxiliary(), fillRunAuxiliary(), makeProductProvenanceRetriever(), modifiedIDs(), readCurrentEvent(), readEntryDescriptionTree(), readParentageTree(), RootFile(), and validateFile().

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

private

Definition at line 407 of file RootFile.h.

Referenced by goToEvent(), initializeDuplicateChecker(), isDuplicateEvent(), setIfFastClonable(), skipEvents(), and validateFile().

edm::propagate_const<TClass*> edm::RootFile::edProductClass_

private

Definition at line 413 of file RootFile.h.

Referenced by dropOnInputAndReorder().

bool edm::RootFile::enforceGUIDInFileName_

private

Definition at line 379 of file RootFile.h.

Referenced by validateFile().

EventAuxiliary edm::RootFile::eventAuxCache_

private

Definition at line 383 of file RootFile.h.

Referenced by fillThisEventAuxiliary().

edm::propagate_const<TTree*> edm::RootFile::eventHistoryTree_

private

Definition at line 402 of file RootFile.h.

Referenced by close(), fillEventHistory(), and readEventHistoryTree().

std::vector<EventProcessHistoryID> edm::RootFile::eventProcessHistoryIDs_

private

Definition at line 373 of file RootFile.h.

Referenced by fillEventHistory(), and RootFile().

std::vector<EventProcessHistoryID>::const_iterator edm::RootFile::eventProcessHistoryIter_

private

Definition at line 374 of file RootFile.h.

Referenced by fillEventHistory(), and RootFile().

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

private

Definition at line 410 of file RootFile.h.

Referenced by eventProductProvenanceRetriever(), and makeProductProvenanceRetriever().

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

private

Definition at line 363 of file RootFile.h.

Referenced by RootFile(), skipEvents(), and skipThisEntry().

EventToProcessBlockIndexes edm::RootFile::eventToProcessBlockIndexes_

private

Definition at line 403 of file RootFile.h.

Referenced by fillEventToProcessBlockIndexes(), and readCurrentEvent().

edm::propagate_const<TBranch*> edm::RootFile::eventToProcessBlockIndexesBranch_

private

Definition at line 404 of file RootFile.h.

Referenced by fillEventToProcessBlockIndexes().

RootTree edm::RootFile::eventTree_

private

Definition at line 384 of file RootFile.h.

Referenced by createFileBlock(), eventTree(), fillEventAuxiliary(), fillEventHistory(), fillEventToProcessBlockIndexes(), fillIndexIntoFile(), fillThisEventAuxiliary(), initializeDuplicateChecker(), makeProductProvenanceRetriever(), nextEventEntry(), readCurrentEvent(), readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), reportOpened(), rewind(), RootFile(), setAtEventEntry(), setEntryAtEvent(), setIfFastClonable(), setSignals(), skipEntries(), updateFileBlock(), and validateFile().

FileID edm::RootFile::fid_

private

Definition at line 365 of file RootFile.h.

Referenced by reportOpened(), RootFile(), and validateFile().

std::string const edm::RootFile::file_

private

Definition at line 358 of file RootFile.h.

Referenced by createFileBlock(), dropOnInputAndReorder(), file(), isDuplicateEvent(), skipEvents(), and validateFile().

FileFormatVersion edm::RootFile::fileFormatVersion_

private

Definition at line 364 of file RootFile.h.

Referenced by fileFormatVersion(), makeProvenanceReaderMaker(), and RootFile().

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

private

Definition at line 362 of file RootFile.h.

Referenced by close(), readCurrentEvent(), readEntryDescriptionTree(), readEventHistoryTree(), readLuminosityBlockAuxiliary_(), readParentageTree(), readRunAuxiliary_(), reportOpened(), and RootFile().

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

private

Definition at line 397 of file RootFile.h.

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

std::array<bool, NumBranchTypes> edm::RootFile::hasNewlyDroppedBranch_

private

Definition at line 381 of file RootFile.h.

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

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

private

Definition at line 405 of file RootFile.h.

Referenced by fillEventHistory(), and readEventHistoryTree().

IndexIntoFile& edm::RootFile::indexIntoFile_

private

Definition at line 367 of file RootFile.h.

Referenced by containsItem(), fillIndexIntoFile(), goToEvent(), initializeDuplicateChecker(), readCurrentEvent(), RootFile(), setEntryAtEvent(), setEntryAtLumi(), setEntryAtRun(), setIfFastClonable(), and validateFile().

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileBegin_

private

Definition at line 369 of file RootFile.h.

Referenced by rewind(), RootFile(), and setIfFastClonable().

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileEnd_

private

Definition at line 370 of file RootFile.h.

Referenced by readEvent(), readLuminosityBlock_(), readLuminosityBlockAuxiliary_(), readRun_(), readRunAuxiliary_(), RootFile(), setEntryAtEvent(), setEntryAtLumi(), setEntryAtRun(), setIfFastClonable(), setToLastEntry(), skipEvents(), and skipThisEntry().

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileIter_

private

Definition at line 371 of file RootFile.h.

Referenced by getNextItemType(), goToEvent(), indexIntoFileIter(), isDuplicateEvent(), readCurrentEvent(), readEvent(), readLuminosityBlock_(), readLuminosityBlockAuxiliary_(), readRun_(), readRunAuxiliary_(), rewind(), RootFile(), setEntryAtEvent(), setEntryAtLumi(), setEntryAtNextEventInLumi(), setEntryAtRun(), setPosition(), setToLastEntry(), skipEvents(), skipThisEntry(), wasFirstEventJustRead(), and wasLastEventJustRead().

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

private

Definition at line 366 of file RootFile.h.

Referenced by indexIntoFileSharedPtr().

InputType edm::RootFile::inputType_

private

Definition at line 414 of file RootFile.h.

Referenced by fillProcessBlockHelper_(), nextProcessBlock_(), readProcessBlock_(), and readRun_().

IndexIntoFile::EntryNumber_t edm::RootFile::lastEventEntryNumberRead_

private

Definition at line 391 of file RootFile.h.

Referenced by fillIndexIntoFile(), and fillThisEventAuxiliary().

std::string const edm::RootFile::logicalFile_

private

Definition at line 359 of file RootFile.h.

Referenced by reportOpened().

RootTree edm::RootFile::lumiTree_

private

Definition at line 385 of file RootFile.h.

Referenced by createFileBlock(), fillIndexIntoFile(), fillLumiAuxiliary(), lumiTree(), readLuminosityBlock_(), readLuminosityBlockAuxiliary_(), rewind(), RootFile(), setEntryAtLumi(), setIfFastClonable(), and updateFileBlock().

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

private

Definition at line 401 of file RootFile.h.

Referenced by newBranchToOldBranch(), and RootFile().

bool edm::RootFile::noEventSort_

private

Definition at line 378 of file RootFile.h.

Referenced by goToEvent(), setIfFastClonable(), and validateFile().

bool edm::RootFile::noRunLumiSort_

private

Definition at line 377 of file RootFile.h.

Referenced by goToEvent(), and setIfFastClonable().

std::vector<ProcessHistoryID>& edm::RootFile::orderedProcessHistoryIDs_

private

Definition at line 368 of file RootFile.h.

Referenced by validateFile().

std::vector<ParentageID> edm::RootFile::parentageIDLookup_

private

Definition at line 411 of file RootFile.h.

Referenced by makeProvenanceReaderMaker(), and readParentageTree().

edm::propagate_const<ProcessBlockHelper*> edm::RootFile::processBlockHelper_

private

Definition at line 395 of file RootFile.h.

Referenced by fillEventToProcessBlockIndexes(), and fillProcessBlockHelper_().

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

private

Definition at line 387 of file RootFile.h.

Referenced by createFileBlock(), dropOnInputAndReorder(), dropProcessesAndReorder(), endOfProcessBlocksReached(), fillProcessBlockHelper_(), initializeFirstProcessBlockEntry(), makeProcessBlockRootTrees(), nextProcessBlock_(), readProcessBlock_(), rewind(), RootFile(), setPresenceInProductRegistry(), and updateFileBlock().

ProcessConfiguration const& edm::RootFile::processConfiguration_

private

Definition at line 360 of file RootFile.h.

edm::propagate_const<ProcessHistoryRegistry*> edm::RootFile::processHistoryRegistry_

private

Definition at line 361 of file RootFile.h.

Referenced by fillIndexIntoFile(), readCurrentEvent(), readLuminosityBlock_(), readRun_(), and validateFile().

InputSource::ProcessingMode edm::RootFile::processingMode_

private

Definition at line 399 of file RootFile.h.

Referenced by getNextItemType(), and setIfFastClonable().

std::shared_ptr<ProductRegistry const> edm::RootFile::productRegistry_

private

Definition at line 392 of file RootFile.h.

Referenced by productRegistry(), and RootFile().

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

private

Definition at line 408 of file RootFile.h.

Referenced by fillEventHistory(), fillLumiAuxiliary(), fillRunAuxiliary(), and RootFile().

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

private

Definition at line 409 of file RootFile.h.

Referenced by makeProductProvenanceRetriever(), and RootFile().

edm::propagate_const<RunHelperBase*> edm::RootFile::runHelper_

private

Definition at line 400 of file RootFile.h.

Referenced by getNextItemType(), readCurrentEvent(), readEvent(), readLuminosityBlockAuxiliary_(), readRun_(), readRunAuxiliary_(), and RootFile().

RootTree edm::RootFile::runTree_

private

Definition at line 386 of file RootFile.h.

Referenced by createFileBlock(), fillIndexIntoFile(), fillRunAuxiliary(), readRun_(), readRunAuxiliary_(), rewind(), RootFile(), runTree(), setEntryAtRun(), and updateFileBlock().

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

private

Definition at line 375 of file RootFile.h.

Referenced by readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), and savedRunAuxiliary().

bool edm::RootFile::skipAnyEvents_

private

Definition at line 376 of file RootFile.h.

Referenced by setIfFastClonable().

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

private

Definition at line 372 of file RootFile.h.

Referenced by readRun_(), and RootFile().

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

private

Definition at line 396 of file RootFile.h.

Referenced by fillProcessBlockHelper_(), and RootFile().

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

private

Definition at line 398 of file RootFile.h.

Referenced by initAssociationsFromSecondary().

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

private

Definition at line 389 of file RootFile.h.

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

int edm::RootFile::whyNotFastClonable_

private

Definition at line 380 of file RootFile.h.

Referenced by RootFile(), setIfFastClonable(), and whyNotFastClonable().