edm::RootOutputFile Class Reference

#include <RootOutputFile.h>

Public Types
typedef PoolOutputModule::OutputItem	OutputItem
typedef PoolOutputModule::OutputItemList	OutputItemList
typedef std::array< edm::propagate_const< RootOutputTree * >, NumBranchTypes >	RootOutputTreePtrArray

Public Member Functions
void	beginInputFile (FileBlock const &fb, int remainingEvents)
std::string const &	fileName () const
void	finishEndFile ()
void	respondToCloseInputFile (FileBlock const &fb)
	RootOutputFile (PoolOutputModule *om, std::string const &fileName, std::string const &logicalFileName, std::vector< std::string > const &processesWithSelectedMergeableRunProducts)
bool	shouldWeCloseFile () const
void	writeBranchIDListRegistry ()
void	writeEventAuxiliary ()
void	writeFileFormatVersion ()
void	writeFileIdentifier ()
void	writeIndexIntoFile ()
void	writeLuminosityBlock (LuminosityBlockForOutput const &lb)
void	writeOne (EventForOutput const &e)
void	writeParameterSetRegistry ()
void	writeParentageRegistry ()
void	writeProcessHistoryRegistry ()
void	writeProductDependencies ()
void	writeProductDescriptionRegistry ()
void	writeRun (RunForOutput const &r)
void	writeStoredMergeableRunProductMetadata ()
void	writeThinnedAssociationsHelper ()
	~RootOutputFile ()

Private Member Functions
std::shared_ptr< TFile > &	filePtr ()
std::shared_ptr< TFile const >	filePtr () const
void	fillBranches (BranchType const &branchType, OccurrenceForOutput const &occurrence, StoredProductProvenanceVector *productProvenanceVecPtr=nullptr, ProductProvenanceRetriever const *provRetriever=nullptr)
void	insertAncestors (ProductProvenance const &iGetParents, ProductProvenanceRetriever const *iMapper, bool produced, std::set< BranchID > const &producedBranches, std::set< StoredProductProvenance > &oToFill)
bool	insertProductProvenance (const ProductProvenance &, std::set< StoredProductProvenance > &oToInsert)
StoredProductProvenanceVector *&	pEventEntryInfoVector ()
StoredProductProvenanceVector const *	pEventEntryInfoVector () const
void	setBranchAliases (TTree *tree, SelectedProducts const &branches) const

Private Attributes
std::set< BranchID >	branchesWithStoredHistory_
bool	canFastCloneAux_
CompactEventAuxiliaryVector	compactEventAuxiliary_
bool	dataTypeReported_
StoredProductProvenanceVector	eventEntryInfoVector_
IndexIntoFile::EntryNumber_t	eventEntryNumber_
RootOutputTree	eventTree_
FileID	fid_
std::string	file_
edm::propagate_const< std::shared_ptr< TFile > >	filePtr_
IndexIntoFile	indexIntoFile_
std::string	logicalFile_
LuminosityBlockAuxiliary	lumiAux_
IndexIntoFile::EntryNumber_t	lumiEntryNumber_
RootOutputTree	lumiTree_
edm::propagate_const< TTree * >	metaDataTree_
unsigned long	nEventsInLumi_
edm::propagate_const< PoolOutputModule * >	om_
edm::propagate_const< TTree * >	parameterSetsTree_
std::map< ParentageID, unsigned int >	parentageIDs_
edm::propagate_const< TTree * >	parentageTree_
BranchListIndexes const *	pBranchListIndexes_
EventAuxiliary const *	pEventAux_
edm::propagate_const< StoredProductProvenanceVector * >	pEventEntryInfoVector_
EventSelectionIDVector const *	pEventSelectionIDs_
LuminosityBlockAuxiliary const *	pLumiAux_
ProcessHistoryRegistry	processHistoryRegistry_
RunAuxiliary const *	pRunAux_
JobReport::Token	reportToken_
RunAuxiliary	runAux_
IndexIntoFile::EntryNumber_t	runEntryNumber_
RootOutputTree	runTree_
StoredMergeableRunProductMetadata	storedMergeableRunProductMetadata_
RootOutputTreePtrArray	treePointers_
int	whyNotFastClonable_
edm::propagate_const< TClass * >	wrapperBaseTClass_

Detailed Description

Definition at line 46 of file RootOutputFile.h.

Member Typedef Documentation

OutputItem

typedef PoolOutputModule::OutputItem edm::RootOutputFile::OutputItem

Definition at line 48 of file RootOutputFile.h.

OutputItemList

typedef PoolOutputModule::OutputItemList edm::RootOutputFile::OutputItemList

Definition at line 49 of file RootOutputFile.h.

RootOutputTreePtrArray

typedef std::array<edm::propagate_const<RootOutputTree*>, NumBranchTypes> edm::RootOutputFile::RootOutputTreePtrArray

Definition at line 50 of file RootOutputFile.h.

Constructor & Destructor Documentation

RootOutputFile()

edm::RootOutputFile::RootOutputFile ( PoolOutputModule *  om, std::string const &  fileName, std::string const &  logicalFileName, std::vector< std::string > const &  processesWithSelectedMergeableRunProducts  )

explicit

