edm::RootFile Class Reference

#include <RootFile.h>

Inheritance diagram for edm::RootFile:

Public Types
typedef boost::array< RootTree *, NumBranchTypes >	RootTreePtrArray

Public Member Functions
BranchIDListRegistry::collection_type const &	branchIDLists ()
bool	branchListIndexesUnchanged () const
void	close ()
boost::shared_ptr< FileBlock >	createFileBlock () const
EventAuxiliary const &	eventAux () const
EventID const &	eventID () const
RootTree const &	eventTree () const
std::string const &	file () const
FileFormatVersion	fileFormatVersion () const
IndexIntoFile::EntryType	getNextEntryTypeWanted ()
bool	goToEvent (EventID const &eventID)
boost::array< bool, NumBranchTypes > const &	hasNewlyDroppedBranch () const
IndexIntoFile::IndexIntoFileItr	indexIntoFileIter () const
boost::shared_ptr< IndexIntoFile >	indexIntoFileSharedPtr () const
RootTree const &	lumiTree () const
bool	nextEventEntry ()
boost::shared_ptr < ProductRegistry const >	productRegistry () const
EventPrincipal *	readCurrentEvent (EventPrincipal &cache, boost::shared_ptr< LuminosityBlockPrincipal > lb=boost::shared_ptr< LuminosityBlockPrincipal >())
EventPrincipal *	readEvent (EventPrincipal &cache, boost::shared_ptr< LuminosityBlockPrincipal > lb=boost::shared_ptr< LuminosityBlockPrincipal >())
boost::shared_ptr < LuminosityBlockPrincipal >	readLumi (boost::shared_ptr< LuminosityBlockPrincipal > lbCache)
boost::shared_ptr < LuminosityBlockAuxiliary >	readLuminosityBlockAuxiliary_ ()
boost::shared_ptr< RunPrincipal >	readRun_ (boost::shared_ptr< RunPrincipal > rpCache)
boost::shared_ptr< RunAuxiliary >	readRunAuxiliary_ ()
void	reportOpened (std::string const &inputType)
void	rewind ()
	RootFile (std::string const &fileName, ProcessConfiguration const &processConfiguration, std::string const &logicalFileName, boost::shared_ptr< InputFile > filePtr, boost::shared_ptr< EventSkipperByID > eventSkipperByID, bool skipAnyEvents, int remainingEvents, int remainingLumis, unsigned int treeCacheSize, int treeMaxVirtualSize, InputSource::ProcessingMode processingMode, RunNumber_t const &forcedRunNumber, bool noEventSort, GroupSelectorRules const &groupSelectorRules, bool secondaryFile, boost::shared_ptr< DuplicateChecker > duplicateChecker, bool dropDescendantsOfDroppedProducts, std::vector< boost::shared_ptr< IndexIntoFile > > const &indexesIntoFiles, std::vector< boost::shared_ptr< IndexIntoFile > >::size_type currentIndexIntoFile, std::vector< ProcessHistoryID > &orderedProcessHistoryIDs, bool usingGoToEvent)
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	setEntryAtRun (RunNumber_t run)
void	setPosition (IndexIntoFile::IndexIntoFileItr const &position)
void	setToLastEntry ()
bool	skipEvents (int &offset)
bool	wasFirstEventJustRead () const
bool	wasLastEventJustRead () const
int	whyNotFastClonable () const
	~RootFile ()

Private Member Functions
void	dropOnInput (ProductRegistry &reg, GroupSelectorRules const &rules, bool dropDescendants, bool secondaryFile)
void	fillEventAuxiliary ()
void	fillHistory ()
void	fillIndexIntoFile ()
boost::shared_ptr < LuminosityBlockAuxiliary >	fillLumiAuxiliary ()
boost::shared_ptr< RunAuxiliary >	fillRunAuxiliary ()
void	fillThisEventAuxiliary ()
IndexIntoFile::EntryType	getEntryTypeWithSkipping ()
void	initializeDuplicateChecker (std::vector< boost::shared_ptr< IndexIntoFile > > const &indexesIntoFiles, std::vector< boost::shared_ptr< IndexIntoFile > >::size_type currentIndexIntoFile)
bool	isDuplicateEvent ()
boost::shared_ptr< BranchMapper >	makeBranchMapper (RootTree &rootTree, BranchType const &type) const
std::string const &	newBranchToOldBranch (std::string const &newBranch) const
void	overrideRunNumber (RunID &id)
void	overrideRunNumber (LuminosityBlockID &id)
void	overrideRunNumber (EventID &id, bool isRealData)
void	readEntryDescriptionTree ()
void	readEventHistoryTree ()
void	readParentageTree ()
void	setIfFastClonable (int remainingEvents, int remainingLumis)
bool	skipThisEntry ()
RootTreePtrArray &	treePointers ()
void	validateFile (bool secondaryFile, bool usingGoToEvent)

Private Attributes
boost::shared_ptr< BranchChildren >	branchChildren_
boost::shared_ptr < BranchIDListRegistry::collection_type const >	branchIDLists_
boost::shared_ptr < BranchListIndexes >	branchListIndexes_
bool	branchListIndexesUnchanged_
boost::shared_ptr < DuplicateChecker >	duplicateChecker_
EventAuxiliary	eventAux_
TTree *	eventHistoryTree_
std::vector < EventProcessHistoryID >	eventProcessHistoryIDs_
std::vector < EventProcessHistoryID > ::const_iterator	eventProcessHistoryIter_
boost::shared_ptr < EventSelectionIDVector >	eventSelectionIDs_
boost::shared_ptr < EventSkipperByID >	eventSkipperByID_
RootTree	eventTree_
FileID	fid_
std::string const	file_
FileFormatVersion	fileFormatVersion_
boost::shared_ptr< InputFile >	filePtr_
int	forcedRunOffset_
boost::array< bool, NumBranchTypes >	hasNewlyDroppedBranch_
boost::shared_ptr< History >	history_
IndexIntoFile &	indexIntoFile_
IndexIntoFile::IndexIntoFileItr	indexIntoFileBegin_
IndexIntoFile::IndexIntoFileItr	indexIntoFileEnd_
IndexIntoFile::IndexIntoFileItr	indexIntoFileIter_
boost::shared_ptr< IndexIntoFile >	indexIntoFileSharedPtr_
IndexIntoFile::EntryNumber_t	lastEventEntryNumberRead_
std::string const	logicalFile_
RootTree	lumiTree_
std::map< std::string, std::string >	newBranchToOldBranch_
bool	noEventSort_
std::vector< ProcessHistoryID > &	orderedProcessHistoryIDs_
ProcessConfiguration const &	processConfiguration_
InputSource::ProcessingMode	processingMode_
boost::shared_ptr < ProductRegistry const >	productRegistry_
boost::shared_ptr < ProvenanceAdaptor >	provenanceAdaptor_
RootTree	runTree_
bool	skipAnyEvents_
RootTreePtrArray	treePointers_
int	whyNotFastClonable_

Detailed Description

Definition at line 44 of file RootFile.h.

Member Typedef Documentation

typedef boost::array<RootTree*, NumBranchTypes> edm::RootFile::RootTreePtrArray

Definition at line 46 of file RootFile.h.

Constructor & Destructor Documentation

edm::RootFile::RootFile	(	std::string const &	fileName,
		ProcessConfiguration const &	processConfiguration,
		std::string const &	logicalFileName,
		boost::shared_ptr< InputFile >	filePtr,
		boost::shared_ptr< EventSkipperByID >	eventSkipperByID,
		bool	skipAnyEvents,
		int	remainingEvents,
		int	remainingLumis,
		unsigned int	treeCacheSize,
		int	treeMaxVirtualSize,
		InputSource::ProcessingMode	processingMode,
		RunNumber_t const &	forcedRunNumber,
		bool	noEventSort,
		GroupSelectorRules const &	groupSelectorRules,
		bool	secondaryFile,
		boost::shared_ptr< DuplicateChecker >	duplicateChecker,
		bool	dropDescendantsOfDroppedProducts,
		std::vector< boost::shared_ptr< IndexIntoFile > > const &	indexesIntoFiles,
		std::vector< boost::shared_ptr< IndexIntoFile > >::size_type	currentIndexIntoFile,
		std::vector< ProcessHistoryID > &	orderedProcessHistoryIDs,
		bool	usingGoToEvent
	)

Definition at line 100 of file RootFile.cc.

