#include <RootOutputFile.h>

Public Types
using	OutputItem = PoolOutputModule::OutputItem

using	OutputItemList = PoolOutputModule::OutputItemList

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	writeProcessBlock (ProcessBlockForOutput const &)

void	writeProcessBlockHelper ()

void	writeProcessHistoryRegistry ()

void	writeProductDependencies ()

void	writeProductDescriptionRegistry ()

void	writeRun (RunForOutput const &r)

void	writeStoredMergeableRunProductMetadata ()

void	writeThinnedAssociationsHelper ()

	~RootOutputFile ()

Private Member Functions
std::shared_ptr< TFile const >	filePtr () const

std::shared_ptr< TFile > &	filePtr ()

void	fillBranches (BranchType const &branchType, OccurrenceForOutput const &occurrence, unsigned int ttreeIndex, 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 const *	pEventEntryInfoVector () const

StoredProductProvenanceVector *&	pEventEntryInfoVector ()

void	setBranchAliases (TTree *tree, SelectedProducts const &branches, std::string const &processName) 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_

EventToProcessBlockIndexes const *	pEventToProcessBlockIndexes_

LuminosityBlockAuxiliary const *	pLumiAux_

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

ProcessHistoryRegistry	processHistoryRegistry_

RunAuxiliary const *	pRunAux_

JobReport::Token	reportToken_

RunAuxiliary	runAux_

IndexIntoFile::EntryNumber_t	runEntryNumber_

RootOutputTree	runTree_

StoredMergeableRunProductMetadata	storedMergeableRunProductMetadata_

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

int	whyNotFastClonable_

edm::propagate_const< TClass * >	wrapperBaseTClass_

Detailed Description

Definition at line 48 of file RootOutputFile.h.

Member Typedef Documentation

using edm::RootOutputFile::OutputItem = PoolOutputModule::OutputItem

Definition at line 50 of file RootOutputFile.h.

using edm::RootOutputFile::OutputItemList = PoolOutputModule::OutputItemList

Definition at line 51 of file RootOutputFile.h.

Constructor & Destructor Documentation

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.

References edm::RootOutputTree::addAuxiliary(), edm::RootOutputTree::addBranch(), branchesWithStoredHistory_, edm::poolNames::branchListIndexesBranchName(), edm::BranchDescription::branchName(), haddnano::branchNames, edm::BranchTypeToAuxiliaryBranchName(), edm::BranchTypeToProductProvenanceBranchName(), edm::errors::Configuration, edm::createGlobalIdentifier(), submitPVResolutionJobs::desc, cms::Digest::digest(), edm::PoolOutputModule::eventAutoFlushSize(), edm::poolNames::eventSelectionsBranchName(), edm::poolNames::eventToProcessBlockIndexesBranchName(), eventTree_, Exception, fid_, file_, filePtr(), filePtr_, edm::BranchDescription::fullClassName(), 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::BranchDescription::moduleLabel(), edm::moduleName(), om_, parameterSetsTree_, edm::poolNames::parameterSetsTreeName(), parentageTree_, edm::poolNames::parentageTreeName(), pBranchListIndexes_, pEventAux_, pEventEntryInfoVector(), pEventSelectionIDs_, pEventToProcessBlockIndexes_, pLumiAux_, processBlockTrees_, edm::BranchDescription::processName(), FSQHLTOfflineSource_cfi::processName, edm::BranchDescription::productInstanceName(), pRunAux_, reportToken_, runTree_, edm::PoolOutputModule::selectedOutputItemList(), edm::RootOutputTree::setAutoFlush(), edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, cms::MD5Result::toString(), edm::RootOutputTree::tree(), treePointers_, and edm::BranchDescription::wrappedName().

       : 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()),
         dataTypeReported_(false),
         processHistoryRegistry_(),
         parentageIDs_(),
         branchesWithStoredHistory_(),
         wrapperBaseTClass_(TClass::GetClass("edm::WrapperBase")) {
     std::vector<std::string> const& processesWithProcessBlockProducts =
         om_->outputProcessBlockHelper().processesWithProcessBlockProducts();
     for (auto const& processName : processesWithProcessBlockProducts) {
       processBlockTrees_.emplace_back(std::make_unique<RootOutputTree>(
           filePtr(), InProcess, om_->splitLevel(), om_->treeMaxVirtualSize(), processName));
     }
 
     if (om_->compressionAlgorithm() == std::string("ZLIB")) {
       filePtr_->SetCompressionAlgorithm(ROOT::kZLIB);
     } else if (om_->compressionAlgorithm() == std::string("LZMA")) {
       filePtr_->SetCompressionAlgorithm(ROOT::kLZMA);
     } else if (om_->compressionAlgorithm() == std::string("ZSTD")) {
       filePtr_->SetCompressionAlgorithm(ROOT::kZSTD);
     } else if (om_->compressionAlgorithm() == std::string("LZ4")) {
       filePtr_->SetCompressionAlgorithm(ROOT::kLZ4);
     } else {
       throw Exception(errors::Configuration)
           << "PoolOutputModule configured with unknown compression algorithm '" << om_->compressionAlgorithm() << "'\n"
           << "Allowed compression algorithms are ZLIB, LZMA, LZ4, and ZSTD\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_);
 
     if (om_->outputProcessBlockHelper().productsFromInputKept()) {
       eventTree_.addAuxiliary<EventToProcessBlockIndexes>(poolNames::eventToProcessBlockIndexesBranchName(),
                                                           pEventToProcessBlockIndexes_,
                                                           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_.emplace_back(&eventTree_);
     treePointers_.emplace_back(&lumiTree_);
     treePointers_.emplace_back(&runTree_);
     for (auto& processBlockTree : processBlockTrees_) {
       treePointers_.emplace_back(processBlockTree.get());
     }
 
     for (unsigned int i = 0; i < treePointers_.size(); ++i) {
       RootOutputTree* theTree = treePointers_[i];
       for (auto& item : om_->selectedOutputItemList()[i]) {
         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
   }

edm::RootOutputFile::~RootOutputFile ( )

inline

Definition at line 56 of file RootOutputFile.h.

56 {}

Member Function Documentation

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

Definition at line 330 of file RootOutputFile.cc.

References cms::cuda::assert(), edm::FileBlock::BranchMismatch, edm::FileBlock::CanFastClone, canFastCloneAux_, edm::RootOutputTree::checkIfFastClonable(), edm::RootOutputTree::checkSplitLevelsAndBasketSizes(), compactEventAuxiliary_, edm::FileBlock::EventSelectionUsed, eventTree_, Exception, file_, edm::FileBlock::fileName(), filePtr_, timingPdfMaker::infile, edm::match(), edm::RootOutputTree::maybeFastCloneTree(), SiStripPI::min, edm::errors::MismatchedInputFiles, edm::FileBlock::NoRootInputSource, om_, edm::FileBlock::OutputMaxEventsTooSmall, edm::FileBlock::ParallelProcesses, reportToken_, edm::CompactEventAuxiliaryVector::reserve(), edm::RootOutputTree::setSubBranchBasketSizes(), edm::CompactEventAuxiliaryVector::size(), edm::FileBlock::SplitLevelMismatch, edm::FileBlock::tree(), edm::FileBlock::whyNotFastClonable(), and whyNotFastClonable_.

                                                                               {
     // 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 spite 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;
         }
       }
 
       // reasons for whyNotFastClonable that are also inconsistent with a merge job
       constexpr auto setSubBranchBasketConditions =
           FileBlock::EventsOrLumisSelectedByID | FileBlock::InitialEventsSkipped | FileBlock::MaxEventsTooSmall |
           FileBlock::MaxLumisTooSmall | FileBlock::EventSelectionUsed | FileBlock::OutputMaxEventsTooSmall |
           FileBlock::SplitLevelMismatch | FileBlock::BranchMismatch;
 
       if (om_->inputFileCount() == 1) {
         if (om_->mergeJob()) {
           // for merge jobs always forward the compression mode
           auto infile = fb.tree()->GetCurrentFile();
           if (infile != nullptr) {
             filePtr_->SetCompressionSettings(infile->GetCompressionSettings());
           }
         }
 
         // if we aren't fast cloning, and the reason why is consistent with a
         // merge job or is only because of parallel processes, then forward all
         // the sub-branch basket sizes
         if (whyNotFastClonable_ != FileBlock::CanFastClone &&
             ((om_->mergeJob() && (whyNotFastClonable_ & setSubBranchBasketConditions) == 0) ||
              (whyNotFastClonable_ == FileBlock::ParallelProcesses))) {
           eventTree_.setSubBranchBasketSizes(fb.tree());
         }
       }
 
       // 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);
       }
     }
   }

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

inline

Definition at line 81 of file RootOutputFile.h.

References file_.

81 { return file_; }

edm::RootOutputFile::file_

std::string file_

Definition: RootOutputFile.h:110

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

inlineprivate

Definition at line 100 of file RootOutputFile.h.

References filePtr_, and edm::get_underlying_safe().

Referenced by RootOutputFile().

100 { return get_underlying_safe(filePtr_); }

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:41

edm::RootOutputFile::filePtr_

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

Definition: RootOutputFile.h:116

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

inlineprivate

Definition at line 101 of file RootOutputFile.h.

References filePtr_, and edm::get_underlying_safe().

101 { return get_underlying_safe(filePtr_); }

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:41

edm::RootOutputFile::filePtr_

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

Definition: RootOutputFile.h:116

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

private

Definition at line 838 of file RootOutputFile.cc.

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

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

                                                                                      {
     std::vector<std::unique_ptr<WrapperBase> > dummies;
 
     OutputItemList& items = om_->selectedOutputItemList()[ttreeIndex];
 
     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_[ttreeIndex]->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_[ttreeIndex]->fillTree();
     if (doProvenance)
       productProvenanceVecPtr->clear();
   }

void edm::RootOutputFile::finishEndFile ( )

Definition at line 754 of file RootOutputFile.cc.

References filePtr_, mps_fire::i, edm::InProcess, metaDataTree_, om_, parameterSetsTree_, parentageTree_, FSQHLTOfflineSource_cfi::processName, reportToken_, setBranchAliases(), AlCaHLTBitMon_QueryRunRegistry::string, MainPageGenerator::tree, treePointers_, and edm::RootOutputTree::writeTTree().

                                      {
     metaDataTree_->SetEntries(-1);
     RootOutputTree::writeTTree(metaDataTree_);
     RootOutputTree::writeTTree(parameterSetsTree_);
 
     RootOutputTree::writeTTree(parentageTree_);
 
     // Create branch aliases for all the branches in the
     // events/lumis/runs/processblock trees. The loop is over
     // all types of data products.
     for (unsigned int i = 0; i < treePointers_.size(); ++i) {
       std::string processName;
       BranchType branchType = InProcess;
       if (i < InProcess) {
         branchType = static_cast<BranchType>(i);
       } else {
         processName = om_->outputProcessBlockHelper().processesWithProcessBlockProducts()[i - InProcess];
       }
       setBranchAliases(treePointers_[i]->tree(), om_->keptProducts()[branchType], processName);
       treePointers_[i]->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_) {
       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_);
   }

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 813 of file RootOutputFile.cc.

References cms::cuda::assert(), branchesWithStoredHistory_, edm::ProductProvenance::branchID(), edm::ProductProvenanceLookup::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().

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

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

private

Definition at line 915 of file RootOutputFile.cc.

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

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

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

inlineprivate

Definition at line 102 of file RootOutputFile.h.

References edm::get_underlying_safe(), and pEventEntryInfoVector_.

Referenced by RootOutputFile().

                                                                        {
       return get_underlying_safe(pEventEntryInfoVector_);
     }

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

inlineprivate

Definition at line 105 of file RootOutputFile.h.

References edm::get_underlying_safe(), and pEventEntryInfoVector_.

105 { return get_underlying_safe(pEventEntryInfoVector_); }

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:41

edm::RootOutputFile::pEventEntryInfoVector_

edm::propagate_const< StoredProductProvenanceVector * > pEventEntryInfoVector_

Definition: RootOutputFile.h:133

void edm::RootOutputFile::respondToCloseInputFile ( FileBlock const & fb )

Definition at line 448 of file RootOutputFile.cc.

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

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

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

private

Definition at line 791 of file RootOutputFile.cc.

References HLT_FULL_cff::alias, edm::BranchDescription::branchAliases(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), full, edm::InProcess, edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), edm::BranchDescription::productInstanceName(), corrVsCorr::selection, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by finishEndFile().

                                                                             {
     if (tree && tree->GetNbranches() != 0) {
       for (auto const& selection : branches) {
         BranchDescription const& pd = *selection.first;
         if (pd.branchType() == InProcess && processName != pd.processName()) {
           continue;
         }
         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());
           }
         }
       }
     }
   }