Definition at line 81 of file RootOutputFile.cc.

      : file_(fileName),
        logicalFile_(logicalFileName),
        reportToken_(0),
        om_(om),
        whyNotFastClonable_(om_->whyNotFastClonable()),
        canFastCloneAux_(false),
        filePtr_(openTFile(file_.c_str(), om_->compressionLevel())),
        fid_(),
        eventEntryNumber_(0LL),
        lumiEntryNumber_(0LL),
        runEntryNumber_(0LL),
        indexIntoFile_(),
        storedMergeableRunProductMetadata_(processesWithSelectedMergeableRunProducts),
        nEventsInLumi_(0),
        metaDataTree_(nullptr),
        parameterSetsTree_(nullptr),
        parentageTree_(nullptr),
        lumiAux_(),
        runAux_(),
        pEventAux_(nullptr),
        pLumiAux_(&lumiAux_),
        pRunAux_(&runAux_),
        eventEntryInfoVector_(),
        pEventEntryInfoVector_(&eventEntryInfoVector_),
        pBranchListIndexes_(nullptr),
        pEventSelectionIDs_(nullptr),
        eventTree_(filePtr(), InEvent, om_->splitLevel(), om_->treeMaxVirtualSize()),
        lumiTree_(filePtr(), InLumi, om_->splitLevel(), om_->treeMaxVirtualSize()),
        runTree_(filePtr(), InRun, om_->splitLevel(), om_->treeMaxVirtualSize()),
        treePointers_(),
        dataTypeReported_(false),
        processHistoryRegistry_(),
        parentageIDs_(),
        branchesWithStoredHistory_(),
        wrapperBaseTClass_(TClass::GetClass("edm::WrapperBase")) {
    if (om_->compressionAlgorithm() == std::string("ZLIB")) {
      filePtr_->SetCompressionAlgorithm(ROOT::kZLIB);
    } else if (om_->compressionAlgorithm() == std::string("LZMA")) {
      filePtr_->SetCompressionAlgorithm(ROOT::kLZMA);
    } else {
      throw Exception(errors::Configuration)
          << "PoolOutputModule configured with unknown compression algorithm '" << om_->compressionAlgorithm() << "'\n"
          << "Allowed compression algorithms are ZLIB and LZMA\n";
    }
    if (-1 != om->eventAutoFlushSize()) {
      eventTree_.setAutoFlush(-1 * om->eventAutoFlushSize());
    }
    if (om_->compactEventAuxiliary()) {
      eventTree_.addAuxiliary<EventAuxiliary>(
          BranchTypeToAuxiliaryBranchName(InEvent), pEventAux_, om_->auxItems()[InEvent].basketSize_, false);
      eventTree_.tree()->SetBranchStatus(BranchTypeToAuxiliaryBranchName(InEvent).c_str(),
                                         false);  // see writeEventAuxiliary
    } else {
      eventTree_.addAuxiliary<EventAuxiliary>(
          BranchTypeToAuxiliaryBranchName(InEvent), pEventAux_, om_->auxItems()[InEvent].basketSize_);
    }
 
    eventTree_.addAuxiliary<StoredProductProvenanceVector>(BranchTypeToProductProvenanceBranchName(InEvent),
                                                           pEventEntryInfoVector(),
                                                           om_->auxItems()[InEvent].basketSize_);
    eventTree_.addAuxiliary<EventSelectionIDVector>(
        poolNames::eventSelectionsBranchName(), pEventSelectionIDs_, om_->auxItems()[InEvent].basketSize_, false);
    eventTree_.addAuxiliary<BranchListIndexes>(
        poolNames::branchListIndexesBranchName(), pBranchListIndexes_, om_->auxItems()[InEvent].basketSize_);
 
    lumiTree_.addAuxiliary<LuminosityBlockAuxiliary>(
        BranchTypeToAuxiliaryBranchName(InLumi), pLumiAux_, om_->auxItems()[InLumi].basketSize_);
 
    runTree_.addAuxiliary<RunAuxiliary>(
        BranchTypeToAuxiliaryBranchName(InRun), pRunAux_, om_->auxItems()[InRun].basketSize_);
 
    treePointers_[InEvent] = &eventTree_;
    treePointers_[InLumi] = &lumiTree_;
    treePointers_[InRun] = &runTree_;
    treePointers_[InProcess] = nullptr;
 
    for (int i = InEvent; i < NumBranchTypes; ++i) {
      if (i == InProcess) {
        // Output for ProcessBlocks is not implemented yet.
        continue;
      }
      BranchType branchType = static_cast<BranchType>(i);
      RootOutputTree* theTree = treePointers_[branchType];
      for (auto& item : om_->selectedOutputItemList()[branchType]) {
        item.setProduct(nullptr);
        BranchDescription const& desc = *item.branchDescription();
        theTree->addBranch(desc.branchName(),
                           desc.wrappedName(),
                           item.product(),
                           item.splitLevel(),
                           item.basketSize(),
                           item.branchDescription()->produced());
        //make sure we always store product registry info for all branches we create
        branchesWithStoredHistory_.insert(item.branchID());
      }
    }
    // Don't split metadata tree or event description tree
    metaDataTree_ = RootOutputTree::makeTTree(filePtr_.get(), poolNames::metaDataTreeName(), 0);
    parentageTree_ = RootOutputTree::makeTTree(filePtr_.get(), poolNames::parentageTreeName(), 0);
    parameterSetsTree_ = RootOutputTree::makeTTree(filePtr_.get(), poolNames::parameterSetsTreeName(), 0);
 
    fid_ = FileID(createGlobalIdentifier());
 
    // For the Job Report, get a vector of branch names in the "Events" tree.
    // Also create a hash of all the branch names in the "Events" tree
    // in a deterministic order, except use the full class name instead of the friendly class name.
    // To avoid extra string copies, we create a vector of pointers into the product registry,
    // and use a custom comparison operator for sorting.
    std::vector<std::string> branchNames;
    std::vector<BranchDescription const*> branches;
    branchNames.reserve(om_->selectedOutputItemList()[InEvent].size());
    branches.reserve(om->selectedOutputItemList()[InEvent].size());
    for (auto const& item : om_->selectedOutputItemList()[InEvent]) {
      branchNames.push_back(item.branchDescription()->branchName());
      branches.push_back(item.branchDescription());
    }
    // Now sort the branches for the hash.
    sort_all(branches, sorterForJobReportHash);
    // Now, make a concatenated string.
    std::ostringstream oss;
    char const underscore = '_';
    for (auto const& branch : branches) {
      BranchDescription const& bd = *branch;
      oss << bd.fullClassName() << underscore << bd.moduleLabel() << underscore << bd.productInstanceName()
          << underscore << bd.processName() << underscore;
    }
    std::string stringrep = oss.str();
    cms::Digest md5alg(stringrep);
 
    // Register the output file with the JobReport service
    // and get back the token for it.
    std::string moduleName = "PoolOutputModule";
    Service<JobReport> reportSvc;
    reportToken_ = reportSvc->outputFileOpened(file_,
                                               logicalFile_,        // PFN and LFN
                                               om_->catalog(),      // catalog
                                               moduleName,          // module class name
                                               om_->moduleLabel(),  // module label
                                               fid_.fid(),          // file id (guid)
                                               std::string(),       // data type (not yet known, so string is empty).
                                               md5alg.digest().toString(),  // branch hash
                                               branchNames);                // branch names being written
  }

References edm::RootOutputTree::addAuxiliary(), edm::RootOutputTree::addBranch(), MicroEventContent_cff::branch, branchesWithStoredHistory_, edm::poolNames::branchListIndexesBranchName(), edm::BranchTypeToAuxiliaryBranchName(), edm::BranchTypeToProductProvenanceBranchName(), edm::errors::Configuration, edm::createGlobalIdentifier(), submitPVResolutionJobs::desc, cms::Digest::digest(), edm::PoolOutputModule::eventAutoFlushSize(), edm::poolNames::eventSelectionsBranchName(), eventTree_, Exception, edm::FileID::fid(), fid_, file_, filePtr_, edm::propagate_const< T >::get(), mps_fire::i, edm::InEvent, edm::InLumi, edm::InProcess, edm::InRun, B2GTnPMonitor_cfi::item, logicalFile_, lumiTree_, edm::RootOutputTree::makeTTree(), metaDataTree_, edm::poolNames::metaDataTreeName(), edm::moduleName(), edm::NumBranchTypes, om_, parameterSetsTree_, edm::poolNames::parameterSetsTreeName(), parentageTree_, edm::poolNames::parentageTreeName(), pBranchListIndexes_, pEventAux_, pEventEntryInfoVector(), pEventSelectionIDs_, pLumiAux_, pRunAux_, reportToken_, runTree_, edm::PoolOutputModule::selectedOutputItemList(), edm::RootOutputTree::setAutoFlush(), edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, cms::MD5Result::toString(), edm::RootOutputTree::tree(), and treePointers_.

~RootOutputFile()

edm::RootOutputFile::~RootOutputFile ( )

inline

Definition at line 55 of file RootOutputFile.h.

{}

Member Function Documentation

beginInputFile()

void edm::RootOutputFile::beginInputFile	(	FileBlock const &	fb,
		int	remainingEvents
	)