References edm::IndexIntoFile::begin(), branchChildren_, edm::poolNames::branchIDListBranchName(), branchIDLists_, branchListIndexesUnchanged_, edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), edm::BranchDescription::className(), edm::input::defaultNonEventCacheSize, edm::IndexIntoFile::doneFileInitialization(), dropOnInput(), edm::IndexIntoFile::end(), edm::errors::EventCorruption, edm::poolNames::eventHistoryBranchName(), eventProcessHistoryIDs_, eventProcessHistoryIter_, eventSkipperByID_, edm::FileBlock::EventsOrLumisSelectedByID, eventTree_, edm::hlt::Exception, fid_, file_, fileFormatVersion(), fileFormatVersion_, edm::poolNames::fileFormatVersionBranchName(), edm::poolNames::fileIdentifierBranchName(), filePtr_, edm::errors::FileReadError, edm::fillProductRegistryTransients(), edm::IndexIntoFile::firstAppearanceOrder, forcedRunOffset_, edm::BranchDescription::friendlyClassName(), edm::friendlyname::friendlyName(), edm::input::getEntry(), hasNewlyDroppedBranch_, i, edm::poolNames::idToParameterSetBlobsBranchName(), indexIntoFile_, indexIntoFileBegin_, edm::poolNames::indexIntoFileBranchName(), indexIntoFileEnd_, indexIntoFileIter_, edm::InEvent, initializeDuplicateChecker(), edm::InLumi, edm::InRun, edm::detail::ThreadSafeRegistry< KEY, T, E >::insertCollection(), edm::detail::ThreadSafeRegistry< KEY, T, E >::insertMapped(), edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), lumiTree_, edm::poolNames::metaDataTreeName(), edm::poolNames::moduleDescriptionMapBranchName(), newBranchToOldBranch(), newBranchToOldBranch_, edm::IndexIntoFile::numericalOrder, edm::poolNames::parameterSetMapBranchName(), edm::poolNames::parameterSetsTreeName(), edm::poolNames::processConfigurationBranchName(), edm::poolNames::processHistoryBranchName(), edm::poolNames::processHistoryMapBranchName(), CrabTask::prod, edm::poolNames::productDependenciesBranchName(), edm::poolNames::productDescriptionBranchName(), edm::ProductRegistry::productList(), productRegistry(), productRegistry_, provenanceAdaptor_, CrabTask::pset, readEventHistoryTree(), readParentageTree(), edm::RootTree::resetTraining(), runTree_, setIfFastClonable(), edm::setRefCoreStreamer(), treePointers_, edm::errors::UnimplementedFeature, edm::BranchDescription::updateFriendlyClassName(), edm::BranchIDListHelper::updateFromInput(), validateFile(), and whyNotFastClonable_.

                                          :
      file_(fileName),
      logicalFile_(logicalFileName),
      processConfiguration_(processConfiguration),
      filePtr_(filePtr),
      eventSkipperByID_(eventSkipperByID),
      fileFormatVersion_(),
      fid_(),
      indexIntoFileSharedPtr_(new IndexIntoFile),
      indexIntoFile_(*indexIntoFileSharedPtr_),
      orderedProcessHistoryIDs_(orderedProcessHistoryIDs),
      indexIntoFileBegin_(indexIntoFile_.begin(noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder)),
      indexIntoFileEnd_(indexIntoFileBegin_),
      indexIntoFileIter_(indexIntoFileBegin_),
      eventProcessHistoryIDs_(),
      eventProcessHistoryIter_(eventProcessHistoryIDs_.begin()),
      skipAnyEvents_(skipAnyEvents),
      noEventSort_(noEventSort),
      whyNotFastClonable_(0),
      hasNewlyDroppedBranch_(),
      branchListIndexesUnchanged_(false),
      eventAux_(),
      eventTree_(filePtr_, InEvent, treeMaxVirtualSize, treeCacheSize, input::defaultLearningEntries),
      lumiTree_(filePtr_, InLumi, treeMaxVirtualSize, input::defaultNonEventCacheSize, input::defaultNonEventLearningEntries),
      runTree_(filePtr_, InRun, treeMaxVirtualSize, input::defaultNonEventCacheSize, input::defaultNonEventLearningEntries),
      treePointers_(),
      lastEventEntryNumberRead_(-1LL),
      productRegistry_(),
      branchIDLists_(),
      processingMode_(processingMode),
      forcedRunOffset_(0),
      newBranchToOldBranch_(),
      eventHistoryTree_(0),
      eventSelectionIDs_(new EventSelectionIDVector),
      branchListIndexes_(new BranchListIndexes),
      history_(),
      branchChildren_(new BranchChildren),
      duplicateChecker_(duplicateChecker),
      provenanceAdaptor_() {

    hasNewlyDroppedBranch_.assign(false);

    treePointers_[InEvent] = &eventTree_;
    treePointers_[InLumi]  = &lumiTree_;
    treePointers_[InRun]   = &runTree_;

    // Read the metadata tree.
    TTree *metaDataTree = dynamic_cast<TTree *>(filePtr_->Get(poolNames::metaDataTreeName().c_str()));
    if(!metaDataTree)
      throw edm::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()) != 0) {
      TBranch *fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
      fft->SetAddress(&fftPtr);
      input::getEntry(fft, 0);
      metaDataTree->SetBranchAddress(poolNames::fileFormatVersionBranchName().c_str(), &fftPtr);
    }

    setRefCoreStreamer(0, !fileFormatVersion().splitProductIDs(), !fileFormatVersion().productIDIsInt()); // backward compatibility

    FileID *fidPtr = &fid_;
    if(metaDataTree->FindBranch(poolNames::fileIdentifierBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
    }

    IndexIntoFile *iifPtr = &indexIntoFile_;
    if(metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::indexIntoFileBranchName().c_str(), &iifPtr);
    }

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

    typedef std::map<ParameterSetID, ParameterSetBlob> PsetMap;
    PsetMap psetMap;
    PsetMap *psetMapPtr = &psetMap;
    if(metaDataTree->FindBranch(poolNames::parameterSetMapBranchName().c_str()) != 0) {
      //backward compatibility
      assert(!fileFormatVersion().parameterSetsTree());
      metaDataTree->SetBranchAddress(poolNames::parameterSetMapBranchName().c_str(), &psetMapPtr);
    } else {
      assert(fileFormatVersion().parameterSetsTree());
      TTree* psetTree = dynamic_cast<TTree *>(filePtr_->Get(poolNames::parameterSetsTreeName().c_str()));
      if(0 == psetTree) {
        throw Exception(errors::FileReadError) << "Could not find tree " << poolNames::parameterSetsTreeName()
        << " in the input file.\n";
      }
      psetTree->SetCacheSize(input::defaultNonEventCacheSize);
      std::auto_ptr<TTreeCache> treeCache(dynamic_cast<TTreeCache*>(filePtr_->GetCacheRead()));
      typedef std::pair<ParameterSetID, ParameterSetBlob> IdToBlobs;
      IdToBlobs idToBlob;
      IdToBlobs* pIdToBlob = &idToBlob;
      psetTree->SetBranchAddress(poolNames::idToParameterSetBlobsBranchName().c_str(), &pIdToBlob);
      if (0 != treeCache.get()) {
        treeCache->SetEntryRange(0, psetTree->GetEntries());
        treeCache->AddBranch("*");
        treeCache->StopLearningPhase();
      }
      for(Long64_t i = 0; i != psetTree->GetEntries(); ++i) {
        psetTree->GetEntry(i);
        psetMap.insert(idToBlob);
      }
      // We own the treeCache_.
      // We make sure the treeCache_ is detatched from the file,
      // so that ROOT does not also delete it.
      filePtr->SetCacheRead(0);
    }

    // backward compatibility
    ProcessHistoryRegistry::collection_type pHistMap;
    ProcessHistoryRegistry::collection_type *pHistMapPtr = &pHistMap;
    if(metaDataTree->FindBranch(poolNames::processHistoryMapBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::processHistoryMapBranchName().c_str(), &pHistMapPtr);
    }

    ProcessHistoryRegistry::vector_type pHistVector;
    ProcessHistoryRegistry::vector_type *pHistVectorPtr = &pHistVector;
    if(metaDataTree->FindBranch(poolNames::processHistoryBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::processHistoryBranchName().c_str(), &pHistVectorPtr);
    }

    ProcessConfigurationVector procConfigVector;
    ProcessConfigurationVector* procConfigVectorPtr = &procConfigVector;
    if(metaDataTree->FindBranch(poolNames::processConfigurationBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::processConfigurationBranchName().c_str(), &procConfigVectorPtr);
    }

    std::auto_ptr<BranchIDListRegistry::collection_type> branchIDListsAPtr(new BranchIDListRegistry::collection_type);
    BranchIDListRegistry::collection_type *branchIDListsPtr = branchIDListsAPtr.get();
    if(metaDataTree->FindBranch(poolNames::branchIDListBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::branchIDListBranchName().c_str(), &branchIDListsPtr);
    }

    BranchChildren* branchChildrenBuffer = branchChildren_.get();
    if(metaDataTree->FindBranch(poolNames::productDependenciesBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::productDependenciesBranchName().c_str(), &branchChildrenBuffer);
    }

    // backward compatibility
    std::vector<EventProcessHistoryID> *eventHistoryIDsPtr = &eventProcessHistoryIDs_;
    if(metaDataTree->FindBranch(poolNames::eventHistoryBranchName().c_str()) != 0) {
      metaDataTree->SetBranchAddress(poolNames::eventHistoryBranchName().c_str(), &eventHistoryIDsPtr);
    }

    if(metaDataTree->FindBranch(poolNames::moduleDescriptionMapBranchName().c_str()) != 0) {
      if(metaDataTree->GetBranch(poolNames::moduleDescriptionMapBranchName().c_str())->GetSplitLevel() != 0) {
        metaDataTree->SetBranchStatus((poolNames::moduleDescriptionMapBranchName() + ".*").c_str(), 0);
      } else {
        metaDataTree->SetBranchStatus(poolNames::moduleDescriptionMapBranchName().c_str(), 0);
      }
    }

    // Here we read the metadata tree
    input::getEntry(metaDataTree, 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(PsetMap::const_iterator i = psetMap.begin(), iEnd = psetMap.end(); i != iEnd; ++i) {
        ParameterSet pset(i->second.pset());
        pset.setID(i->first);
        psetRegistry.insertMapped(pset);
      }
    }
    if(!fileFormatVersion().splitProductIDs()) {
      // Old provenance format input file.  Create a provenance adaptor.
      provenanceAdaptor_.reset(new ProvenanceAdaptor(
            inputProdDescReg, pHistMap, pHistVector, procConfigVector, 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.
        provenanceAdaptor_.reset(new ProvenanceAdaptor(
            inputProdDescReg, pHistMap, pHistVector, procConfigVector, psetIdConverter, false));
      }
      // New provenance format input file. The branchIDLists branch was read directly from the input file.
      if(metaDataTree->FindBranch(poolNames::branchIDListBranchName().c_str()) == 0) {
        throw edm::Exception(errors::EventCorruption)
          << "Failed to find branchIDLists branch in metaData tree.\n";
      }
      branchIDLists_.reset(branchIDListsAPtr.release());
    }

    // Merge into the hashed registries.
    ProcessHistoryRegistry::instance()->insertCollection(pHistVector);
    ProcessConfigurationRegistry::instance()->insertCollection(procConfigVector);

    validateFile(secondaryFile, usingGoToEvent);

    // Read the parentage tree.  Old format files are handled internally in readParentageTree().
    readParentageTree();

    if (eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
      whyNotFastClonable_ += FileBlock::EventsOrLumisSelectedByID;
    }

    initializeDuplicateChecker(indexesIntoFiles, currentIndexIntoFile);
    indexIntoFileIter_ = indexIntoFileBegin_ = indexIntoFile_.begin(noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder);
    indexIntoFileEnd_ = indexIntoFile_.end(noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder);
    forcedRunOffset_ = forcedRunOffset(forcedRunNumber, indexIntoFileBegin_, indexIntoFileEnd_);
    eventProcessHistoryIter_ = eventProcessHistoryIDs_.begin();

    // Set product presence information in the product registry.
    ProductRegistry::ProductList const& pList = inputProdDescReg.productList();
    for(ProductRegistry::ProductList::const_iterator it = pList.begin(), itEnd = pList.end();
        it != itEnd; ++it) {
      BranchDescription const& prod = it->second;
      treePointers_[prod.branchType()]->setPresence(prod);
    }

    fillProductRegistryTransients(procConfigVector, inputProdDescReg);

    std::auto_ptr<ProductRegistry> newReg(new ProductRegistry);

    // Do the translation from the old registry to the new one
    {
      ProductRegistry::ProductList const& prodList = inputProdDescReg.productList();
      for(ProductRegistry::ProductList::const_iterator it = prodList.begin(), itEnd = prodList.end();
           it != itEnd; ++it) {
        BranchDescription const& prod = it->second;
        std::string newFriendlyName = friendlyname::friendlyName(prod.className());
        if(newFriendlyName == prod.friendlyClassName()) {
          newReg->copyProduct(prod);
        } else {
          if(fileFormatVersion().splitProductIDs()) {
            throw edm::Exception(errors::UnimplementedFeature)
              << "Cannot change friendly class name algorithm without more development work\n"
              << "to update BranchIDLists.  Contact the framework group.\n";
          }
          BranchDescription newBD(prod);
          newBD.updateFriendlyClassName();
          newReg->copyProduct(newBD);
          newBranchToOldBranch_.insert(std::make_pair(newBD.branchName(), prod.branchName()));
        }
      }
      dropOnInput(*newReg, groupSelectorRules, dropDescendants, secondaryFile);
      // freeze the product registry
      newReg->setFrozen();
      productRegistry_.reset(newReg.release());
    }


    // Set up information from the product registry.
    ProductRegistry::ProductList const& prodList = productRegistry()->productList();
    for(ProductRegistry::ProductList::const_iterator it = prodList.begin(), itEnd = prodList.end();
        it != itEnd; ++it) {
      BranchDescription const& prod = it->second;
      treePointers_[prod.branchType()]->addBranch(it->first, prod,
                                                  newBranchToOldBranch(prod.branchName()));
    }

    // Determine if this file is fast clonable.
    setIfFastClonable(remainingEvents, remainingLumis);

    // Update the branch id info.
    if (!secondaryFile) {
      branchListIndexesUnchanged_ = BranchIDListHelper::updateFromInput(*branchIDLists_, file_);
    }

    setRefCoreStreamer(true);  // backward compatibility

    // We are done with our initial reading of EventAuxiliary.
    indexIntoFile_.doneFileInitialization();
    eventTree_.resetTraining();
  }