bool edm::RootOutputFile::shouldWeCloseFile ( ) const

Definition at line 457 of file RootOutputFile.cc.

References filePtr_, om_, and findQualityFiles::size.

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

void edm::RootOutputFile::writeBranchIDListRegistry ( )

Definition at line 644 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeEventAuxiliary ( )

Definition at line 710 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeFileFormatVersion ( )

Definition at line 598 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeFileIdentifier ( )

Definition at line 607 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeIndexIntoFile ( )

Definition at line 614 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeLuminosityBlock ( LuminosityBlockForOutput const & lb )

Definition at line 518 of file RootOutputFile.cc.

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(), and edm::LuminosityBlockAuxiliary::setProcessHistoryID().

                                                                               {
     // 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_;
     unsigned int ttreeIndex = InLumi;
     fillBranches(InLumi, lb, ttreeIndex);
     lumiTree_.optimizeBaskets(10ULL * 1024 * 1024);
 
     Service<JobReport> reportSvc;
     reportSvc->reportLumiSection(reportToken_, lb.id().run(), lb.id().luminosityBlock(), nEventsInLumi_);
     nEventsInLumi_ = 0;
   }

void edm::RootOutputFile::writeOne ( EventForOutput const & e )

Definition at line 463 of file RootOutputFile.cc.