Definition at line 317 of file RootOutputFile.cc.

                                                                              {
    // Reset per input file information
    whyNotFastClonable_ = om_->whyNotFastClonable();
    canFastCloneAux_ = false;
 
    if (fb.tree() != nullptr) {
      whyNotFastClonable_ |= fb.whyNotFastClonable();
 
      if (remainingEvents >= 0 && remainingEvents < fb.tree()->GetEntries()) {
        whyNotFastClonable_ |= FileBlock::OutputMaxEventsTooSmall;
      }
 
      bool match = eventTree_.checkSplitLevelsAndBasketSizes(fb.tree());
      if (!match) {
        if (om_->overrideInputFileSplitLevels()) {
          // We may be fast copying.  We must disable fast copying if the split levels
          // or basket sizes do not match.
          whyNotFastClonable_ |= FileBlock::SplitLevelMismatch;
        } else {
          // We are using the input split levels and basket sizes from the first input file
          // for copied output branches.  In this case, we throw an exception if any branches
          // have different split levels or basket sizes in a subsequent input file.
          // If the mismatch is in the first file, there is a bug somewhere, so we assert.
          assert(om_->inputFileCount() > 1);
          throw Exception(errors::MismatchedInputFiles, "RootOutputFile::beginInputFile()")
              << "Merge failure because input file " << file_ << " has different ROOT split levels or basket sizes\n"
              << "than previous files.  To allow merging in splite of this, use the configuration parameter\n"
              << "overrideInputFileSplitLevels=cms.untracked.bool(True)\n"
              << "in every PoolOutputModule.\n";
        }
      }
 
      // Since this check can be time consuming, we do it only if we would otherwise fast clone.
      if (whyNotFastClonable_ == FileBlock::CanFastClone) {
        if (!eventTree_.checkIfFastClonable(fb.tree())) {
          whyNotFastClonable_ |= FileBlock::BranchMismatch;
        }
      }
      // We now check if we can fast copy the auxiliary branches.
      // We can do so only if we can otherwise fast copy,
      // the input file has the current format (these branches are in the Events Tree),
      // there are no newly dropped or produced products,
      // no metadata has been dropped,
      // ID's have not been modified,
      // and the branch list indexes do not need modification.
 
      // Note: Fast copy of the EventProductProvenance branch is unsafe
      // unless we can enforce that the parentage information for a fully copied
      // output file will be the same as for the input file, with nothing dropped.
      // This has never been enforced, and, withthe EDAlias feature, it may no longer
      // work by accident.
      // So, for now, we do not enable fast cloning of the non-product branches.
      /*
      Service<ConstProductRegistry> reg;
      canFastCloneAux_ = (whyNotFastClonable_ == FileBlock::CanFastClone) &&
                          fb.fileFormatVersion().noMetaDataTrees() &&
                          !om_->hasNewlyDroppedBranch()[InEvent] &&
                          !fb.hasNewlyDroppedBranch()[InEvent] &&
                          om_->dropMetaData() == PoolOutputModule::DropNone &&
                          !reg->anyProductProduced() &&
                          !fb.modifiedIDs() &&
                          fb.branchListIndexesUnchanged();
*/
 
      // Report the fast copying status.
      Service<JobReport> reportSvc;
      reportSvc->reportFastCopyingStatus(reportToken_, fb.fileName(), whyNotFastClonable_ == FileBlock::CanFastClone);
    } else {
      whyNotFastClonable_ |= FileBlock::NoRootInputSource;
    }
 
    eventTree_.maybeFastCloneTree(
        whyNotFastClonable_ == FileBlock::CanFastClone, canFastCloneAux_, fb.tree(), om_->basketOrder());
 
    // Possibly issue warning or informational message if we haven't fast cloned.
    if (fb.tree() != nullptr && whyNotFastClonable_ != FileBlock::CanFastClone) {
      maybeIssueWarning(whyNotFastClonable_, fb.fileName(), file_);
    }
 
    if (om_->compactEventAuxiliary() &&
        (whyNotFastClonable_ & (FileBlock::EventsOrLumisSelectedByID | FileBlock::InitialEventsSkipped |
                                FileBlock::EventSelectionUsed)) == 0) {
      long long int reserve = remainingEvents;
      if (fb.tree() != nullptr) {
        reserve = reserve > 0 ? std::min(fb.tree()->GetEntries(), reserve) : fb.tree()->GetEntries();
      }
      if (reserve > 0) {
        compactEventAuxiliary_.reserve(compactEventAuxiliary_.size() + reserve);
      }
    }
  }

References cms::cuda::assert(), edm::FileBlock::BranchMismatch, edm::FileBlock::CanFastClone, canFastCloneAux_, edm::RootOutputTree::checkIfFastClonable(), edm::RootOutputTree::checkSplitLevelsAndBasketSizes(), compactEventAuxiliary_, edm::FileBlock::EventSelectionUsed, edm::FileBlock::EventsOrLumisSelectedByID, eventTree_, Exception, benchmark_cfg::fb, file_, edm::FileBlock::InitialEventsSkipped, edm::match(), edm::RootOutputTree::maybeFastCloneTree(), min(), edm::errors::MismatchedInputFiles, edm::FileBlock::NoRootInputSource, om_, edm::FileBlock::OutputMaxEventsTooSmall, reportToken_, edm::CompactEventAuxiliaryVector::reserve(), edm::CompactEventAuxiliaryVector::size(), edm::FileBlock::SplitLevelMismatch, and whyNotFastClonable_.

fileName()

std::string const& edm::RootOutputFile::fileName ( ) const

inline

Definition at line 78 of file RootOutputFile.h.

{ return file_; }

References file_.

filePtr() [1/2]

std::shared_ptr<TFile>& edm::RootOutputFile::filePtr ( )

inlineprivate

Definition at line 104 of file RootOutputFile.h.

{ return get_underlying_safe(filePtr_); }

References filePtr_, and edm::get_underlying_safe().

filePtr() [2/2]

std::shared_ptr<TFile const> edm::RootOutputFile::filePtr ( ) const

inlineprivate

Definition at line 103 of file RootOutputFile.h.

{ return get_underlying_safe(filePtr_); }

References filePtr_, and edm::get_underlying_safe().

fillBranches()

void edm::RootOutputFile::fillBranches ( BranchType const &  branchType, OccurrenceForOutput const &  occurrence, StoredProductProvenanceVector *  productProvenanceVecPtr = nullptr, ProductProvenanceRetriever const *  provRetriever = nullptr  )

private