edm::RootFile::~RootFile

(

)

Definition at line 403 of file RootFile.cc.

                      {
  }

Member Function Documentation

BranchIDListRegistry::collection_type const& edm::RootFile::branchIDLists ( )

inline

Definition at line 82 of file RootFile.h.

References branchIDLists_.

{return *branchIDLists_;}

bool edm::RootFile::branchListIndexesUnchanged ( ) const

inline

Definition at line 94 of file RootFile.h.

References branchListIndexesUnchanged_.

Referenced by createFileBlock().

{return branchListIndexesUnchanged_;}

void edm::RootFile::close

(

void

)

Definition at line 991 of file RootFile.cc.

References eventHistoryTree_, filePtr_, and treePointers_.

Referenced by python.Vispa.Gui.BoxContentDialog.BoxContentDialog::keyPressEvent(), and python.Vispa.Gui.FindDialog.FindDialog::keyPressEvent().

                  {
    // Just to play it safe, zero all pointers to objects in the InputFile to be closed.
    eventHistoryTree_ = 0;
    for(RootTreePtrArray::iterator it = treePointers_.begin(), itEnd = treePointers_.end(); it != itEnd; ++it) {
      (*it)->close();
      (*it) = 0;
    }
    filePtr_->Close();
    filePtr_.reset();
  }

boost::shared_ptr< FileBlock > edm::RootFile::createFileBlock

(

)

const

Definition at line 519 of file RootFile.cc.

References branchChildren_, branchListIndexesUnchanged(), eventTree_, file_, fileFormatVersion(), hasNewlyDroppedBranch(), lumiTree_, edm::RootTree::metaTree(), runTree_, edm::RootTree::tree(), and whyNotFastClonable().

                                  {
    return boost::shared_ptr<FileBlock>(new FileBlock(fileFormatVersion(),
                                                     eventTree_.tree(),
                                                     eventTree_.metaTree(),
                                                     lumiTree_.tree(),
                                                     lumiTree_.metaTree(),
                                                     runTree_.tree(),
                                                     runTree_.metaTree(),
                                                     whyNotFastClonable(),
                                                     hasNewlyDroppedBranch(),
                                                     file_,
                                                     branchListIndexesUnchanged(),
                                                     branchChildren_));
  }

void edm::RootFile::dropOnInput ( ProductRegistry &  reg, GroupSelectorRules const &  rules, bool  dropDescendants, bool  secondaryFile  )

private

Definition at line 1484 of file RootFile.cc.

References edm::ProductRegistry::allBranchDescriptions(), branchChildren_, edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), CommonMethods::cp(), drop, file_, hasNewlyDroppedBranch_, edm::InEvent, edm::GroupSelector::initialize(), newBranchToOldBranch(), CrabTask::prod, edm::ProductRegistry::productListUpdator(), edm::GroupSelector::selected(), treePointers_, and edm::BranchDescription::wrappedName().

Referenced by RootFile().

                                                                                                                        {
    // This is the selector for drop on input.
    GroupSelector groupSelector;
    groupSelector.initialize(rules, reg.allBranchDescriptions());

    ProductRegistry::ProductList& prodList = reg.productListUpdator();
    // Do drop on input. On the first pass, just fill in a set of branches to be dropped.
    std::set<BranchID> branchesToDrop;
    for(ProductRegistry::ProductList::const_iterator it = prodList.begin(), itEnd = prodList.end();
        it != itEnd; ++it) {
      BranchDescription const& prod = it->second;
      if(!groupSelector.selected(prod)) {
        if(dropDescendants) {
          branchChildren_->appendToDescendants(prod.branchID(), branchesToDrop);
        } else {
          branchesToDrop.insert(prod.branchID());
        }
      }
    }

    // On this pass, actually drop the branches.
    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(groupSelector.selected(prod)) {
          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";
        }
        treePointers_[prod.branchType()]->dropBranch(newBranchToOldBranch(prod.branchName()));
        hasNewlyDroppedBranch_[prod.branchType()] = true;
        ProductRegistry::ProductList::iterator icopy = it;
        ++it;
        prodList.erase(icopy);
      } else {
        ++it;
      }
    }

    // Drop on input mergeable run and lumi products, this needs to be invoked for secondary file input
    if(secondaryFile) {
      for(ProductRegistry::ProductList::iterator it = prodList.begin(), itEnd = prodList.end(); it != itEnd;) {
        BranchDescription const& prod = it->second;
        if(prod.branchType() != InEvent) {
          TClass *cp = gROOT->GetClass(prod.wrappedName().c_str());
          boost::shared_ptr<EDProduct> dummy(static_cast<EDProduct *>(cp->New()));
          if(dummy->isMergeable()) {
            treePointers_[prod.branchType()]->dropBranch(newBranchToOldBranch(prod.branchName()));
            ProductRegistry::ProductList::iterator icopy = it;
            ++it;
            prodList.erase(icopy);
          } else {
            ++it;
          }
        }
        else ++it;
      }
    }
  }

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

inline

Definition at line 83 of file RootFile.h.

References eventAux_.

Referenced by eventID(), fillHistory(), fillIndexIntoFile(), fillThisEventAuxiliary(), initializeDuplicateChecker(), readCurrentEvent(), readEvent(), readLuminosityBlockAuxiliary_(), and readRunAuxiliary_().

{return eventAux_;}

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

inline

Definition at line 87 of file RootFile.h.

References eventAux(), and edm::EventAuxiliary::id().

Referenced by readCurrentEvent().

{return eventAux().id();}

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

inline

Definition at line 88 of file RootFile.h.

References eventTree_.

{return eventTree_;}

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

inline

Definition at line 80 of file RootFile.h.