References edm::IndexIntoFile::addEntry(), cms::cuda::assert(), edm::EventForOutput::branchListIndexes(), compactEventAuxiliary_, dtTPAnalyzer_cfg::dataType, dataTypeReported_, edm::EventID::event(), edm::EventAuxiliary::event(), edm::EventForOutput::eventAuxiliary(), eventEntryNumber_, edm::EventForOutput::eventSelectionIDs(), edm::EventForOutput::eventToProcessBlockIndexes(), fillBranches(), edm::EventForOutput::id(), indexIntoFile_, edm::InEvent, edm::EventAuxiliary::isRealData(), edm::EventAuxiliary::luminosityBlock(), nEventsInLumi_, om_, pBranchListIndexes_, pEventAux_, pEventEntryInfoVector_, pEventSelectionIDs_, pEventToProcessBlockIndexes_, edm::OccurrenceForOutput::processHistory(), edm::OccurrenceForOutput::processHistoryID(), edm::EventAuxiliary::processHistoryID(), processHistoryRegistry_, edm::EventForOutput::productProvenanceRetrieverPtr(), edm::CompactEventAuxiliaryVector::push_back(), edm::ProcessHistoryRegistry::reducedProcessHistoryID(), edm::ProcessHistoryRegistry::registerProcessHistory(), reportToken_, edm::EventID::run(), edm::EventAuxiliary::run(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                        {
     // 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();
     pEventToProcessBlockIndexes_ = &e.eventToProcessBlockIndexes();
 
     // 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);
     unsigned int ttreeIndex = InEvent;
     fillBranches(InEvent, e, ttreeIndex, 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_;
   }

void edm::RootOutputFile::writeParameterSetRegistry ( )

Definition at line 659 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeParentageRegistry ( )

Definition at line 576 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeProcessBlock ( ProcessBlockForOutput const & pb )

Definition at line 562 of file RootOutputFile.cc.

References HLT_FULL_cff::distance, fillBranches(), spr::find(), edm::InProcess, om_, edm::ProcessBlockForOutput::processName(), FSQHLTOfflineSource_cfi::processName, AlCaHLTBitMon_QueryRunRegistry::string, and treePointers_.

                                                                         {
     std::string const& processName = pb.processName();
     std::vector<std::string> const& processesWithProcessBlockProducts =
         om_->outputProcessBlockHelper().processesWithProcessBlockProducts();
     std::vector<std::string>::const_iterator it =
         std::find(processesWithProcessBlockProducts.cbegin(), processesWithProcessBlockProducts.cend(), processName);
     if (it == processesWithProcessBlockProducts.cend()) {
       return;
     }
     unsigned int ttreeIndex = InProcess + std::distance(processesWithProcessBlockProducts.cbegin(), it);
     fillBranches(InProcess, pb, ttreeIndex);
     treePointers_[ttreeIndex]->optimizeBaskets(10ULL * 1024 * 1024);
   }

void edm::RootOutputFile::writeProcessBlockHelper ( )

Definition at line 740 of file RootOutputFile.cc.

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

                                                {
     if (!om_->outputProcessBlockHelper().processesWithProcessBlockProducts().empty()) {
       StoredProcessBlockHelper storedProcessBlockHelper(
           om_->outputProcessBlockHelper().processesWithProcessBlockProducts());
       om_->outputProcessBlockHelper().fillCacheIndices(storedProcessBlockHelper);
 
       StoredProcessBlockHelper* pStoredProcessBlockHelper = &storedProcessBlockHelper;
       TBranch* b = metaDataTree_->Branch(
           poolNames::processBlockHelperBranchName().c_str(), &pStoredProcessBlockHelper, om_->basketSize(), 0);
       assert(b);
       b->Fill();
     }
   }

void edm::RootOutputFile::writeProcessHistoryRegistry ( )

Definition at line 640 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeProductDependencies ( )

Definition at line 694 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeProductDescriptionRegistry ( )

Definition at line 663 of file RootOutputFile.cc.

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

                                                        {
     // Make a local copy of the ProductRegistry, removing any transient or pruned products.
     using ProductList = ProductRegistry::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();
   }

void edm::RootOutputFile::writeRun ( RunForOutput const & r )

Definition at line 540 of file RootOutputFile.cc.

References edm::IndexIntoFile::addEntry(), edm::MergeableRunProductMetadata::addEntryToStoredMetadata(), fillBranches(), indexIntoFile_, edm::InRun, edm::RunForOutput::mergeableRunProductMetadata(), edm::RootOutputTree::optimizeBaskets(), edm::OccurrenceForOutput::processHistory(), edm::OccurrenceForOutput::processHistoryID(), processHistoryRegistry_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), edm::ProcessHistoryRegistry::registerProcessHistory(), reportToken_, edm::RunAuxiliary::run(), edm::RunForOutput::run(), runAux_, edm::RunForOutput::runAuxiliary(), runEntryNumber_, runTree_, edm::RunAuxiliary::setProcessHistoryID(), and storedMergeableRunProductMetadata_.

                                                      {
     // 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_;
     unsigned int ttreeIndex = InRun;
     fillBranches(InRun, r, ttreeIndex);
     runTree_.optimizeBaskets(10ULL * 1024 * 1024);
 
     Service<JobReport> reportSvc;
     reportSvc->reportRunNumber(reportToken_, r.run());
   }

void edm::RootOutputFile::writeStoredMergeableRunProductMetadata ( )

Definition at line 631 of file RootOutputFile.cc.

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

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

void edm::RootOutputFile::writeThinnedAssociationsHelper ( )

Definition at line 651 of file RootOutputFile.cc.

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

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