Definition at line 764 of file RootOutputFile.cc.

                                                                                     {
    std::vector<std::unique_ptr<WrapperBase> > dummies;
 
    OutputItemList& items = om_->selectedOutputItemList()[branchType];
 
    bool const doProvenance =
        (productProvenanceVecPtr != nullptr) && (om_->dropMetaData() != PoolOutputModule::DropAll);
    bool const keepProvenanceForPrior = doProvenance && om_->dropMetaData() != PoolOutputModule::DropPrior;
 
    bool const fastCloning = (branchType == InEvent) && (whyNotFastClonable_ == FileBlock::CanFastClone);
    std::set<StoredProductProvenance> provenanceToKeep;
    //
    //If we are dropping some of the meta data we need to know
    // which BranchIDs were produced in this process because
    // we may be storing meta data for only those products
    // We do this only for event products.
    std::set<BranchID> producedBranches;
    if (doProvenance && branchType == InEvent && om_->dropMetaData() != PoolOutputModule::DropNone) {
      Service<ConstProductRegistry> preg;
      for (auto bd : preg->allBranchDescriptions()) {
        if (bd->produced() && bd->branchType() == InEvent) {
          producedBranches.insert(bd->branchID());
        }
      }
    }
 
    // Loop over EDProduct branches, possibly fill the provenance, and write the branch.
    for (auto& item : items) {
      BranchID const& id = item.branchDescription()->branchID();
      branchesWithStoredHistory_.insert(id);
 
      bool produced = item.branchDescription()->produced();
      bool getProd =
          (produced || !fastCloning || treePointers_[branchType]->uncloned(item.branchDescription()->branchName()));
      bool keepProvenance = doProvenance && (produced || keepProvenanceForPrior);
 
      WrapperBase const* product = nullptr;
      ProductProvenance const* productProvenance = nullptr;
      if (getProd) {
        BasicHandle result = occurrence.getByToken(item.token(), item.branchDescription()->unwrappedTypeID());
        product = result.wrapper();
        if (result.isValid() && keepProvenance) {
          productProvenance = result.provenance()->productProvenance();
        }
        if (product == nullptr) {
          // No product with this ID is in the event.
          // Add a null product.
          TClass* cp = item.branchDescription()->wrappedType().getClass();
          assert(cp != nullptr);
          int offset = cp->GetBaseClassOffset(wrapperBaseTClass_);
          void* p = cp->New();
          std::unique_ptr<WrapperBase> dummy = getWrapperBasePtr(p, offset);
          product = dummy.get();
          dummies.emplace_back(std::move(dummy));
        }
        item.setProduct(product);
      }
      if (keepProvenance && productProvenance == nullptr) {
        productProvenance = provRetriever->branchIDToProvenance(item.branchDescription()->originalBranchID());
      }
      if (productProvenance) {
        insertProductProvenance(*productProvenance, provenanceToKeep);
        insertAncestors(*productProvenance, provRetriever, produced, producedBranches, provenanceToKeep);
      }
    }
 
    if (doProvenance)
      productProvenanceVecPtr->assign(provenanceToKeep.begin(), provenanceToKeep.end());
    treePointers_[branchType]->fillTree();
    if (doProvenance)
      productProvenanceVecPtr->clear();
  }

References cms::cuda::assert(), branchesWithStoredHistory_, edm::ProductProvenanceRetriever::branchIDToProvenance(), edm::FileBlock::CanFastClone, edm::PoolOutputModule::DropAll, edm::PoolOutputModule::DropNone, edm::PoolOutputModule::DropPrior, test_L1EGCrystalClusterEmulator_cfg::fastCloning, edm::OccurrenceForOutput::getByToken(), edm::getWrapperBasePtr(), edm::InEvent, insertAncestors(), insertProductProvenance(), B2GTnPMonitor_cfi::item, mps_monitormerge::items, eostools::move(), hltrates_dqm_sourceclient-live_cfg::offset, om_, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, treePointers_, whyNotFastClonable_, and wrapperBaseTClass_.

Referenced by writeLuminosityBlock(), writeOne(), and writeRun().

finishEndFile()

void edm::RootOutputFile::finishEndFile

(

)

Definition at line 683 of file RootOutputFile.cc.

                                     {
    metaDataTree_->SetEntries(-1);
    RootOutputTree::writeTTree(metaDataTree_);
    RootOutputTree::writeTTree(parameterSetsTree_);
 
    RootOutputTree::writeTTree(parentageTree_);
 
    // Create branch aliases for all the branches in the
    // events/lumis/runs trees. The loop is over all types of data
    // products.
    for (int i = InEvent; i < NumBranchTypes; ++i) {
      if (i == InProcess) {
        // Output for ProcessBlocks is not implemented yet.
        continue;
      }
      BranchType branchType = static_cast<BranchType>(i);
      setBranchAliases(treePointers_[branchType]->tree(), om_->keptProducts()[branchType]);
      treePointers_[branchType]->writeTree();
    }
 
    // close the file -- mfp
    // Just to play it safe, zero all pointers to objects in the TFile to be closed.
    metaDataTree_ = parentageTree_ = nullptr;
    for (auto& treePointer : treePointers_) {
      if (treePointer.get() == nullptr) {
        // Output for ProcessBlock is not implemented yet
        continue;
      }
      treePointer->close();
      treePointer = nullptr;
    }
    filePtr_->Close();
    filePtr_ = nullptr;  // propagate_const<T> has no reset() function
 
    // report that file has been closed
    Service<JobReport> reportSvc;
    reportSvc->outputFileClosed(reportToken_);
  }

References filePtr_, mps_fire::i, edm::InEvent, edm::InProcess, metaDataTree_, edm::NumBranchTypes, om_, parameterSetsTree_, parentageTree_, reportToken_, setBranchAliases(), MainPageGenerator::tree, treePointers_, and edm::RootOutputTree::writeTTree().

insertAncestors()

void edm::RootOutputFile::insertAncestors ( ProductProvenance const &  iGetParents, ProductProvenanceRetriever const *  iMapper, bool  produced, std::set< BranchID > const &  producedBranches, std::set< StoredProductProvenance > &  oToFill  )

private

Definition at line 739 of file RootOutputFile.cc.

                                                                                 {
    assert(om_->dropMetaData() != PoolOutputModule::DropAll);
    assert(produced || om_->dropMetaData() != PoolOutputModule::DropPrior);
    if (om_->dropMetaData() == PoolOutputModule::DropDroppedPrior && !produced)
      return;
    std::vector<BranchID> const& parentIDs = iGetParents.parentage().parents();
    for (auto const& parentID : parentIDs) {
      branchesWithStoredHistory_.insert(parentID);
      ProductProvenance const* info = iMapper->branchIDToProvenance(parentID);
      if (info) {
        if (om_->dropMetaData() == PoolOutputModule::DropNone ||
            (iProducedIDs.end() != iProducedIDs.find(info->branchID()))) {
          if (insertProductProvenance(*info, oToFill)) {
            //haven't seen this one yet
            insertAncestors(*info, iMapper, produced, iProducedIDs, oToFill);
          }
        }
      }
    }
  }

References cms::cuda::assert(), branchesWithStoredHistory_, edm::ProductProvenanceRetriever::branchIDToProvenance(), edm::PoolOutputModule::DropAll, edm::PoolOutputModule::DropDroppedPrior, edm::PoolOutputModule::DropNone, edm::PoolOutputModule::DropPrior, info(), insertProductProvenance(), om_, edm::ProductProvenance::parentage(), and edm::Parentage::parents().

Referenced by fillBranches().

insertProductProvenance()

bool edm::RootOutputFile::insertProductProvenance ( const ProductProvenance &  , std::set< StoredProductProvenance > &  oToInsert  )

private

Definition at line 840 of file RootOutputFile.cc.

                                                                                              {
    StoredProductProvenance toStore;
    toStore.branchID_ = iProv.branchID().id();
    std::set<edm::StoredProductProvenance>::iterator itFound = oToInsert.find(toStore);
    if (itFound == oToInsert.end()) {
      //get the index to the ParentageID or insert a new value if not already present
      std::pair<std::map<edm::ParentageID, unsigned int>::iterator, bool> i =
          parentageIDs_.insert(std::make_pair(iProv.parentageID(), static_cast<unsigned int>(parentageIDs_.size())));
      toStore.parentageIDIndex_ = i.first->second;
      if (toStore.parentageIDIndex_ >= parentageIDs_.size()) {
        throw edm::Exception(errors::LogicError)
            << "RootOutputFile::insertProductProvenance\n"
            << "The parentage ID index value " << toStore.parentageIDIndex_
            << " is out of bounds.  The maximum value is currently " << parentageIDs_.size() - 1 << ".\n"
            << "This should never happen.\n"
            << "Please report this to the framework hypernews forum 'hn-cms-edmFramework@cern.ch'.\n";
      }
 
      oToInsert.insert(toStore);
      return true;
    }
    return false;
  }