References file_.

{return file_;}

FileFormatVersion edm::RootFile::fileFormatVersion ( ) const

inline

Definition at line 91 of file RootFile.h.

References fileFormatVersion_.

Referenced by createFileBlock(), fillHistory(), fillIndexIntoFile(), fillLumiAuxiliary(), fillRunAuxiliary(), fillThisEventAuxiliary(), makeBranchMapper(), readCurrentEvent(), readEntryDescriptionTree(), readEventHistoryTree(), readLumi(), readLuminosityBlockAuxiliary_(), readParentageTree(), readRun_(), readRunAuxiliary_(), RootFile(), setIfFastClonable(), and validateFile().

{return fileFormatVersion_;}

void edm::RootFile::fillEventAuxiliary ( )

private

Definition at line 1022 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), eventTree_, fillThisEventAuxiliary(), indexIntoFileIter_, and edm::RootTree::setEntryNumber().

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

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

void edm::RootFile::fillHistory ( )

private

Definition at line 1028 of file RootFile.cc.

References branchListIndexes_, edm::poolNames::branchListIndexesBranchName(), ExpressReco_HICollisions_FallBack::e, edm::RootTree::entryNumber(), event(), eventAux(), eventAux_, edm::errors::EventCorruption, edm::poolNames::eventHistoryBranchName(), edm::FileFormatVersion::eventHistoryTree(), eventHistoryTree_, eventProcessHistoryIDs_, eventProcessHistoryIter_, eventSelectionIDs_, edm::poolNames::eventSelectionsBranchName(), eventTree_, edm::hlt::Exception, fileFormatVersion(), edm::RootTree::fillBranchEntry(), edm::input::getEntry(), history_, i, ExpressReco_HICollisions_FallBack::id, edm::lower_bound_all(), edm::FileFormatVersion::noMetaDataTrees(), provenanceAdaptor_, CrabTask::run, edm::EventAuxiliary::setProcessHistoryID(), filterCSVwithJSON::target, and edm::RootTree::tree().

Referenced by fillIndexIntoFile(), and readCurrentEvent().

                        {
    // 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(eventAux().id().run(), 0, eventAux().id().event());
      if(eventProcessHistoryIter_->eventID() != id) {
        EventProcessHistoryID target(id, ProcessHistoryID());
        eventProcessHistoryIter_ = lower_bound_all(eventProcessHistoryIDs_, target);
        assert(eventProcessHistoryIter_->eventID() == id);
      }
      eventAux_.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 edm::Exception(errors::EventCorruption)
          << "Failed to find history branch in event history tree.\n";
      }
      eventHistoryBranch->SetAddress(&pHistory);
      input::getEntry(eventHistoryTree_, eventTree_.entryNumber());
      eventAux_.setProcessHistoryID(history_->processHistoryID());
      eventSelectionIDs_.reset(&history_->eventSelectionIDs(), do_nothing_deleter());
      branchListIndexes_.reset(&history_->branchListIndexes(), do_nothing_deleter());
    } else if (fileFormatVersion().noMetaDataTrees()) {
      // Current format
      EventSelectionIDVector* pESV = eventSelectionIDs_.get();
      TBranch* eventSelectionIDBranch = eventTree_.tree()->GetBranch(poolNames::eventSelectionsBranchName().c_str());
      assert(eventSelectionIDBranch != 0);
      eventTree_.fillBranchEntry(eventSelectionIDBranch, pESV);
      BranchListIndexes* pBLI = branchListIndexes_.get();
      TBranch* branchListIndexesBranch = eventTree_.tree()->GetBranch(poolNames::branchListIndexesBranchName().c_str());
      assert(branchListIndexesBranch != 0);
      eventTree_.fillBranchEntry(branchListIndexesBranch, pBLI);
    }
    if(provenanceAdaptor_) {
      eventAux_.setProcessHistoryID(provenanceAdaptor_->convertID(eventAux().processHistoryID()));
      for(EventSelectionIDVector::iterator i = eventSelectionIDs_->begin(), e = eventSelectionIDs_->end(); i != e; ++i) {
        (*i) = provenanceAdaptor_->convertID(*i);
      }
    }
    if(!fileFormatVersion().splitProductIDs()) {
      // old format.  branchListIndexes_ must be filled in from the ProvenanceAdaptor.
      provenanceAdaptor_->branchListIndexes(*branchListIndexes_);
    }
  }

void edm::RootFile::fillIndexIntoFile ( )

private

Definition at line 720 of file RootFile.cc.

References edm::RootTree::entries(), python.tagInventory::entries, edm::RootTree::entryNumber(), event(), eventAux(), eventAux_, eventTree_, fileFormatVersion(), fillHistory(), fillLumiAuxiliary(), fillRunAuxiliary(), fillThisEventAuxiliary(), edm::find_in_all(), i, indexIntoFile_, edm::RootTree::isValid(), lastEventEntryNumberRead_, edm::EventAuxiliary::luminosityBlock(), edmLumisInFiles::lumis, lumiTree_, edm::RootTree::next(), edm::EventAuxiliary::processHistoryID(), CrabTask::run, edm::EventAuxiliary::run(), getRunRegistry::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;

    indexIntoFile_.unsortedEventNumbers().clear(); // should already be empty, just being careful
    indexIntoFile_.unsortedEventNumbers().reserve(eventTree_.entries());

    // First, loop through the event tree.
    while(eventTree_.next()) {
      bool newRun = false;
      bool newLumi = false;
      fillThisEventAuxiliary();
      fillHistory();

      // 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(eventAux().event());

      if (prevPhid != eventAux().processHistoryID() || prevRun != eventAux().run()) {
        newRun = newLumi = true;
      } else if(prevLumi != eventAux().luminosityBlock()) {
        newLumi = true;
      }
      prevPhid = eventAux().processHistoryID();
      prevRun = eventAux().run();
      prevLumi = eventAux().luminosityBlock();
      if (newLumi) {
        lumis.push_back(LumiItem(eventAux().processHistoryID(),
          eventAux().run(), eventAux().luminosityBlock(), eventTree_.entryNumber())); // (insert 1)
        runLumiSet.insert(LuminosityBlockID(eventAux().run(), eventAux().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(eventAux().processHistoryID(), eventAux().run());
        if (runItemSet.insert(item).second) { // (check 3, insert 3)
          runs.push_back(item); // (insert 5)
          runSet.insert(eventAux().run()); // (insert 4)
          phidMap.insert(std::make_pair(eventAux().run(), eventAux().processHistoryID()));
        }
      }
    }
    // now clean up.
    eventTree_.setEntryNumber(-1);
    eventAux_ = EventAuxiliary();
    lastEventEntryNumberRead_ = -1LL;

    // Loop over run entries and fill information.

    typedef std::map<RunNumber_t, 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.
        boost::shared_ptr<RunAuxiliary> runAux = fillRunAuxiliary();
        if (runSet.insert(runAux->run()).second) { // (check 4, insert 4)
          // This run was not assciated with any events or lumis.
          emptyRuns.push_back(RunItem(runAux->processHistoryID(), runAux->run())); // (insert 12)
        }
        runMap.insert(std::make_pair(runAux->run(), runTree_.entryNumber())); // (insert 11)
        phidMap.insert(std::make_pair(runAux->run(), runAux->processHistoryID()));
      }
      // now clean up.
      runTree_.setEntryNumber(-1);
    }

    // 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 (RunVector::const_iterator i = emptyRuns.begin(), iEnd = emptyRuns.end(); i != iEnd; ++i) {
      for (; itRuns != endRuns; ++itRuns) {
        if (runItemSortByRun(*i, *itRuns)) {
          break;
        }
      }
      runs.insert(itRuns, *i);
    }

    // Loop over luminosity block entries and fill information.

    typedef std::vector<LumiItem> LumiVector;
    LumiVector emptyLumis; // (declare 7)

    typedef std::map<LuminosityBlockID, EntryNumber_t> RunLumiMap;
    RunLumiMap runLumiMap; // (declare 6)

    if(lumiTree_.isValid()) {
      while(lumiTree_.next()) {
        // Note: adjacent duplicates will be skipped without an explicit check.
        boost::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.push_back(LumiItem(iPhidMap->second, lumiAux->run(), lumiAux->luminosityBlock(), -1LL)); // (insert 7)
        }
        runLumiMap.insert(std::make_pair(lumiID, lumiTree_.entryNumber()));
      }
      // now clean up.
      lumiTree_.setEntryNumber(-1);
    }

    // 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 (LumiVector::const_iterator i = emptyLumis.begin(), iEnd = emptyLumis.end(); i != iEnd; ++i) {
      for (; itLumis != endLumis; ++itLumis) {
        if (lumiItemSortByRunLumi(*i, *itLumis)) {
          break;
        }
      }
      lumis.insert(itLumis, *i);
    }

    // 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 (RunList::iterator it = runs.begin(), itEnd = runs.end(); it != itEnd; ++it) {
      RunCountMap::const_iterator countMapItem = runCountMap.find(*it);
      if (countMapItem == runCountMap.end()) {
        countMapItem = runCountMap.insert(std::make_pair(*it, rcount)).first; // Insert (17)
        assert(countMapItem != runCountMap.end());
        ++rcount;
      }
      std::vector<ProcessHistoryID>::const_iterator phidItem = find_in_all(phids, it->phid_);
      if (phidItem == phids.end()) {
        phids.push_back(it->phid_);
        phidItem = phids.end() - 1;
      }
      entries.push_back(IndexIntoFile::RunOrLumiEntry(
        countMapItem->second, // use (17)
        -1LL,
        runMap[it->run_], // use (11)
        phidItem - phids.begin(),
        it->run_,
        0U,
        -1LL,
        -1LL));
    }

    // 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 (LumiList::iterator it = lumis.begin(), itEnd = lumis.end(); it != itEnd; ++it) {
      RunCountMap::const_iterator runCountMapItem = runCountMap.find(RunItem(it->phid_, it->run_));
      assert(runCountMapItem != runCountMap.end());
      LumiCountMap::const_iterator countMapItem = lumiCountMap.find(*it);
      if (countMapItem == lumiCountMap.end()) {
        countMapItem = lumiCountMap.insert(std::make_pair(*it, lcount)).first; // Insert (17)
        assert(countMapItem != lumiCountMap.end());
        ++lcount;
      }
      std::vector<ProcessHistoryID>::const_iterator phidItem = find_in_all(phids, it->phid_);
      assert(phidItem != phids.end());
      entries.push_back(IndexIntoFile::RunOrLumiEntry(
        runCountMapItem->second,
        countMapItem->second,
        runLumiMap[LuminosityBlockID(it->run_, it->lumi_)],
        phidItem - phids.begin(),
        it->run_,
        it->lumi_,
        it->firstEventEntry_,
        it->lastEventEntry_));
    }
    stable_sort_all(entries);
  }

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