References edm::ProductProvenance::branchID(), edm::StoredProductProvenance::branchID_, Exception, mps_fire::i, edm::BranchID::id(), edm::errors::LogicError, edm::ProductProvenance::parentageID(), edm::StoredProductProvenance::parentageIDIndex_, and parentageIDs_.

Referenced by fillBranches(), and insertAncestors().

pEventEntryInfoVector() [1/2]

StoredProductProvenanceVector*& edm::RootOutputFile::pEventEntryInfoVector ( )

inlineprivate

Definition at line 108 of file RootOutputFile.h.

{ return get_underlying_safe(pEventEntryInfoVector_); }

References edm::get_underlying_safe(), and pEventEntryInfoVector_.

pEventEntryInfoVector() [2/2]

StoredProductProvenanceVector const* edm::RootOutputFile::pEventEntryInfoVector ( ) const

inlineprivate

Definition at line 105 of file RootOutputFile.h.

                                                                       {
      return get_underlying_safe(pEventEntryInfoVector_);
    }

References edm::get_underlying_safe(), and pEventEntryInfoVector_.

Referenced by RootOutputFile().

respondToCloseInputFile()

void edm::RootOutputFile::respondToCloseInputFile

(

FileBlock const &

fb

)

Definition at line 409 of file RootOutputFile.cc.

                                                               {
    // We can't do setEntries() on the event tree if the EventAuxiliary branch is empty & disabled
    if (not om_->compactEventAuxiliary()) {
      eventTree_.setEntries();
    }
    lumiTree_.setEntries();
    runTree_.setEntries();
  }

References eventTree_, lumiTree_, om_, runTree_, and edm::RootOutputTree::setEntries().

setBranchAliases()

void edm::RootOutputFile::setBranchAliases ( TTree *  tree, SelectedProducts const &  branches  ) const

private

Definition at line 722 of file RootOutputFile.cc.

                                                                                           {
    if (tree && tree->GetNbranches() != 0) {
      for (auto const& selection : branches) {
        BranchDescription const& pd = *selection.first;
        std::string const& full = pd.branchName() + "obj";
        if (pd.branchAliases().empty()) {
          std::string const& alias = (pd.productInstanceName().empty() ? pd.moduleLabel() : pd.productInstanceName());
          tree->SetAlias(alias.c_str(), full.c_str());
        } else {
          for (auto const& alias : pd.branchAliases()) {
            tree->SetAlias(alias.c_str(), full.c_str());
          }
        }
      }
    }
  }

References SiStripOfflineCRack_cfg::alias, edm::BranchDescription::branchAliases(), edm::BranchDescription::branchName(), full, edm::BranchDescription::moduleLabel(), edm::BranchDescription::productInstanceName(), corrVsCorr::selection, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by finishEndFile().

shouldWeCloseFile()

bool edm::RootOutputFile::shouldWeCloseFile

(

)

const

Definition at line 418 of file RootOutputFile.cc.

                                               {
    unsigned int const oneK = 1024;
    Long64_t size = filePtr_->GetSize() / oneK;
    return (size >= om_->maxFileSize());
  }

References filePtr_, om_, and findQualityFiles::size.

writeBranchIDListRegistry()

void edm::RootOutputFile::writeBranchIDListRegistry

(

)

Definition at line 587 of file RootOutputFile.cc.

                                                 {
    BranchIDLists const* p = om_->branchIDLists();
    TBranch* b = metaDataTree_->Branch(poolNames::branchIDListBranchName().c_str(), &p, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::cuda::assert(), b, edm::poolNames::branchIDListBranchName(), metaDataTree_, om_, and AlCaHLTBitMon_ParallelJobs::p.

writeEventAuxiliary()

void edm::RootOutputFile::writeEventAuxiliary

(

)

Definition at line 653 of file RootOutputFile.cc.

                                           {
    constexpr std::size_t maxEaBasketSize = 4 * 1024 * 1024;
 
    if (om_->compactEventAuxiliary()) {
      auto tree = eventTree_.tree();
      auto const& bname = BranchTypeToAuxiliaryBranchName(InEvent).c_str();
 
      tree->SetBranchStatus(bname, true);
      auto basketsize =
          std::min(maxEaBasketSize,
                   compactEventAuxiliary_.size() * (sizeof(EventAuxiliary) + 26));  // 26 is an empirical fudge factor
      tree->SetBasketSize(bname, basketsize);
      auto b = tree->GetBranch(bname);
 
      assert(b);
 
      LogDebug("writeEventAuxiliary") << "EventAuxiliary ratio extras/GUIDs/all = "
                                      << compactEventAuxiliary_.extrasSize() << "/"
                                      << compactEventAuxiliary_.guidsSize() << "/" << compactEventAuxiliary_.size();
 
      for (auto const& aux : compactEventAuxiliary_) {
        const auto ea = aux.eventAuxiliary();
        pEventAux_ = &ea;
        // Fill EventAuxiliary branch
        b->Fill();
      }
      eventTree_.setEntries();
    }
  }

References cms::cuda::assert(), printConversionInfo::aux, b, edm::BranchTypeToAuxiliaryBranchName(), compactEventAuxiliary_, eventTree_, edm::CompactEventAuxiliaryVector::extrasSize(), edm::CompactEventAuxiliaryVector::guidsSize(), edm::InEvent, LogDebug, min(), om_, pEventAux_, edm::RootOutputTree::setEntries(), edm::CompactEventAuxiliaryVector::size(), and edm::RootOutputTree::tree().

writeFileFormatVersion()

void edm::RootOutputFile::writeFileFormatVersion

(

)

Definition at line 541 of file RootOutputFile.cc.

                                              {
    FileFormatVersion fileFormatVersion(getFileFormatVersion());
    FileFormatVersion* pFileFmtVsn = &fileFormatVersion;
    TBranch* b =
        metaDataTree_->Branch(poolNames::fileFormatVersionBranchName().c_str(), &pFileFmtVsn, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::cuda::assert(), b, edm::poolNames::fileFormatVersionBranchName(), edm::getFileFormatVersion(), metaDataTree_, and om_.

writeFileIdentifier()

void edm::RootOutputFile::writeFileIdentifier

(

)

Definition at line 550 of file RootOutputFile.cc.

                                           {
    FileID* fidPtr = &fid_;
    TBranch* b = metaDataTree_->Branch(poolNames::fileIdentifierBranchName().c_str(), &fidPtr, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::cuda::assert(), b, fid_, edm::poolNames::fileIdentifierBranchName(), metaDataTree_, and om_.

writeIndexIntoFile()

void edm::RootOutputFile::writeIndexIntoFile

(

)

Definition at line 557 of file RootOutputFile.cc.

                                          {
    if (eventTree_.checkEntriesInReadBranches(eventEntryNumber_) == false) {
      Exception ex(errors::OtherCMS);
      ex << "The number of entries in at least one output TBranch whose entries\n"
            "were copied from the input does not match the number of events\n"
            "recorded in IndexIntoFile. This might (or might not) indicate a\n"
            "problem related to fast copy.";
      ex.addContext("Calling RootOutputFile::writeIndexIntoFile");
      throw ex;
    }
    indexIntoFile_.sortVector_Run_Or_Lumi_Entries();
    IndexIntoFile* iifPtr = &indexIntoFile_;
    TBranch* b = metaDataTree_->Branch(poolNames::indexIntoFileBranchName().c_str(), &iifPtr, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::Exception::addContext(), cms::cuda::assert(), b, edm::RootOutputTree::checkEntriesInReadBranches(), eventEntryNumber_, eventTree_, indexIntoFile_, edm::poolNames::indexIntoFileBranchName(), metaDataTree_, om_, edm::errors::OtherCMS, and edm::IndexIntoFile::sortVector_Run_Or_Lumi_Entries().

writeLuminosityBlock()

void edm::RootOutputFile::writeLuminosityBlock

(

LuminosityBlockForOutput const &

lb

)

Definition at line 477 of file RootOutputFile.cc.

                                                                              {
    // Auxiliary branch
    // NOTE: lumiAux_ must be filled before calling fillBranches since it gets written out in that routine.
    lumiAux_ = lb.luminosityBlockAuxiliary();
    // Use the updated process historyID
    lumiAux_.setProcessHistoryID(lb.processHistoryID());
    // Store the process history.
    processHistoryRegistry_.registerProcessHistory(lb.processHistory());
    // Store the reduced ID in the IndexIntoFile
    ProcessHistoryID reducedPHID = processHistoryRegistry_.reducedProcessHistoryID(lb.processHistoryID());
    // Add lumi to index.
    indexIntoFile_.addEntry(reducedPHID, lumiAux_.run(), lumiAux_.luminosityBlock(), 0U, lumiEntryNumber_);
    ++lumiEntryNumber_;
    fillBranches(InLumi, lb);
    lumiTree_.optimizeBaskets(10ULL * 1024 * 1024);
 
    Service<JobReport> reportSvc;
    reportSvc->reportLumiSection(reportToken_, lb.id().run(), lb.id().luminosityBlock(), nEventsInLumi_);
    nEventsInLumi_ = 0;
  }

References edm::IndexIntoFile::addEntry(), fillBranches(), edm::LuminosityBlockForOutput::id(), indexIntoFile_, edm::InLumi, lumiAux_, lumiEntryNumber_, edm::LuminosityBlockAuxiliary::luminosityBlock(), edm::LuminosityBlockID::luminosityBlock(), edm::LuminosityBlockForOutput::luminosityBlockAuxiliary(), lumiTree_, nEventsInLumi_, edm::RootOutputTree::optimizeBaskets(), edm::OccurrenceForOutput::processHistory(), edm::OccurrenceForOutput::processHistoryID(), processHistoryRegistry_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), edm::ProcessHistoryRegistry::registerProcessHistory(), reportToken_, edm::LuminosityBlockAuxiliary::run(), edm::LuminosityBlockID::run(), edm::LuminosityBlockAuxiliary::setProcessHistoryID(), and mitigatedMETSequence_cff::U.

writeOne()

void edm::RootOutputFile::writeOne

(

EventForOutput const &

e

)

Definition at line 424 of file RootOutputFile.cc.

                                                       {
    // Auxiliary branch
    pEventAux_ = &e.eventAuxiliary();
 
    // Because getting the data may cause an exception to be thrown we want to do that
    // first before writing anything to the file about this event
    // NOTE: pEventAux_, pBranchListIndexes_, pEventSelectionIDs_, and pEventEntryInfoVector_
    // must be set before calling fillBranches since they get written out in that routine.
    assert(pEventAux_->processHistoryID() == e.processHistoryID());
    pBranchListIndexes_ = &e.branchListIndexes();
 
    // Note: The EventSelectionIDVector should have a one to one correspondence with the processes in the process history.
    // Therefore, a new entry should be added if and only if the current process has been added to the process history,
    // which is done if and only if there is a produced product.
    Service<ConstProductRegistry> reg;
    EventSelectionIDVector esids = e.eventSelectionIDs();
    if (reg->anyProductProduced() || !om_->wantAllEvents()) {
      esids.push_back(om_->selectorConfig());
    }
    pEventSelectionIDs_ = &esids;
    ProductProvenanceRetriever const* provRetriever = e.productProvenanceRetrieverPtr();
    assert(provRetriever);
    fillBranches(InEvent, e, pEventEntryInfoVector_, provRetriever);
 
    // Add the dataType to the job report if it hasn't already been done
    if (!dataTypeReported_) {
      Service<JobReport> reportSvc;
      std::string dataType("MC");
      if (pEventAux_->isRealData())
        dataType = "Data";
      reportSvc->reportDataType(reportToken_, dataType);
      dataTypeReported_ = true;
    }
 
    // Store the process history.
    processHistoryRegistry_.registerProcessHistory(e.processHistory());
    // Store the reduced ID in the IndexIntoFile
    ProcessHistoryID reducedPHID = processHistoryRegistry_.reducedProcessHistoryID(e.processHistoryID());
    // Add event to index
    indexIntoFile_.addEntry(
        reducedPHID, pEventAux_->run(), pEventAux_->luminosityBlock(), pEventAux_->event(), eventEntryNumber_);
    ++eventEntryNumber_;
 
    if (om_->compactEventAuxiliary()) {
      compactEventAuxiliary_.push_back(*pEventAux_);
    }
 
    // Report event written
    Service<JobReport> reportSvc;
    reportSvc->eventWrittenToFile(reportToken_, e.id().run(), e.id().event());
    ++nEventsInLumi_;
  }

References edm::IndexIntoFile::addEntry(), cms::cuda::assert(), compactEventAuxiliary_, DTskim_cfg::dataType, dataTypeReported_, MillePedeFileConverter_cfg::e, edm::EventAuxiliary::event(), eventEntryNumber_, fillBranches(), indexIntoFile_, edm::InEvent, edm::EventAuxiliary::isRealData(), edm::EventAuxiliary::luminosityBlock(), nEventsInLumi_, om_, pBranchListIndexes_, pEventAux_, pEventEntryInfoVector_, pEventSelectionIDs_, edm::EventAuxiliary::processHistoryID(), processHistoryRegistry_, edm::CompactEventAuxiliaryVector::push_back(), edm::ProcessHistoryRegistry::reducedProcessHistoryID(), edm::ProcessHistoryRegistry::registerProcessHistory(), reportToken_, edm::EventAuxiliary::run(), and AlCaHLTBitMon_QueryRunRegistry::string.

writeParameterSetRegistry()

void edm::RootOutputFile::writeParameterSetRegistry

(

)

Definition at line 602 of file RootOutputFile.cc.

                                                 {
    fillParameterSetBranch(parameterSetsTree_.get(), om_->basketSize());
  }

References edm::fillParameterSetBranch(), edm::propagate_const< T >::get(), om_, and parameterSetsTree_.

writeParentageRegistry()

void edm::RootOutputFile::writeParentageRegistry

(

)

Definition at line 519 of file RootOutputFile.cc.

                                              {
    Parentage const* desc(nullptr);
 
    if (!parentageTree_->Branch(poolNames::parentageBranchName().c_str(), &desc, om_->basketSize(), 0))
      throw Exception(errors::FatalRootError) << "Failed to create a branch for Parentages in the output file";
 
    ParentageRegistry& ptReg = *ParentageRegistry::instance();
 
    std::vector<ParentageID> orderedIDs(parentageIDs_.size());
    for (auto const& parentageID : parentageIDs_) {
      orderedIDs[parentageID.second] = parentageID.first;
    }
    //now put them into the TTree in the correct order
    for (auto const& orderedID : orderedIDs) {
      desc = ptReg.getMapped(orderedID);
      //NOTE: some old format files have missing Parentage info
      // so a null value of desc can't be fatal.
      // Root will default construct an object in that case.
      parentageTree_->Fill();
    }
  }

References submitPVResolutionJobs::desc, Exception, edm::errors::FatalRootError, edm::ParentageRegistry::getMapped(), edm::ParentageRegistry::instance(), om_, edm::poolNames::parentageBranchName(), parentageIDs_, and parentageTree_.

writeProcessHistoryRegistry()

void edm::RootOutputFile::writeProcessHistoryRegistry

(

)

Definition at line 583 of file RootOutputFile.cc.

                                                   {
    fillProcessHistoryBranch(metaDataTree_.get(), om_->basketSize(), processHistoryRegistry_);
  }

References edm::fillProcessHistoryBranch(), edm::propagate_const< T >::get(), metaDataTree_, om_, and processHistoryRegistry_.

writeProductDependencies()

void edm::RootOutputFile::writeProductDependencies

(

)

Definition at line 637 of file RootOutputFile.cc.

                                                {
    BranchChildren& pDeps = const_cast<BranchChildren&>(om_->branchChildren());
    BranchChildren* ppDeps = &pDeps;
    TBranch* b =
        metaDataTree_->Branch(poolNames::productDependenciesBranchName().c_str(), &ppDeps, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::cuda::assert(), b, metaDataTree_, om_, and edm::poolNames::productDependenciesBranchName().

writeProductDescriptionRegistry()

void edm::RootOutputFile::writeProductDescriptionRegistry

(

)

Definition at line 606 of file RootOutputFile.cc.

                                                       {
    // Make a local copy of the ProductRegistry, removing any transient or pruned products.
    typedef ProductRegistry::ProductList ProductList;
    Service<ConstProductRegistry> reg;
    ProductRegistry pReg(reg->productList());
    ProductList& pList = const_cast<ProductList&>(pReg.productList());
    for (auto const& prod : pList) {
      if (prod.second.branchID() != prod.second.originalBranchID()) {
        if (branchesWithStoredHistory_.find(prod.second.branchID()) != branchesWithStoredHistory_.end()) {
          branchesWithStoredHistory_.insert(prod.second.originalBranchID());
        }
      }
    }
    std::set<BranchID>::iterator end = branchesWithStoredHistory_.end();
    for (ProductList::iterator it = pList.begin(); it != pList.end();) {
      if (branchesWithStoredHistory_.find(it->second.branchID()) == end) {
        // avoid invalidating iterator on deletion
        ProductList::iterator itCopy = it;
        ++it;
        pList.erase(itCopy);
 
      } else {
        ++it;
      }
    }
 
    ProductRegistry* ppReg = &pReg;
    TBranch* b = metaDataTree_->Branch(poolNames::productDescriptionBranchName().c_str(), &ppReg, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::cuda::assert(), b, branchesWithStoredHistory_, mps_fire::end, metaDataTree_, om_, dumpMFGeometry_cfg::prod, and edm::poolNames::productDescriptionBranchName().

writeRun()

void edm::RootOutputFile::writeRun

(

RunForOutput const &

r

)

Definition at line 498 of file RootOutputFile.cc.

                                                     {
    // Auxiliary branch
    // NOTE: runAux_ must be filled before calling fillBranches since it gets written out in that routine.
    runAux_ = r.runAuxiliary();
    // Use the updated process historyID
    runAux_.setProcessHistoryID(r.processHistoryID());
    // Store the process history.
    processHistoryRegistry_.registerProcessHistory(r.processHistory());
    // Store the reduced ID in the IndexIntoFile
    ProcessHistoryID reducedPHID = processHistoryRegistry_.reducedProcessHistoryID(r.processHistoryID());
    // Add run to index.
    indexIntoFile_.addEntry(reducedPHID, runAux_.run(), 0U, 0U, runEntryNumber_);
    r.mergeableRunProductMetadata()->addEntryToStoredMetadata(storedMergeableRunProductMetadata_);
    ++runEntryNumber_;
    fillBranches(InRun, r);
    runTree_.optimizeBaskets(10ULL * 1024 * 1024);
 
    Service<JobReport> reportSvc;
    reportSvc->reportRunNumber(reportToken_, r.run());
  }

References edm::IndexIntoFile::addEntry(), fillBranches(), indexIntoFile_, edm::InRun, edm::RootOutputTree::optimizeBaskets(), processHistoryRegistry_, alignCSCRings::r, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), edm::ProcessHistoryRegistry::registerProcessHistory(), reportToken_, edm::RunAuxiliary::run(), runAux_, runEntryNumber_, runTree_, edm::RunAuxiliary::setProcessHistoryID(), storedMergeableRunProductMetadata_, and mitigatedMETSequence_cff::U.

writeStoredMergeableRunProductMetadata()

void edm::RootOutputFile::writeStoredMergeableRunProductMetadata

(

)

Definition at line 574 of file RootOutputFile.cc.

                                                              {
    storedMergeableRunProductMetadata_.optimizeBeforeWrite();
    StoredMergeableRunProductMetadata* ptr = &storedMergeableRunProductMetadata_;
    TBranch* b =
        metaDataTree_->Branch(poolNames::mergeableRunProductMetadataBranchName().c_str(), &ptr, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::cuda::assert(), b, edm::poolNames::mergeableRunProductMetadataBranchName(), metaDataTree_, om_, edm::StoredMergeableRunProductMetadata::optimizeBeforeWrite(), and storedMergeableRunProductMetadata_.

writeThinnedAssociationsHelper()

void edm::RootOutputFile::writeThinnedAssociationsHelper

(

)

Definition at line 594 of file RootOutputFile.cc.

                                                      {
    ThinnedAssociationsHelper const* p = om_->thinnedAssociationsHelper();
    TBranch* b =
        metaDataTree_->Branch(poolNames::thinnedAssociationsHelperBranchName().c_str(), &p, om_->basketSize(), 0);
    assert(b);
    b->Fill();
  }

References cms::cuda::assert(), b, metaDataTree_, om_, AlCaHLTBitMon_ParallelJobs::p, and edm::poolNames::thinnedAssociationsHelperBranchName().

Member Data Documentation

branchesWithStoredHistory_

std::set<BranchID> edm::RootOutputFile::branchesWithStoredHistory_

private

Definition at line 146 of file RootOutputFile.h.

Referenced by fillBranches(), insertAncestors(), RootOutputFile(), and writeProductDescriptionRegistry().

canFastCloneAux_

bool edm::RootOutputFile::canFastCloneAux_

private

Definition at line 118 of file RootOutputFile.h.

Referenced by beginInputFile().

compactEventAuxiliary_

CompactEventAuxiliaryVector edm::RootOutputFile::compactEventAuxiliary_

private

Definition at line 148 of file RootOutputFile.h.

Referenced by beginInputFile(), writeEventAuxiliary(), and writeOne().

dataTypeReported_

bool edm::RootOutputFile::dataTypeReported_

private

Definition at line 143 of file RootOutputFile.h.

Referenced by writeOne().

eventEntryInfoVector_

StoredProductProvenanceVector edm::RootOutputFile::eventEntryInfoVector_

private

Definition at line 135 of file RootOutputFile.h.

eventEntryNumber_

IndexIntoFile::EntryNumber_t edm::RootOutputFile::eventEntryNumber_

private

Definition at line 121 of file RootOutputFile.h.

Referenced by writeIndexIntoFile(), and writeOne().

eventTree_

RootOutputTree edm::RootOutputFile::eventTree_

private

Definition at line 139 of file RootOutputFile.h.

Referenced by beginInputFile(), respondToCloseInputFile(), RootOutputFile(), writeEventAuxiliary(), and writeIndexIntoFile().

fid_

FileID edm::RootOutputFile::fid_

private

Definition at line 120 of file RootOutputFile.h.

Referenced by RootOutputFile(), and writeFileIdentifier().

file_

std::string edm::RootOutputFile::file_

private

Definition at line 113 of file RootOutputFile.h.

Referenced by beginInputFile(), fileName(), and RootOutputFile().

filePtr_

edm::propagate_const<std::shared_ptr<TFile> > edm::RootOutputFile::filePtr_

private

Definition at line 119 of file RootOutputFile.h.

Referenced by filePtr(), finishEndFile(), RootOutputFile(), and shouldWeCloseFile().

indexIntoFile_

IndexIntoFile edm::RootOutputFile::indexIntoFile_

private

Definition at line 124 of file RootOutputFile.h.

Referenced by writeIndexIntoFile(), writeLuminosityBlock(), writeOne(), and writeRun().

logicalFile_

std::string edm::RootOutputFile::logicalFile_

private

Definition at line 114 of file RootOutputFile.h.

Referenced by RootOutputFile().

lumiAux_

LuminosityBlockAuxiliary edm::RootOutputFile::lumiAux_

private

Definition at line 130 of file RootOutputFile.h.

Referenced by writeLuminosityBlock().

lumiEntryNumber_

IndexIntoFile::EntryNumber_t edm::RootOutputFile::lumiEntryNumber_

private

Definition at line 122 of file RootOutputFile.h.

Referenced by writeLuminosityBlock().

lumiTree_

RootOutputTree edm::RootOutputFile::lumiTree_

private

Definition at line 140 of file RootOutputFile.h.

Referenced by respondToCloseInputFile(), RootOutputFile(), and writeLuminosityBlock().

metaDataTree_

edm::propagate_const<TTree*> edm::RootOutputFile::metaDataTree_

private

Definition at line 127 of file RootOutputFile.h.

Referenced by finishEndFile(), RootOutputFile(), writeBranchIDListRegistry(), writeFileFormatVersion(), writeFileIdentifier(), writeIndexIntoFile(), writeProcessHistoryRegistry(), writeProductDependencies(), writeProductDescriptionRegistry(), writeStoredMergeableRunProductMetadata(), and writeThinnedAssociationsHelper().

nEventsInLumi_

unsigned long edm::RootOutputFile::nEventsInLumi_

private

Definition at line 126 of file RootOutputFile.h.

Referenced by writeLuminosityBlock(), and writeOne().

om_

edm::propagate_const<PoolOutputModule*> edm::RootOutputFile::om_

private

Definition at line 116 of file RootOutputFile.h.

Referenced by beginInputFile(), fillBranches(), finishEndFile(), insertAncestors(), respondToCloseInputFile(), RootOutputFile(), shouldWeCloseFile(), writeBranchIDListRegistry(), writeEventAuxiliary(), writeFileFormatVersion(), writeFileIdentifier(), writeIndexIntoFile(), writeOne(), writeParameterSetRegistry(), writeParentageRegistry(), writeProcessHistoryRegistry(), writeProductDependencies(), writeProductDescriptionRegistry(), writeStoredMergeableRunProductMetadata(), and writeThinnedAssociationsHelper().

parameterSetsTree_

edm::propagate_const<TTree*> edm::RootOutputFile::parameterSetsTree_

private

Definition at line 128 of file RootOutputFile.h.

Referenced by finishEndFile(), RootOutputFile(), and writeParameterSetRegistry().

parentageIDs_

std::map<ParentageID, unsigned int> edm::RootOutputFile::parentageIDs_

private

Definition at line 145 of file RootOutputFile.h.

Referenced by insertProductProvenance(), and writeParentageRegistry().

parentageTree_

edm::propagate_const<TTree*> edm::RootOutputFile::parentageTree_

private

Definition at line 129 of file RootOutputFile.h.

Referenced by finishEndFile(), RootOutputFile(), and writeParentageRegistry().

pBranchListIndexes_

BranchListIndexes const* edm::RootOutputFile::pBranchListIndexes_

private

Definition at line 137 of file RootOutputFile.h.

Referenced by RootOutputFile(), and writeOne().

pEventAux_

EventAuxiliary const* edm::RootOutputFile::pEventAux_

private

Definition at line 132 of file RootOutputFile.h.

Referenced by RootOutputFile(), writeEventAuxiliary(), and writeOne().

pEventEntryInfoVector_

edm::propagate_const<StoredProductProvenanceVector*> edm::RootOutputFile::pEventEntryInfoVector_

private

Definition at line 136 of file RootOutputFile.h.

Referenced by pEventEntryInfoVector(), and writeOne().

pEventSelectionIDs_

EventSelectionIDVector const* edm::RootOutputFile::pEventSelectionIDs_

private

Definition at line 138 of file RootOutputFile.h.

Referenced by RootOutputFile(), and writeOne().

pLumiAux_

LuminosityBlockAuxiliary const* edm::RootOutputFile::pLumiAux_

private

Definition at line 133 of file RootOutputFile.h.

Referenced by RootOutputFile().

processHistoryRegistry_

ProcessHistoryRegistry edm::RootOutputFile::processHistoryRegistry_

private

Definition at line 144 of file RootOutputFile.h.

Referenced by writeLuminosityBlock(), writeOne(), writeProcessHistoryRegistry(), and writeRun().

pRunAux_

RunAuxiliary const* edm::RootOutputFile::pRunAux_

private

Definition at line 134 of file RootOutputFile.h.

Referenced by RootOutputFile().

reportToken_

JobReport::Token edm::RootOutputFile::reportToken_

private

Definition at line 115 of file RootOutputFile.h.

Referenced by beginInputFile(), finishEndFile(), RootOutputFile(), writeLuminosityBlock(), writeOne(), and writeRun().

runAux_

RunAuxiliary edm::RootOutputFile::runAux_

private

Definition at line 131 of file RootOutputFile.h.

Referenced by writeRun().

runEntryNumber_

IndexIntoFile::EntryNumber_t edm::RootOutputFile::runEntryNumber_

private

Definition at line 123 of file RootOutputFile.h.

Referenced by writeRun().

runTree_

RootOutputTree edm::RootOutputFile::runTree_

private

Definition at line 141 of file RootOutputFile.h.

Referenced by respondToCloseInputFile(), RootOutputFile(), and writeRun().

storedMergeableRunProductMetadata_

StoredMergeableRunProductMetadata edm::RootOutputFile::storedMergeableRunProductMetadata_

private

Definition at line 125 of file RootOutputFile.h.

Referenced by writeRun(), and writeStoredMergeableRunProductMetadata().

treePointers_

RootOutputTreePtrArray edm::RootOutputFile::treePointers_

private

Definition at line 142 of file RootOutputFile.h.

Referenced by fillBranches(), finishEndFile(), and RootOutputFile().

whyNotFastClonable_

int edm::RootOutputFile::whyNotFastClonable_

private

Definition at line 117 of file RootOutputFile.h.

Referenced by beginInputFile(), and fillBranches().

wrapperBaseTClass_

edm::propagate_const<TClass*> edm::RootOutputFile::wrapperBaseTClass_

private

Definition at line 147 of file RootOutputFile.h.

Referenced by fillBranches().