private

Definition at line 1080 of file RootFile.cc.

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

Referenced by fillIndexIntoFile(), and readLuminosityBlockAuxiliary_().

                              {
    boost::shared_ptr<LuminosityBlockAuxiliary> lumiAuxiliary(new 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(lumiAuxiliary->luminosityBlock() == 0 && !fileFormatVersion().runsAndLumis()) {
      lumiAuxiliary->id() = LuminosityBlockID(RunNumber_t(1), LuminosityBlockNumber_t(1));
    }
    return lumiAuxiliary;
  }

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

private

Definition at line 1101 of file RootFile.cc.

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

Referenced by fillIndexIntoFile(), and readRunAuxiliary_().

                             {
    boost::shared_ptr<RunAuxiliary> runAuxiliary(new 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()));
    }
    return runAuxiliary;
  }

void edm::RootFile::fillThisEventAuxiliary ( )

private

Definition at line 1003 of file RootFile.cc.

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

Referenced by fillEventAuxiliary(), fillIndexIntoFile(), initializeDuplicateChecker(), readCurrentEvent(), readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), and skipEvents().

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

IndexIntoFile::EntryType edm::RootFile::getEntryTypeWithSkipping ( )

private

Definition at line 598 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToNextLumiOrRun(), edm::IndexIntoFile::IndexIntoFileItr::advanceToNextRun(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileIter_, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, and skipThisEntry().

Referenced by getNextEntryTypeWanted().

                                     {
    while(skipThisEntry()) {
      if (indexIntoFileIter_.getEntryType() == IndexIntoFile::kRun) {
        indexIntoFileIter_.advanceToNextRun();
      }
      else if (indexIntoFileIter_.getEntryType() == IndexIntoFile::kLumi) {
        indexIntoFileIter_.advanceToNextLumiOrRun();
      }
      else {
        ++indexIntoFileIter_;
      }
    }
    return indexIntoFileIter_.getEntryType();
  }

IndexIntoFile::EntryType edm::RootFile::getNextEntryTypeWanted

(

)

Definition at line 625 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::advanceToNextLumiOrRun(), edm::IndexIntoFile::IndexIntoFileItr::advanceToNextRun(), getEntryTypeWithSkipping(), indexIntoFileIter_, isDuplicateEvent(), edm::IndexIntoFile::kEnd, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, processingMode_, edm::InputSource::Runs, and edm::InputSource::RunsAndLumis.

                                   {
    IndexIntoFile::EntryType entryType = getEntryTypeWithSkipping();
    if(entryType == IndexIntoFile::kEnd) {
      return IndexIntoFile::kEnd;
    }
    if(entryType == IndexIntoFile::kRun) {
      return IndexIntoFile::kRun;
    } else if(processingMode_ == InputSource::Runs) {
      indexIntoFileIter_.advanceToNextRun();
      return getNextEntryTypeWanted();
    }
    if(entryType == IndexIntoFile::kLumi) {
      return IndexIntoFile::kLumi;
    } else if(processingMode_ == InputSource::RunsAndLumis) {
      indexIntoFileIter_.advanceToNextLumiOrRun();
      return getNextEntryTypeWanted();
    }
    if(isDuplicateEvent()) {
      ++indexIntoFileIter_;
      return getNextEntryTypeWanted();
    }
    return IndexIntoFile::kEvent;
  }

bool edm::RootFile::goToEvent

(

EventID const &

eventID

)

Definition at line 1193 of file RootFile.cc.

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

                                            {

    indexIntoFile_.fillEventNumbers();

    if (duplicateChecker_) {
      duplicateChecker_->disable();
    }

    IndexIntoFile::SortOrder sortOrder = IndexIntoFile::numericalOrder;
    if (noEventSort_) sortOrder = IndexIntoFile::firstAppearanceOrder;

    IndexIntoFile::IndexIntoFileItr iter = 
      indexIntoFile_.findPosition(sortOrder, eventID.run(), eventID.luminosityBlock(), eventID.event());

    if (iter == indexIntoFile_.end(sortOrder)) {
      return false;
    }
    indexIntoFileIter_ = iter;
    return true;
  }

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

inline

Definition at line 93 of file RootFile.h.

References hasNewlyDroppedBranch_.

Referenced by createFileBlock().

{return hasNewlyDroppedBranch_;}

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileIter

(

)

const

Definition at line 544 of file RootFile.cc.

References indexIntoFileIter_.

                                    {
    return indexIntoFileIter_;
  }

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

inline

Definition at line 118 of file RootFile.h.

References indexIntoFileSharedPtr_.

                                                                  {
      return indexIntoFileSharedPtr_;
    }

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

private

Definition at line 1468 of file RootFile.cc.

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

Referenced by RootFile().

                                                                              {
    if(duplicateChecker_) {
      if(eventTree_.next()) {
        fillThisEventAuxiliary();
        duplicateChecker_->inputFileOpened(eventAux().isRealData(),
                                           indexIntoFile_,
                                           indexesIntoFiles,
                                           currentIndexIntoFile);
      }
      eventTree_.setEntryNumber(-1);
    }
  }

bool edm::RootFile::isDuplicateEvent ( )

private

Definition at line 614 of file RootFile.cc.

References duplicateChecker_, edm::EventID::event(), eventAux_, file_, fillEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), edm::EventAuxiliary::id(), indexIntoFileIter_, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::IndexIntoFileItr::lumi(), edm::IndexIntoFile::IndexIntoFileItr::processHistoryIDIndex(), and edm::IndexIntoFile::IndexIntoFileItr::run().

Referenced by getNextEntryTypeWanted().

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

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

inline

Definition at line 89 of file RootFile.h.

References lumiTree_.

{return lumiTree_;}

boost::shared_ptr< BranchMapper > edm::RootFile::makeBranchMapper ( RootTree &  rootTree, BranchType const &  type  ) const

private

Definition at line 1645 of file RootFile.cc.

References fileFormatVersion(), and productRegistry_.

Referenced by readCurrentEvent(), readLumi(), and readRun_().

                                                                             {
    if(fileFormatVersion().noMetaDataTrees()) {
      return makeBranchMapperInRelease390(rootTree);
    } else if(fileFormatVersion().splitProductIDs()) {
      return makeBranchMapperInRelease300(rootTree);
    } else if(fileFormatVersion().perEventProductIDs()) {
      return makeBranchMapperInRelease210(rootTree, type);
    } else if(fileFormatVersion().eventHistoryTree()) {
      return makeBranchMapperInRelease200(rootTree, type, *productRegistry_);
    } else {
      return makeBranchMapperInRelease180(rootTree, type, *productRegistry_);
    }
  }

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

private

Definition at line 535 of file RootFile.cc.

References newBranchToOldBranch_.

Referenced by dropOnInput(), and RootFile().

                                                                 {
    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 116 of file RootFile.h.

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

{return eventTree_.next();}

void edm::RootFile::overrideRunNumber ( RunID &  id )

private

Definition at line 1424 of file RootFile.cc.

References edm::RunID::firstValidRun(), forcedRunOffset_, and CrabTask::run.

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

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

void edm::RootFile::overrideRunNumber ( LuminosityBlockID &  id )

private

Definition at line 1432 of file RootFile.cc.

References edm::RunID::firstValidRun(), forcedRunOffset_, and CrabTask::run.

                                                   {
    if(forcedRunOffset_ != 0) {
      id = LuminosityBlockID(id.run() + forcedRunOffset_, id.luminosityBlock());
    }
    if(RunID(id.run()) < RunID::firstValidRun()) id = LuminosityBlockID(RunID::firstValidRun().run(), id.luminosityBlock());
  }

void edm::RootFile::overrideRunNumber ( EventID &  id, bool  isRealData  )

private

Definition at line 1440 of file RootFile.cc.

References edm::errors::Configuration, event(), edm::hlt::Exception, edm::LuminosityBlockID::firstValidLuminosityBlock(), edm::RunID::firstValidRun(), forcedRunOffset_, and CrabTask::run.

                                                          {
    if(forcedRunOffset_ != 0) {
      if(isRealData) {
        throw edm::Exception(errors::Configuration,"RootFile::RootFile()")
          << "The 'setRunNumber' parameter of PoolSource cannot be used with real data.\n";
      }
      id = EventID(id.run() + forcedRunOffset_, id.luminosityBlock(), id.event());
    }
    if(RunID(id.run()) < RunID::firstValidRun()) {
      id = EventID(RunID::firstValidRun().run(), LuminosityBlockID::firstValidLuminosityBlock().luminosityBlock(),id.event());
    }
  }

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

inline

Definition at line 81 of file RootFile.h.

References productRegistry_.

Referenced by RootFile().

{return productRegistry_;}

EventPrincipal * edm::RootFile::readCurrentEvent	(	EventPrincipal &	cache,
		boost::shared_ptr< LuminosityBlockPrincipal >	lb = boost::shared_ptr<LuminosityBlockPrincipal>()
	)

Definition at line 1245 of file RootFile.cc.

References printConversionInfo::aux, branchListIndexes_, edm::RootTree::current(), event(), eventAux(), eventAux_, eventID(), eventSelectionIDs_, eventTree_, fileFormatVersion(), filePtr_, edm::EventPrincipal::fillEventPrincipal(), fillHistory(), fillThisEventAuxiliary(), edm::EventAuxiliary::id(), edm::InEvent, edm::EventAuxiliary::isRealData(), makeBranchMapper(), edm::RootTree::makeDelayedReader(), edm::EventAuxiliary::oldLuminosityBlock(), overrideRunNumber(), edm::EventAuxiliary::resetObsoleteInfo(), and CrabTask::run.

Referenced by readEvent().

                                                                                                {
    if(!eventTree_.current()) {
      return 0;
    }
    fillThisEventAuxiliary();
    if(!fileFormatVersion().lumiInEventID()) {
        //ugly, but will disappear when the backward compatibility is done with schema evolution.
        const_cast<EventID&>(eventAux_.id()).setLuminosityBlockNumber(eventAux_.oldLuminosityBlock());
        eventAux_.resetObsoleteInfo();
    }
    fillHistory();
    overrideRunNumber(eventAux_.id(), eventAux().isRealData());

    std::auto_ptr<EventAuxiliary> aux(new EventAuxiliary(eventAux()));
    // We're not done ... so prepare the EventPrincipal
    cache.fillEventPrincipal(aux,
                             lb,
                             eventSelectionIDs_,
                             branchListIndexes_,
                             makeBranchMapper(eventTree_, InEvent),
                             eventTree_.makeDelayedReader(fileFormatVersion()));

    // report event read from file
    filePtr_->eventReadFromFile(eventID().run(), eventID().event());
    return &cache;
  }

void edm::RootFile::readEntryDescriptionTree ( )

private

Definition at line 407 of file RootFile.cc.

References edm::poolNames::entryDescriptionBranchName(), edm::poolNames::entryDescriptionIDBranchName(), edm::poolNames::entryDescriptionTreeName(), edm::errors::EventCorruption, edm::hlt::Exception, fileFormatVersion(), filePtr_, edm::errors::FileReadError, edm::input::getEntry(), i, edm::EventEntryDescription::id(), edm::detail::ThreadSafeRegistry< KEY, T, E >::insertMapped(), edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), edm::numEntries(), parents, edm::EventEntryDescription::parents(), edm::Parentage::parents(), and PhysicsTools::registry.

Referenced by readParentageTree().

                                     {
    // Called only for old format files.
    if(!fileFormatVersion().perEventProductIDs()) return;
    TTree* entryDescriptionTree = dynamic_cast<TTree*>(filePtr_->Get(poolNames::entryDescriptionTreeName().c_str()));
    if(!entryDescriptionTree)
      throw edm::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);

    EntryDescriptionRegistry& oldregistry = *EntryDescriptionRegistry::instance();

    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) {
      input::getEntry(entryDescriptionTree, i);
      if(idBuffer != entryDescriptionBuffer.id())
        throw edm::Exception(errors::EventCorruption) << "Corruption of EntryDescription tree detected.\n";
      oldregistry.insertMapped(entryDescriptionBuffer);
      Parentage parents;
      parents.parents() = entryDescriptionBuffer.parents();
      registry.insertMapped(parents);
    }
    entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionIDBranchName().c_str(), 0);
    entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionBranchName().c_str(), 0);
  }

EventPrincipal * edm::RootFile::readEvent	(	EventPrincipal &	cache,
		boost::shared_ptr< LuminosityBlockPrincipal >	lb = boost::shared_ptr<LuminosityBlockPrincipal>()
	)

Definition at line 1228 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), eventAux(), eventTree_, forcedRunOffset_, edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::IndexIntoFileItr::lumi(), readCurrentEvent(), CrabTask::run, edm::IndexIntoFile::IndexIntoFileItr::run(), and edm::RootTree::setEntryNumber().

                                                                                         {
    assert(indexIntoFileIter_ != indexIntoFileEnd_);
    assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kEvent);
    // Set the entry in the tree, and read the event at that entry.
    eventTree_.setEntryNumber(indexIntoFileIter_.entry());
    EventPrincipal* ep = readCurrentEvent(cache, lb);

    assert(ep != 0);
    assert(eventAux().run() == indexIntoFileIter_.run() + forcedRunOffset_);
    assert(eventAux().luminosityBlock() == indexIntoFileIter_.lumi());

    ++indexIntoFileIter_;
    return ep;
  }

void edm::RootFile::readEventHistoryTree ( )

private

Definition at line 1455 of file RootFile.cc.

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

Referenced by RootFile().

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

boost::shared_ptr< LuminosityBlockPrincipal > edm::RootFile::readLumi

(

boost::shared_ptr< LuminosityBlockPrincipal >

lbCache

)

Definition at line 1381 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), fileFormatVersion(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::InLumi, edm::RootTree::isValid(), edm::IndexIntoFile::kLumi, lumiTree_, makeBranchMapper(), edm::RootTree::makeDelayedReader(), 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()) {
      ++indexIntoFileIter_;
      return lbCache;
    }
    // End code for backward compatibility before the existence of lumi trees.
    lumiTree_.setEntryNumber(indexIntoFileIter_.entry());
    lbCache->fillLuminosityBlockPrincipal(makeBranchMapper(lumiTree_, InLumi),
                                         lumiTree_.makeDelayedReader(fileFormatVersion()));
    // Read in all the products now.
    lbCache->readImmediate();
    ++indexIntoFileIter_;
    return lbCache;
  }

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

(

)

Definition at line 1337 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), eventAux(), eventTree_, fileFormatVersion(), filePtr_, fillLumiAuxiliary(), fillThisEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFile_, indexIntoFileEnd_, indexIntoFileIter_, edm::Timestamp::invalidTimestamp(), edm::RootTree::isValid(), edm::IndexIntoFile::kLumi, fjr2json::lumi, edm::IndexIntoFile::IndexIntoFileItr::lumi(), edm::LuminosityBlockID::luminosityBlock(), lumiTree_, edm::RootTree::next(), overrideRunNumber(), edm::RootTree::previous(), edm::IndexIntoFile::processHistoryID(), edm::IndexIntoFile::IndexIntoFileItr::processHistoryIDIndex(), edm::LuminosityBlockID::run(), edm::IndexIntoFile::IndexIntoFileItr::run(), edm::RootTree::setEntryNumber(), cond::rpcobgas::time, and edm::EventAuxiliary::time().

                                          {
    assert(indexIntoFileIter_ != indexIntoFileEnd_);
    assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kLumi);
    // Begin code for backward compatibility before the existence of lumi trees.
    if(!lumiTree_.isValid()) {
      if(eventTree_.next()) {
        fillThisEventAuxiliary();
        // back up, so event will not be skipped.
        eventTree_.previous();
      }

      LuminosityBlockID lumi = LuminosityBlockID(indexIntoFileIter_.run(), indexIntoFileIter_.lumi());
      overrideRunNumber(lumi);
      return boost::shared_ptr<LuminosityBlockAuxiliary>(new LuminosityBlockAuxiliary(lumi.run(), lumi.luminosityBlock(), eventAux().time(), Timestamp::invalidTimestamp()));
    }
    // End code for backward compatibility before the existence of lumi trees.
    lumiTree_.setEntryNumber(indexIntoFileIter_.entry());
    boost::shared_ptr<LuminosityBlockAuxiliary> lumiAuxiliary = fillLumiAuxiliary();
    assert(lumiAuxiliary->run() == indexIntoFileIter_.run());
    assert(lumiAuxiliary->luminosityBlock() == indexIntoFileIter_.lumi());
    overrideRunNumber(lumiAuxiliary->id());
    filePtr_->reportInputLumiSection(lumiAuxiliary->run(), lumiAuxiliary->luminosityBlock());

    if(lumiAuxiliary->beginTime() == Timestamp::invalidTimestamp()) {
      // LuminosityBlockAuxiliary did not contain a timestamp. Take it from the next event.
      if(eventTree_.next()) {
        fillThisEventAuxiliary();
        // back up, so event will not be skipped.
        eventTree_.previous();
      }
      lumiAuxiliary->setBeginTime(eventAux().time());
      lumiAuxiliary->setEndTime(Timestamp::invalidTimestamp());
    }
    if(fileFormatVersion().processHistorySameWithinRun()) {
      ProcessHistoryID phid = indexIntoFile_.processHistoryID(indexIntoFileIter_.processHistoryIDIndex());
      assert(lumiAuxiliary->processHistoryID() == phid);
    } else {
      ProcessHistoryID phid = indexIntoFile_.processHistoryID(indexIntoFileIter_.processHistoryIDIndex());
      lumiAuxiliary->setProcessHistoryID(phid);
    }
    return lumiAuxiliary;
  }

void edm::RootFile::readParentageTree ( )

private

Definition at line 443 of file RootFile.cc.

References edm::hlt::Exception, fileFormatVersion(), filePtr_, edm::errors::FileReadError, edm::input::getEntry(), i, edm::detail::ThreadSafeRegistry< KEY, T, E >::insertMapped(), edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), edm::numEntries(), edm::poolNames::parentageBranchName(), edm::poolNames::parentageTreeName(), readEntryDescriptionTree(), and PhysicsTools::registry.

Referenced by RootFile().

                              {
    if(!fileFormatVersion().splitProductIDs()) {
      // Old format file.
      readEntryDescriptionTree();
      return;
    }
    // New format file
    TTree* parentageTree = dynamic_cast<TTree*>(filePtr_->Get(poolNames::parentageTreeName().c_str()));
    if(!parentageTree)
      throw edm::Exception(errors::FileReadError) << "Could not find tree " << poolNames::parentageTreeName()
                                                         << " in the input file.\n";

    Parentage parentageBuffer;
    Parentage *pParentageBuffer = &parentageBuffer;
    parentageTree->SetBranchAddress(poolNames::parentageBranchName().c_str(), &pParentageBuffer);

    ParentageRegistry& registry = *ParentageRegistry::instance();

    for(Long64_t i = 0, numEntries = parentageTree->GetEntries(); i < numEntries; ++i) {
      input::getEntry(parentageTree, i);
      registry.insertMapped(parentageBuffer);
    }
    parentageTree->SetBranchAddress(poolNames::parentageBranchName().c_str(), 0);
  }

boost::shared_ptr< RunPrincipal > edm::RootFile::readRun_

(

boost::shared_ptr< RunPrincipal >

rpCache

)

Definition at line 1320 of file RootFile.cc.

References fileFormatVersion(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, edm::InRun, edm::RootTree::isValid(), edm::IndexIntoFile::kRun, makeBranchMapper(), edm::RootTree::makeDelayedReader(), and runTree_.

                                                          {
    assert(indexIntoFileIter_ != indexIntoFileEnd_);
    assert(indexIntoFileIter_.getEntryType() == IndexIntoFile::kRun);
    // Begin code for backward compatibility before the existence of run trees.
    if(!runTree_.isValid()) {
      ++indexIntoFileIter_;
      return rpCache;
    }
    // End code for backward compatibility before the existence of run trees.
    rpCache->fillRunPrincipal(makeBranchMapper(runTree_, InRun), runTree_.makeDelayedReader(fileFormatVersion()));
    // Read in all the products now.
    rpCache->readImmediate();
    ++indexIntoFileIter_;
    return rpCache;
  }

boost::shared_ptr< RunAuxiliary > edm::RootFile::readRunAuxiliary_

(

)

Definition at line 1278 of file RootFile.cc.

References edm::IndexIntoFile::IndexIntoFileItr::entry(), eventAux(), eventTree_, fileFormatVersion(), filePtr_, fillRunAuxiliary(), fillThisEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFile_, indexIntoFileEnd_, indexIntoFileIter_, edm::Timestamp::invalidTimestamp(), edm::RootTree::isValid(), edm::IndexIntoFile::kRun, edm::RootTree::next(), overrideRunNumber(), edm::RootTree::previous(), edm::IndexIntoFile::processHistoryID(), edm::IndexIntoFile::IndexIntoFileItr::processHistoryIDIndex(), edm::FileFormatVersion::processHistorySameWithinRun(), edm::RunID::run(), CrabTask::run, edm::IndexIntoFile::IndexIntoFileItr::run(), runTree_, edm::RootTree::setEntryNumber(), cond::rpcobgas::time, and edm::EventAuxiliary::time().

                              {
    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.
      if(eventTree_.next()) {
        fillThisEventAuxiliary();
        // back up, so event will not be skipped.
        eventTree_.previous();
      }
      RunID run = RunID(indexIntoFileIter_.run());
      overrideRunNumber(run);
      return boost::shared_ptr<RunAuxiliary>(new RunAuxiliary(run.run(), eventAux().time(), Timestamp::invalidTimestamp()));
    }
    // End code for backward compatibility before the existence of run trees.
    runTree_.setEntryNumber(indexIntoFileIter_.entry());
    boost::shared_ptr<RunAuxiliary> runAuxiliary = fillRunAuxiliary();
    assert(runAuxiliary->run() == indexIntoFileIter_.run());
    overrideRunNumber(runAuxiliary->id());
    filePtr_->reportInputRunNumber(runAuxiliary->run());
    if(runAuxiliary->beginTime() == Timestamp::invalidTimestamp()) {
      // RunAuxiliary did not contain a valid timestamp.  Take it from the next event.
      if(eventTree_.next()) {
        fillThisEventAuxiliary();
        // back up, so event will not be skipped.
        eventTree_.previous();
      }
      runAuxiliary->setBeginTime(eventAux().time());
      runAuxiliary->setEndTime(Timestamp::invalidTimestamp());
    }
    ProcessHistoryID phid = indexIntoFile_.processHistoryID(indexIntoFileIter_.processHistoryIDIndex());
    if(fileFormatVersion().processHistorySameWithinRun()) {
      assert(runAuxiliary->processHistoryID() == phid);
    } else {
      runAuxiliary->setProcessHistoryID(phid);
    }
    return runAuxiliary;
  }

void edm::RootFile::reportOpened

(

std::string const &

inputType

)

Definition at line 977 of file RootFile.cc.

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

                                                   {
    // 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 104 of file RootFile.h.

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

                  {
      indexIntoFileIter_ = indexIntoFileBegin_;
      eventTree_.rewind();
      lumiTree_.rewind();
      runTree_.rewind();
    }

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

inline

Definition at line 90 of file RootFile.h.

References runTree_.

Referenced by validateFile().

{return runTree_;}

void edm::RootFile::setAtEventEntry

(

IndexIntoFile::EntryNumber_t

entry

)

Definition at line 1273 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 1400 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 96 of file RootFile.h.

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

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

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

Definition at line 1408 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::setEntryAtRun

(

RunNumber_t

run

)

Definition at line 1416 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 469 of file RootFile.cc.

References duplicateChecker_, edm::FileBlock::DuplicateEventsRemoved, edm::RootTree::entries(), 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_, edm::FileBlock::NotProcessingEvents, edm::IndexIntoFile::numericalOrder, processingMode_, edm::InputSource::RunsLumisAndEvents, skipAnyEvents_, and whyNotFastClonable_.

Referenced by RootFile().

                                                                     {
    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 = IndexIntoFile::numericalOrder;
    if (noEventSort_) sortOrder = IndexIntoFile::firstAppearanceOrder;
    if(!indexIntoFile_.iterationWillBeInEntryOrder(sortOrder)) {
      whyNotFastClonable_ += 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;
    }
    // We no longer fast copy the EventAuxiliary branch, so there
    // is no longer any need to disable fast copying because the run
    // number is being modified.   Also, this check did not work anyway
    // because this function is called before forcedRunOffset_ is set.

    // if(forcedRunOffset_ != 0) {
    //   whyNotFastClonable_ += FileBlock::RunNumberModified;
    // }
    if(duplicateChecker_ &&
      !duplicateChecker_->checkDisabled() &&
      !duplicateChecker_->noDuplicatesInFile()) {
      whyNotFastClonable_ += FileBlock::DuplicateEventsRemoved;
    }
  }

void edm::RootFile::setPosition

(

IndexIntoFile::IndexIntoFileItr const &

position

)

Definition at line 549 of file RootFile.cc.

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

                                                                     {
    indexIntoFileIter_.copyPosition(position);
  }

void edm::RootFile::setToLastEntry ( )

inline

Definition at line 110 of file RootFile.h.

References indexIntoFileEnd_, and indexIntoFileIter_.

                          {
      indexIntoFileIter_ = indexIntoFileEnd_;
    }

bool edm::RootFile::skipEvents

(

int &

offset

)

Definition at line 1119 of file RootFile.cc.

References duplicateChecker_, edm::EventID::event(), eventAux_, eventSkipperByID_, eventTree_, file_, fillEventAuxiliary(), fillThisEventAuxiliary(), edm::EventAuxiliary::id(), indexIntoFileEnd_, indexIntoFileIter_, edm::IndexIntoFile::invalidEntry, edm::IndexIntoFile::invalidIndex, edm::IndexIntoFile::invalidLumi, edm::IndexIntoFile::invalidRun, evf::evtn::offset(), edm::RootTree::resetTraining(), edm::RootTree::setEntryNumber(), 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()) {
        eventTree_.setEntryNumber(skippedEventEntry);
        fillThisEventAuxiliary();
        if (eventSkipperByID_->skipIt(runOfSkippedEvent, lumiOfSkippedEvent, eventAux_.id().event())) {
            continue;
        }
      }
      if(duplicateChecker_ &&
         !duplicateChecker_->checkDisabled() &&
         !duplicateChecker_->noDuplicatesInFile()) {

        eventTree_.setEntryNumber(skippedEventEntry);
        fillThisEventAuxiliary();
        if (duplicateChecker_->isDuplicateAndCheckActive(phIndexOfSkippedEvent,
                                                         runOfSkippedEvent,
                                                         lumiOfSkippedEvent,
                                                         eventAux_.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;
      EntryNumber_t eventEntry = IndexIntoFile::invalidEntry;

      indexIntoFileIter_.skipEventBackward(phIndexOfEvent,
                                           runOfEvent,
                                           lumiOfEvent,
                                           eventEntry);

      if (eventEntry == IndexIntoFile::invalidEntry) break;

      if (eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
        eventTree_.setEntryNumber(eventEntry);
        fillEventAuxiliary();
        if (eventSkipperByID_->skipIt(runOfEvent, lumiOfEvent, eventAux_.id().event())) {
          continue;
        }
      }
      ++offset;
    }

    eventTree_.resetTraining();

    return (indexIntoFileIter_ == indexIntoFileEnd_);
  }

bool edm::RootFile::skipThisEntry ( )

private

Definition at line 554 of file RootFile.cc.

References edm::EventID::event(), eventAux_, eventSkipperByID_, fillEventAuxiliary(), edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), edm::EventAuxiliary::id(), 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 getEntryTypeWithSkipping().

                          {
    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) {
        fillEventAuxiliary();
        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()) {
        IndexIntoFile::IndexIntoFileItr iterLumi = indexIntoFileIter_;

        // There are no lumis in this run, not even ones we will skip
        if (iterLumi.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(iterLumi.run(), iterLumi.peekAheadAtLumi(), 0U)) {
            return false;
          }
        }
        while(iterLumi.skipLumiInRun());
        return true;
      }
    }
    return false;
  }

RootTreePtrArray& edm::RootFile::treePointers ( )

inlineprivate

Definition at line 127 of file RootFile.h.

References treePointers_.

{return treePointers_;}

void edm::RootFile::validateFile ( bool  secondaryFile, bool  usingGoToEvent  )

private

Definition at line 939 of file RootFile.cc.

References edm::createGlobalIdentifier(), duplicateChecker_, edm::IndexIntoFile::empty(), edm::RootTree::entries(), python.tagInventory::entries, edm::errors::EventCorruption, eventTree_, edm::hlt::Exception, fid_, fileFormatVersion(), edm::IndexIntoFile::fillEventNumbersOrEntries(), fillIndexIntoFile(), edm::IndexIntoFile::fixIndexes(), indexIntoFile_, edm::FileID::isValid(), edm::RootTree::isValid(), noEventSort_, orderedProcessHistoryIDs_, runTree(), edm::IndexIntoFile::setEventFinder(), and edm::IndexIntoFile::setNumberOfEvents().

Referenced by RootFile().

                                                                {
    if(!fid_.isValid()) {
      fid_ = FileID(createGlobalIdentifier());
    }
    if(!eventTree_.isValid()) {
      throw edm::Exception(errors::EventCorruption) <<
         "'Events' tree is corrupted or not present\n" << "in the input file.\n";
    }

    if (fileFormatVersion().hasIndexIntoFile()) {
      if (runTree().entries() > 0) {
        assert(!indexIntoFile_.empty());
      }
    }
    else {
      assert(indexIntoFile_.empty());
      fillIndexIntoFile();
    }

    indexIntoFile_.fixIndexes(orderedProcessHistoryIDs_);
    indexIntoFile_.setNumberOfEvents(eventTree_.entries());
    indexIntoFile_.setEventFinder(boost::shared_ptr<IndexIntoFile::EventFinder>(new 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 (secondaryFile || needIndexesForDuplicateChecker || usingGoToEvent) {
      needEventNumbers = true;
    }
    bool needEventEntries = false;
    if (secondaryFile || !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 657 of file RootFile.cc.

References indexIntoFileIter_, edm::IndexIntoFile::invalidEntry, fjr2json::lumi, CrabTask::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 650 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 92 of file RootFile.h.

References whyNotFastClonable_.

Referenced by createFileBlock().

{return whyNotFastClonable_;}

Member Data Documentation

boost::shared_ptr<BranchChildren> edm::RootFile::branchChildren_

private

Definition at line 188 of file RootFile.h.

Referenced by createFileBlock(), dropOnInput(), and RootFile().

boost::shared_ptr<BranchIDListRegistry::collection_type const> edm::RootFile::branchIDLists_

private

Definition at line 180 of file RootFile.h.

Referenced by branchIDLists(), and RootFile().

boost::shared_ptr<BranchListIndexes> edm::RootFile::branchListIndexes_

private

Definition at line 186 of file RootFile.h.

Referenced by fillHistory(), and readCurrentEvent().

bool edm::RootFile::branchListIndexesUnchanged_

private

Definition at line 172 of file RootFile.h.

Referenced by branchListIndexesUnchanged(), and RootFile().

boost::shared_ptr<DuplicateChecker> edm::RootFile::duplicateChecker_

private

Definition at line 189 of file RootFile.h.

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

EventAuxiliary edm::RootFile::eventAux_

private

Definition at line 173 of file RootFile.h.

Referenced by eventAux(), fillHistory(), fillIndexIntoFile(), fillThisEventAuxiliary(), isDuplicateEvent(), readCurrentEvent(), skipEvents(), and skipThisEntry().

TTree* edm::RootFile::eventHistoryTree_

private

Definition at line 184 of file RootFile.h.

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

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

private

Definition at line 166 of file RootFile.h.

Referenced by fillHistory(), and RootFile().

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

private

Definition at line 167 of file RootFile.h.

Referenced by fillHistory(), and RootFile().

boost::shared_ptr<EventSelectionIDVector> edm::RootFile::eventSelectionIDs_

private

Definition at line 185 of file RootFile.h.

Referenced by fillHistory(), and readCurrentEvent().

boost::shared_ptr<EventSkipperByID> edm::RootFile::eventSkipperByID_

private

Definition at line 157 of file RootFile.h.

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

RootTree edm::RootFile::eventTree_

private

Definition at line 174 of file RootFile.h.

Referenced by createFileBlock(), eventTree(), fillEventAuxiliary(), fillHistory(), fillIndexIntoFile(), fillThisEventAuxiliary(), initializeDuplicateChecker(), nextEventEntry(), readCurrentEvent(), readEvent(), readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), reportOpened(), rewind(), RootFile(), setAtEventEntry(), setEntryAtEvent(), setIfFastClonable(), skipEvents(), and validateFile().

FileID edm::RootFile::fid_

private

Definition at line 159 of file RootFile.h.

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

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

private

Definition at line 153 of file RootFile.h.

Referenced by createFileBlock(), dropOnInput(), file(), isDuplicateEvent(), RootFile(), and skipEvents().

FileFormatVersion edm::RootFile::fileFormatVersion_

private

Definition at line 158 of file RootFile.h.

Referenced by fileFormatVersion(), and RootFile().

boost::shared_ptr<InputFile> edm::RootFile::filePtr_

private

Definition at line 156 of file RootFile.h.

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

int edm::RootFile::forcedRunOffset_

private

Definition at line 182 of file RootFile.h.

Referenced by overrideRunNumber(), readEvent(), and RootFile().

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

private

Definition at line 171 of file RootFile.h.

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

boost::shared_ptr<History> edm::RootFile::history_

private

Definition at line 187 of file RootFile.h.

Referenced by fillHistory(), and readEventHistoryTree().

IndexIntoFile& edm::RootFile::indexIntoFile_

private

Definition at line 161 of file RootFile.h.

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

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileBegin_

private

Definition at line 163 of file RootFile.h.

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

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileEnd_

private

Definition at line 164 of file RootFile.h.

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

IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileIter_

private

Definition at line 165 of file RootFile.h.

Referenced by fillEventAuxiliary(), getEntryTypeWithSkipping(), getNextEntryTypeWanted(), goToEvent(), indexIntoFileIter(), isDuplicateEvent(), readEvent(), readLumi(), readLuminosityBlockAuxiliary_(), readRun_(), readRunAuxiliary_(), rewind(), RootFile(), setEntryAtEvent(), setEntryAtLumi(), setEntryAtRun(), setPosition(), setToLastEntry(), skipEvents(), skipThisEntry(), wasFirstEventJustRead(), and wasLastEventJustRead().

boost::shared_ptr<IndexIntoFile> edm::RootFile::indexIntoFileSharedPtr_

private

Definition at line 160 of file RootFile.h.

Referenced by indexIntoFileSharedPtr().

IndexIntoFile::EntryNumber_t edm::RootFile::lastEventEntryNumberRead_

private

Definition at line 178 of file RootFile.h.

Referenced by fillIndexIntoFile(), and fillThisEventAuxiliary().

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

private

Definition at line 154 of file RootFile.h.

Referenced by reportOpened().

RootTree edm::RootFile::lumiTree_

private

Definition at line 175 of file RootFile.h.

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

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

private

Definition at line 183 of file RootFile.h.

Referenced by newBranchToOldBranch(), and RootFile().

bool edm::RootFile::noEventSort_

private

Definition at line 169 of file RootFile.h.

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

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

private

Definition at line 162 of file RootFile.h.

Referenced by validateFile().

ProcessConfiguration const& edm::RootFile::processConfiguration_

private

Definition at line 155 of file RootFile.h.

InputSource::ProcessingMode edm::RootFile::processingMode_

private

Definition at line 181 of file RootFile.h.

Referenced by getNextEntryTypeWanted(), and setIfFastClonable().

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

private

Definition at line 179 of file RootFile.h.

Referenced by makeBranchMapper(), productRegistry(), and RootFile().

boost::shared_ptr<ProvenanceAdaptor> edm::RootFile::provenanceAdaptor_

private

Definition at line 190 of file RootFile.h.

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

RootTree edm::RootFile::runTree_

private

Definition at line 176 of file RootFile.h.

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

bool edm::RootFile::skipAnyEvents_

private

Definition at line 168 of file RootFile.h.

Referenced by setIfFastClonable().

RootTreePtrArray edm::RootFile::treePointers_

private

Definition at line 177 of file RootFile.h.

Referenced by close(), dropOnInput(), RootFile(), and treePointers().

int edm::RootFile::whyNotFastClonable_

private

Definition at line 170 of file RootFile.h.

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