#include <RootOutputFile.h>

Classes
struct	OutputItem

Public Types
enum	ClosureRequestMode { ClosureRequestMode::MaxEvents = 0, ClosureRequestMode::MaxSize = 1, ClosureRequestMode::Unset = 2 }

using	RootOutputTreePtrArray = std::array< std::unique_ptr< RootOutputTree >, NumBranchTypes >

Public Member Functions
	~RootOutputFile ()

	RootOutputFile (OutputModule *, std::string const &fileName, ClosingCriteria const &fileSwitchCriteria, int const compressionLevel, int64_t const saveMemoryObjectThreshold, int64_t const treeMaxVirtualSize, int const splitLevel, int const basketSize, DropMetaData dropMetaData, bool dropMetaDataForDroppedData, bool fastCloningRequested)

	RootOutputFile (RootOutputFile const &)=delete

	RootOutputFile (RootOutputFile &&)=delete

RootOutputFile &	operator= (RootOutputFile const &)=delete

RootOutputFile &	operator= (RootOutputFile &&)=delete

void	writeTTrees ()

void	writeOne (EventPrincipal const &)

void	writeSubRun (SubRunPrincipal const &)

void	writeRun (RunPrincipal const &)

void	writeFileFormatVersion ()

void	writeFileIndex ()

void	writeEventHistory ()

void	writeProcessConfigurationRegistry ()

void	writeProcessHistoryRegistry ()

void	writeParameterSetRegistry ()

void	writeProductDescriptionRegistry ()

void	writeParentageRegistry ()

void	writeProductDependencies ()

void	writeFileCatalogMetadata (FileStatsCollector const &stats, FileCatalogMetadata::collection_type const &, FileCatalogMetadata::collection_type const &)

void	writeResults (ResultsPrincipal &resp)

void	setRunAuxiliaryRangeSetID (RangeSet const &)

void	setSubRunAuxiliaryRangeSetID (RangeSet const &)

void	beginInputFile (RootFileBlock const *, bool fastClone)

void	incrementInputFileNumber ()

void	respondToCloseInputFile (FileBlock const &)

bool	requestsToCloseFile ()

void	setFileStatus (OutputFileStatus const ofs)

void	selectProducts ()

std::string const &	currentFileName () const

bool	maxEventsPerFileReached (FileIndex::EntryNumber_t const maxEventsPerFile) const

bool	maxSizeReached (unsigned const maxFileSize) const

template<BranchType BT>
enable_if_t<!RangeSetsSupported< BT >::value, EDProduct const * >	getProduct (OutputHandle const &oh, RangeSet const &, string const &wrappedName)

template<BranchType BT>
enable_if_t< RangeSetsSupported< BT >::value, EDProduct const * >	getProduct (OutputHandle const &oh, RangeSet const &prunedProductRS, string const &wrappedName)

Static Public Member Functions
static bool	shouldFastClone (bool const fastCloningSet, bool const fastCloning, bool const wantAllEvents, ClosingCriteria const &cc)

Private Member Functions
template<BranchType >
void	fillBranches (Principal const &, std::vector< ProductProvenance > *)

template<BranchType BT>
std::enable_if_t<!detail::RangeSetsSupported< BT >::value, EDProduct const * >	getProduct (OutputHandle const &, RangeSet const &productRS, std::string const &wrappedName)

template<BranchType BT>
std::enable_if_t< detail::RangeSetsSupported< BT >::value, EDProduct const * >	getProduct (OutputHandle const &, RangeSet const &productRS, std::string const &wrappedName)

Private Attributes
hep::concurrency::RecursiveMutex	mutex_

OutputModule const *	om_

std::string	file_

ClosingCriteria	fileSwitchCriteria_

OutputFileStatus	status_

int const	compressionLevel_

int64_t const	saveMemoryObjectThreshold_

int64_t const	treeMaxVirtualSize_

int const	splitLevel_

int const	basketSize_

DropMetaData	dropMetaData_

bool	dropMetaDataForDroppedData_

bool	fastCloningEnabledAtConstruction_

bool	wasFastCloned_

std::unique_ptr< TFile >	filePtr_

FileIndex	fileIndex_

FileProperties	fp_

TTree *	metaDataTree_

TTree *	fileIndexTree_

TTree *	parentageTree_

TTree *	eventHistoryTree_

EventAuxiliary const *	pEventAux_

SubRunAuxiliary const *	pSubRunAux_

RunAuxiliary const *	pRunAux_

ResultsAuxiliary const *	pResultsAux_

ProductProvenances	eventProductProvenanceVector_

ProductProvenances	subRunProductProvenanceVector_

ProductProvenances	runProductProvenanceVector_

ProductProvenances	resultsProductProvenanceVector_

ProductProvenances *	pEventProductProvenanceVector_

ProductProvenances *	pSubRunProductProvenanceVector_

ProductProvenances *	pRunProductProvenanceVector_

ProductProvenances *	pResultsProductProvenanceVector_

History const *	pHistory_

RootOutputTreePtrArray	treePointers_

bool	dataTypeReported_

std::array< ProductDescriptionsByID, NumBranchTypes >	descriptionsToPersist_

std::unique_ptr< cet::sqlite::Connection >	rootFileDB_

std::array< std::set< OutputItem >, NumBranchTypes >	selectedOutputItemList_

detail::DummyProductCache	dummyProductCache_

unsigned	subRunRSID_

unsigned	runRSID_

std::chrono::steady_clock::time_point	beginTime_

Detailed Description

Definition at line 47 of file RootOutputFile.h.

Member Typedef Documentation

using art::RootOutputFile::RootOutputTreePtrArray = std::array<std::unique_ptr<RootOutputTree>, NumBranchTypes>

Definition at line 51 of file RootOutputFile.h.

Member Enumeration Documentation

enum art::RootOutputFile::ClosureRequestMode

strong

Enumerator
MaxEvents
MaxSize
Unset

Definition at line 49 of file RootOutputFile.h.

49 { MaxEvents = 0, MaxSize = 1, Unset = 2 };

util::flags::Unset

constexpr BitMask< Storage > Unset(Flag_t< Storage > flag)

Returns a bit mask which unsets the specified flag.

Constructor & Destructor Documentation

art::RootOutputFile::~RootOutputFile ( )

default

art::RootOutputFile::RootOutputFile	(	OutputModule *	om,
		std::string const &	fileName,
		ClosingCriteria const &	fileSwitchCriteria,
		int const	compressionLevel,
		int64_t const	saveMemoryObjectThreshold,
		int64_t const	treeMaxVirtualSize,
		int const	splitLevel,
		int const	basketSize,
		DropMetaData	dropMetaData,
		bool	dropMetaDataForDroppedData,
		bool	fastCloningRequested
	)

explicit

Definition at line 382 of file RootOutputFile.cc.

     : mutex_{"RootOutputFile::mutex_"}
     , compressionLevel_{compressionLevel}
     , saveMemoryObjectThreshold_{saveMemoryObjectThreshold}
     , treeMaxVirtualSize_{treeMaxVirtualSize}
     , splitLevel_{splitLevel}
     , basketSize_{basketSize}
     , dropMetaData_{dropMetaData}
     , descriptionsToPersist_{{}}
     , selectedOutputItemList_{{}}
   {
     om_ = om;
     file_ = fileName;
     fileSwitchCriteria_ = fileSwitchCriteria;
     status_ = OutputFileStatus::Closed;
     dropMetaDataForDroppedData_ = dropMetaDataForDroppedData;
     fastCloningEnabledAtConstruction_ = fastCloningRequested;
     wasFastCloned_ = false;
     filePtr_.reset(
       TFile::Open(file_.c_str(), "recreate", "", compressionLevel));
     // Don't split metadata tree or event description tree
     metaDataTree_ = RootOutputTree::makeTTree(
       filePtr_.get(), rootNames::metaDataTreeName(), 0);
     fileIndexTree_ = RootOutputTree::makeTTree(
       filePtr_.get(), rootNames::fileIndexTreeName(), 0);
     parentageTree_ = RootOutputTree::makeTTree(
       filePtr_.get(), rootNames::parentageTreeName(), 0);
     // Create the tree that will carry (event) History objects.
     eventHistoryTree_ = RootOutputTree::makeTTree(
       filePtr_.get(), rootNames::eventHistoryTreeName(), splitLevel);
     if (!eventHistoryTree_) {
       throw Exception(errors::FatalRootError)
         << "Failed to create the tree for History objects\n";
     }
     pEventAux_ = nullptr;
     pSubRunAux_ = nullptr;
     pRunAux_ = nullptr;
     pResultsAux_ = nullptr;
     pEventProductProvenanceVector_ = &eventProductProvenanceVector_;
     pSubRunProductProvenanceVector_ = &subRunProductProvenanceVector_;
     pRunProductProvenanceVector_ = &runProductProvenanceVector_;
     pResultsProductProvenanceVector_ = &resultsProductProvenanceVector_;
     pHistory_ = new History;
     if (!eventHistoryTree_->Branch(rootNames::eventHistoryBranchName().c_str(),
                                    &pHistory_,
                                    basketSize,
                                    0)) {
       throw Exception(errors::FatalRootError)
         << "Failed to create a branch for History in the output file\n";
     }
     delete pHistory_;
     pHistory_ = nullptr;
     treePointers_[0] =
       make_unique<RootOutputTree>(filePtr_.get(),
                                   InEvent,
                                   pEventAux_,
                                   pEventProductProvenanceVector_,
                                   basketSize,
                                   splitLevel,
                                   treeMaxVirtualSize,
                                   saveMemoryObjectThreshold);
     treePointers_[1] =
       make_unique<RootOutputTree>(filePtr_.get(),
                                   InSubRun,
                                   pSubRunAux_,
                                   pSubRunProductProvenanceVector_,
                                   basketSize,
                                   splitLevel,
                                   treeMaxVirtualSize,
                                   saveMemoryObjectThreshold);
     treePointers_[2] = make_unique<RootOutputTree>(filePtr_.get(),
                                                    InRun,
                                                    pRunAux_,
                                                    pRunProductProvenanceVector_,
                                                    basketSize,
                                                    splitLevel,
                                                    treeMaxVirtualSize,
                                                    saveMemoryObjectThreshold);
     treePointers_[3] =
       make_unique<RootOutputTree>(filePtr_.get(),
                                   InResults,
                                   pResultsAux_,
                                   pResultsProductProvenanceVector_,
                                   basketSize,
                                   splitLevel,
                                   treeMaxVirtualSize,
                                   saveMemoryObjectThreshold);
     dataTypeReported_ = false;
     rootFileDB_.reset(
       ServiceHandle<DatabaseConnection> {}->get<TKeyVFSOpenPolicy>(
         "RootFileDB",
         filePtr_.get(),
         SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE));
     subRunRSID_ = -1U;
     runRSID_ = -1U;
     beginTime_ = chrono::steady_clock::now();
     // Check that dictionaries for the auxiliaries exist
     root::DictionaryChecker checker;
     checker.checkDictionaries<EventAuxiliary>();
     checker.checkDictionaries<SubRunAuxiliary>();
     checker.checkDictionaries<RunAuxiliary>();
     checker.checkDictionaries<ResultsAuxiliary>();
     checker.reportMissingDictionaries();
     // Event ranges
     create_table(*rootFileDB_,
                  "EventRanges",
                  {"SubRun INTEGER",
                   "begin INTEGER",
                   "end INTEGER",
                   "UNIQUE (SubRun,begin,end) ON CONFLICT IGNORE"});
     // SubRun range sets
     using namespace cet::sqlite;
     create_table(*rootFileDB_, "SubRunRangeSets", column<int>{"Run"});
     create_table(*rootFileDB_,
                  "SubRunRangeSets_EventRanges",
                  {"RangeSetsID INTEGER",
                   "EventRangesID INTEGER",
                   "PRIMARY KEY(RangeSetsID,EventRangesID)"},
                  "WITHOUT ROWID");
     // Run range sets
     create_table(*rootFileDB_, "RunRangeSets", column<int>{"Run"});
     create_table(*rootFileDB_,
                  "RunRangeSets_EventRanges",
                  {"RangeSetsID INTEGER",
                   "EventRangesID INTEGER",
                   "PRIMARY KEY(RangeSetsID,EventRangesID)"},
                  "WITHOUT ROWID");
   }

art::RootOutputFile::RootOutputFile ( RootOutputFile const & )

delete

art::RootOutputFile::RootOutputFile ( RootOutputFile && )

delete

Member Function Documentation

void art::RootOutputFile::beginInputFile	(	RootFileBlock const *	rfb,
		bool	fastClone
	)

Definition at line 567 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     // FIXME: the logic here is nasty.
     bool shouldFastClone{fastCloningEnabledAtConstruction_ &&
                          fastCloneFromOutputModule && rfb};
     // Create output branches, and then redo calculation to determine if
     // fast cloning should be done.
     selectProducts();
     if (shouldFastClone &&
         !treePointers_[InEvent]->checkSplitLevelAndBasketSize(rfb->tree())) {
       mf::LogWarning("FastCloning")
         << "Fast cloning deactivated for this input file due to "
         << "splitting level and/or basket size.";
       shouldFastClone = false;
     } else if (rfb && rfb->tree() &&
                rfb->tree()->GetCurrentFile()->GetVersion() < 60001) {
       mf::LogWarning("FastCloning")
         << "Fast cloning deactivated for this input file due to "
         << "ROOT version used to write it (< 6.00/01)\n"
            "having a different splitting policy.";
       shouldFastClone = false;
     }
     if (shouldFastClone && rfb->fileFormatVersion().value_ < 10) {
       mf::LogWarning("FastCloning")
         << "Fast cloning deactivated for this input file due to "
         << "reading in file that has a different ProductID schema.";
       shouldFastClone = false;
     }
     if (shouldFastClone && !fastCloningEnabledAtConstruction_) {
       mf::LogWarning("FastCloning")
         << "Fast cloning reactivated for this input file.";
     }
     treePointers_[InEvent]->beginInputFile(shouldFastClone);
     auto tree = (rfb && rfb->tree()) ? rfb->tree() : nullptr;
     wasFastCloned_ = treePointers_[InEvent]->fastCloneTree(tree);
   }

string const & art::RootOutputFile::currentFileName ( ) const

Definition at line 529 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     return file_;
   }

template<BranchType BT>

void art::RootOutputFile::fillBranches	(	Principal const &	principal,
		std::vector< ProductProvenance > *	vpp
	)

private

Definition at line 977 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     bool const fastCloning = ((BT == InEvent) && wasFastCloned_);
     map<unsigned, unsigned> checksumToIndex;
     auto const& principalRS = principal.seenRanges();
     set<ProductProvenance> keptprv;
     for (auto const& val : selectedOutputItemList_[BT]) {
       auto const& bd = val.branchDescription_;
       auto const pid = bd.productID();
       descriptionsToPersist_[BT].emplace(pid, bd);
       bool const produced = bd.produced();
       bool const resolveProd = (produced || !fastCloning ||
                                 treePointers_[BT]->uncloned(bd.branchName()));
       // Update the kept provenance
       bool const keepProvenance =
         ((dropMetaData_ == DropMetaData::DropNone) ||
          (produced && (dropMetaData_ == DropMetaData::DropPrior)));
       auto const& oh = principal.getForOutput(pid, resolveProd);
       auto prov = keptprv.begin();
       if (keepProvenance) {
         if (oh.productProvenance()) {
           prov = keptprv.insert(*oh.productProvenance()).first;
           if ((dropMetaData_ != DropMetaData::DropAll) &&
               !dropMetaDataForDroppedData_) {
             {
               vector<ProductProvenance const*> stacked_pp;
               stacked_pp.push_back(&*oh.productProvenance());
               while (true) {
                 if (stacked_pp.size() == 0) {
                   break;
                 }
                 auto current_pp = stacked_pp.back();
                 stacked_pp.pop_back();
                 for (auto const parent_bid :
                      current_pp->parentage().parents()) {
                   // Note: Suppose the parent ProductID corresponds to
                   //       product that has been requested to be
                   //       "dropped"--i.e. someone has specified "drop
                   //       *_m1a_*_*" in their configuration, and
                   //       although a given product matching this
                   //       pattern will not be included in the
                   //       selectedProducts_ list, one of the parents of
                   //       a selected product can match the "dropping"
                   //       pattern and its BranchDescription will still
                   //       be written to disk since it is inserted into
                   //       the descriptionsToPersist_ data member.
                   auto parent_bd = principal.getProductDescription(parent_bid);
                   if (!parent_bd) {
                     // FIXME: Is this an error condition?
                     continue;
                   }
                   descriptionsToPersist_[BT].emplace(parent_bid, *parent_bd);
                   if (!parent_bd->produced()) {
                     // We got it from the input, nothing to do.
                     continue;
                   }
                   auto parent_pp =
                     principal.branchToProductProvenance(parent_bid);
                   if (!parent_pp || (dropMetaData_ != DropMetaData::DropNone)) {
                     continue;
                   }
                   if (!keptprv.insert(*parent_pp).second) {
                     // Already there, done.
                     continue;
                   }
                   if ((dropMetaData_ != DropMetaData::DropAll) &&
                       !dropMetaDataForDroppedData_) {
                     stacked_pp.push_back(parent_pp.get());
                   }
                 }
               }
             }
           }
         } else {
           // No provenance: product was either not produced, or was
           // dropped; create provenance to remember that.
           auto status = productstatus::dropped();
           if (produced) {
             status = productstatus::neverCreated();
           }
           prov = keptprv.emplace(pid, status).first;
         }
       }
       // Resolve the product if we are going to attempt to write it out.
       if (resolveProd) {
         // Product was either produced, or we are not cloning the whole
         // file and the product branch was not cloned so we should be
         // able to get a pointer to it from the passed principal and
         // write it out.
         auto const& rs = getRangeSet<BT>(oh, principalRS, produced);
         if (RangeSetsSupported<BT>::value && !rs.is_valid()) {
           // At this point we are now going to write out a dummy product
           // whose Wrapper present flag is false because the range set
           // got invalidated to present double counting when combining
           // run or subrun products from multiple fragments.  We change
           // the provenance status that we are going to write out to
           // dummyToPreventDoubleCount to flag this case.  Note that the
           // requirement is only that the status not be
           // productstatus::present().  We use a special code to make it
           // easier for humans to tell what is going on.
           auto prov_bid = prov->productID();
           if (keptprv.erase(*prov) != 1ull) {
             throw Exception(errors::LogicError, "KeptProvenance::setStatus")
               << "Attempt to set product status for product whose provenance "
                  "is not being recorded.\n";
           }
           prov =
             keptprv
               .emplace(prov_bid, productstatus::dummyToPreventDoubleCount())
               .first;
         }
         auto const* product = getProduct<BT>(oh, rs, bd.wrappedName());
         setProductRangeSetID<BT>(
           rs, *rootFileDB_, const_cast<EDProduct*>(product), checksumToIndex);
         val.product_ = product;
       }
     }
     vpp->assign(keptprv.begin(), keptprv.end());
     for (auto const& val : *vpp) {
       if (val.productStatus() == productstatus::uninitialized()) {
         throw Exception(errors::LogicError,
                         "RootOutputFile::fillBranches(principal, vpp):")
           << "Attempt to write a product with uninitialized provenance!\n";
       }
     }
     treePointers_[BT]->fillTree();
     vpp->clear();
   }

template<BranchType BT>

std::enable_if_t<!detail::RangeSetsSupported<BT>::value, EDProduct const*> art::RootOutputFile::getProduct	(	OutputHandle const &	,
		RangeSet const &	productRS,
		std::string const &	wrappedName
	)

private

template<BranchType BT>

std::enable_if_t<detail::RangeSetsSupported<BT>::value, EDProduct const*> art::RootOutputFile::getProduct	(	OutputHandle const &	,
		RangeSet const &	productRS,
		std::string const &	wrappedName
	)

private

template<BranchType BT>

enable_if_t<!RangeSetsSupported<BT>::value, EDProduct const*> art::RootOutputFile::getProduct	(	OutputHandle const &	oh,
		RangeSet const &	,
		string const &	wrappedName
	)

Definition at line 951 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     if (oh.isValid()) {
       return oh.wrapper();
     }
     return dummyProductCache_.product(wrappedName);
   }

template<BranchType BT>

enable_if_t<RangeSetsSupported<BT>::value, EDProduct const*> art::RootOutputFile::getProduct	(	OutputHandle const &	oh,
		RangeSet const &	prunedProductRS,
		string const &	wrappedName
	)

Definition at line 964 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     if (oh.isValid() && prunedProductRS.is_valid()) {
       return oh.wrapper();
     }
     return dummyProductCache_.product(wrappedName);
   }

void art::RootOutputFile::incrementInputFileNumber ( )

Definition at line 607 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     fp_.update_inputFile();
   }

bool art::RootOutputFile::maxEventsPerFileReached ( FileIndex::EntryNumber_t const maxEventsPerFile ) const

bool art::RootOutputFile::maxSizeReached ( unsigned const maxFileSize ) const

RootOutputFile& art::RootOutputFile::operator= ( RootOutputFile const & )

delete

RootOutputFile& art::RootOutputFile::operator= ( RootOutputFile && )

delete

bool art::RootOutputFile::requestsToCloseFile ( )

Definition at line 621 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     using namespace chrono;
     unsigned int constexpr oneK{1024u};
     fp_.updateSize(filePtr_->GetSize() / oneK);
     fp_.updateAge(duration_cast<seconds>(steady_clock::now() - beginTime_));
     return fileSwitchCriteria_.should_close(fp_);
   }

void art::RootOutputFile::respondToCloseInputFile ( FileBlock const & )

Definition at line 614 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     cet::for_all(treePointers_, [](auto const& p) { p->setEntries(); });
   }

void art::RootOutputFile::selectProducts ( )

Definition at line 536 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     auto selectProductsToWrite = [this](BranchType const bt) {
       auto& items = selectedOutputItemList_[bt];
       for (auto const& pr : om_->keptProducts()[bt]) {
         auto const& pd = pr.second;
         // Persist Results products only if they have been produced by
         // the current process.
         if (bt == InResults && !pd.produced()) {
           continue;
         }
         checkDictionaries(pd);
         // Although the transient flag is already checked when
         // OutputModule::doSelectProducts is called, it can be flipped
         // to 'true' after the BranchDescription transients have been
         // fluffed, which happens during the checkDictionaries call.
         if (pd.transient()) {
           continue;
         }
         items.emplace(pd);
       }
       for (auto const& val : items) {
         treePointers_[bt]->addOutputBranch(val.branchDescription_,
                                            val.product_);
       }
     };
     for_each_branch_type(selectProductsToWrite);
   }

void art::RootOutputFile::setFileStatus ( OutputFileStatus const ofs )

Definition at line 522 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     status_ = ofs;
   }

void art::RootOutputFile::setRunAuxiliaryRangeSetID ( RangeSet const & ranges )

Definition at line 940 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     runRSID_ = getNewRangeSetID(*rootFileDB_, InRun, ranges.run());
     insertIntoEventRanges(*rootFileDB_, ranges);
     auto const& eventRangesIDs = getExistingRangeSetIDs(*rootFileDB_, ranges);
     insertIntoJoinTable(*rootFileDB_, InRun, runRSID_, eventRangesIDs);
   }

void art::RootOutputFile::setSubRunAuxiliaryRangeSetID ( RangeSet const & ranges )

Definition at line 930 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     subRunRSID_ = getNewRangeSetID(*rootFileDB_, InSubRun, ranges.run());
     insertIntoEventRanges(*rootFileDB_, ranges);
     auto const& eventRangesIDs = getExistingRangeSetIDs(*rootFileDB_, ranges);
     insertIntoJoinTable(*rootFileDB_, InSubRun, subRunRSID_, eventRangesIDs);
   }

bool art::RootOutputFile::shouldFastClone	(	bool const	fastCloningSet,
		bool const	fastCloning,
		bool const	wantAllEvents,
		ClosingCriteria const &	cc
	)

static

Definition at line 354 of file RootOutputFile.cc.

   {
     bool result = fastCloning;
     mf::LogInfo("FastCloning")
       << "Initial fast cloning configuration "
       << (fastCloningSet ? "(user-set): " : "(from default): ") << boolalpha
       << fastCloning;
     if (fastCloning && !wantAllEvents) {
       result = false;
       mf::LogWarning("FastCloning")
         << "Fast cloning deactivated due to presence of\n"
         << "event selection configuration.";
     }
     if (fastCloning && maxCriterionSpecified(cc) &&
         cc.granularity() < Granularity::InputFile) {
       result = false;
       mf::LogWarning("FastCloning")
         << "Fast cloning deactivated due to request to allow\n"
         << "output file switching at an Event, SubRun, or Run boundary.";
     }
     return result;
   }

void art::RootOutputFile::writeEventHistory ( )

Definition at line 754 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     RootOutputTree::writeTTree(eventHistoryTree_);
   }

void art::RootOutputFile::writeFileCatalogMetadata	(	FileStatsCollector const &	stats,
		FileCatalogMetadata::collection_type const &	md,
		FileCatalogMetadata::collection_type const &	ssmd
	)

Definition at line 788 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     using namespace cet::sqlite;
     Ntuple<string, string> fileCatalogMetadata{
       *rootFileDB_, "FileCatalog_metadata", {{"Name", "Value"}}, true};
     Transaction txn{*rootFileDB_};
     for (auto const& kv : md) {
       fileCatalogMetadata.insert(kv.first, kv.second);
     }
     // Add our own specific information: File format and friends.
     fileCatalogMetadata.insert("file_format", "\"artroot\"");
     fileCatalogMetadata.insert("file_format_era",
                                cet::canonical_string(getFileFormatEra()));
     fileCatalogMetadata.insert("file_format_version",
                                std::to_string(getFileFormatVersion()));
     // File start time.
     namespace bpt = boost::posix_time;
     auto formatted_time = [](auto const& t) {
       return cet::canonical_string(bpt::to_iso_extended_string(t));
     };
     fileCatalogMetadata.insert("start_time",
                                formatted_time(stats.outputFileOpenTime()));
     // File "end" time: now, since file is not actually closed yet.
     fileCatalogMetadata.insert(
       "end_time",
       formatted_time(boost::posix_time::second_clock::universal_time()));
     // Run/subRun information.
     if (!stats.seenSubRuns().empty()) {
       auto I = find_if(md.crbegin(), md.crend(), [](auto const& p) {
         return p.first == "run_type";
       });
       if (I != md.crend()) {
         ostringstream buf;
         buf << "[ ";
         for (auto const& srid : stats.seenSubRuns()) {
           buf << "[ " << srid.run() << ", " << srid.subRun() << ", "
               << cet::canonical_string(I->second) << " ], ";
         }
         // Rewind over last delimiter.
         buf.seekp(-2, ios_base::cur);
         buf << " ]";
         fileCatalogMetadata.insert("runs", buf.str());
       }
     }
     // Number of events.
     fileCatalogMetadata.insert("event_count",
                                std::to_string(stats.eventsThisFile()));
     // first_event and last_event.
     auto eidToTuple = [](EventID const& eid) -> string {
       ostringstream eidStr;
       eidStr << "[ " << eid.run() << ", " << eid.subRun() << ", " << eid.event()
              << " ]";
       return eidStr.str();
     };
     fileCatalogMetadata.insert("first_event",
                                eidToTuple(stats.lowestEventID()));
     fileCatalogMetadata.insert("last_event",
                                eidToTuple(stats.highestEventID()));
     // File parents.
     if (!stats.parents().empty()) {
       ostringstream pstring;
       pstring << "[ ";
       for (auto const& parent : stats.parents()) {
         pstring << cet::canonical_string(parent) << ", ";
       }
       // Rewind over last delimiter.
       pstring.seekp(-2, ios_base::cur);
       pstring << " ]";
       fileCatalogMetadata.insert("parents", pstring.str());
     }
     // Incoming stream-specific metadata overrides.
     for (auto const& kv : ssmd) {
       fileCatalogMetadata.insert(kv.first, kv.second);
     }
     txn.commit();
   }

void art::RootOutputFile::writeFileFormatVersion ( )

Definition at line 723 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     FileFormatVersion const ver{getFileFormatVersion(), getFileFormatEra()};
     auto const* pver = &ver;
     TBranch* b = metaDataTree_->Branch(
       metaBranchRootName<FileFormatVersion>(), &pver, basketSize_, 0);
     // FIXME: Turn this into a throw!
     assert(b);
     b->Fill();
   }

void art::RootOutputFile::writeFileIndex ( )

Definition at line 736 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     fileIndex_.sortBy_Run_SubRun_Event();
     FileIndex::Element elem{};
     auto const* findexElemPtr = &elem;
     TBranch* b = fileIndexTree_->Branch(
       metaBranchRootName<FileIndex::Element>(), &findexElemPtr, basketSize_, 0);
     // FIXME: Turn this into a throw!
     assert(b);
     for (auto& entry : fileIndex_) {
       findexElemPtr = &entry;
       b->Fill();
     }
     b->SetAddress(0);
   }

void art::RootOutputFile::writeOne ( EventPrincipal const & e )

Definition at line 632 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     // Auxiliary branch.
     // Note: pEventAux_ must be set before calling fillBranches
     // since it gets written out in that routine.
     pEventAux_ = &e.eventAux();
     // 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.
     fillBranches<InEvent>(e, pEventProductProvenanceVector_);
     // History branch.
     History historyForOutput{e.history()};
     historyForOutput.addEventSelectionEntry(om_->selectorConfig());
     pHistory_ = &historyForOutput;
     int sz = eventHistoryTree_->Fill();
     if (sz <= 0) {
       throw Exception(errors::FatalRootError)
         << "Failed to fill the History tree for event: " << e.eventID()
         << "\nTTree::Fill() returned " << sz << " bytes written." << endl;
     }
     // Add the dataType to the job report if it hasn't already been done
     if (!dataTypeReported_) {
       string dataType{"MC"};
       if (pEventAux_->isRealData()) {
         dataType = "Data";
       }
       dataTypeReported_ = true;
     }
     pHistory_ = &e.history();
     // Add event to index
     fileIndex_.addEntry(pEventAux_->eventID(), fp_.eventEntryNumber());
     fp_.update_event();
   }

void art::RootOutputFile::writeParameterSetRegistry ( )

Definition at line 870 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     fhicl::ParameterSetRegistry::exportTo(*rootFileDB_);
   }

void art::RootOutputFile::writeParentageRegistry ( )

Definition at line 692 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     auto pid = root::getObjectRequireDict<ParentageID>();
     ParentageID const* hash = &pid;
     if (!parentageTree_->Branch(
           rootNames::parentageIDBranchName().c_str(), &hash, basketSize_, 0)) {
       throw Exception(errors::FatalRootError)
         << "Failed to create a branch for ParentageIDs in the output file";
     }
     hash = nullptr;
     auto par = root::getObjectRequireDict<Parentage>();
     Parentage const* desc = &par;
     if (!parentageTree_->Branch(
           rootNames::parentageBranchName().c_str(), &desc, basketSize_, 0)) {
       throw Exception(errors::FatalRootError)
         << "Failed to create a branch for Parentages in the output file";
     }
     desc = nullptr;
     for (auto const& pr : ParentageRegistry::get()) {
       hash = &pr.first;
       desc = &pr.second;
       parentageTree_->Fill();
     }
     parentageTree_->SetBranchAddress(rootNames::parentageIDBranchName().c_str(),
                                      nullptr);
     parentageTree_->SetBranchAddress(rootNames::parentageBranchName().c_str(),
                                      nullptr);
   }

void art::RootOutputFile::writeProcessConfigurationRegistry ( )

Definition at line 761 of file RootOutputFile.cc.

   {
     // We don't do this yet; currently we're storing a slightly
     // bloated ProcessHistoryRegistry.
   }

void art::RootOutputFile::writeProcessHistoryRegistry ( )

Definition at line 768 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     ProcessHistoryMap pHistMap;
     for (auto const& pr : ProcessHistoryRegistry::get()) {
       pHistMap.emplace(pr);
     }
     auto const* p = &pHistMap;
     TBranch* b = metaDataTree_->Branch(
       metaBranchRootName<ProcessHistoryMap>(), &p, basketSize_, 0);
     if (b == nullptr) {
       throw Exception(errors::LogicError)
         << "Unable to locate required "
            "ProcessHistoryMap branch in output "
            "metadata tree.\n";
     }
     b->Fill();
   }

void art::RootOutputFile::writeProductDependencies ( )

Definition at line 899 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     BranchChildren const* ppDeps = &om_->branchChildren();
     TBranch* b = metaDataTree_->Branch(
       metaBranchRootName<BranchChildren>(), &ppDeps, basketSize_, 0);
     // FIXME: Turn this into a throw!
     assert(b);
     b->Fill();
   }

void art::RootOutputFile::writeProductDescriptionRegistry ( )

Definition at line 877 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     // Make a local copy of the UpdateOutputCallbacks's ProductList,
     // removing any transient or pruned products.
     ProductRegistry reg;
     auto productDescriptionsToWrite = [this, &reg](BranchType const bt) {
       for (auto const& pr : descriptionsToPersist_[bt]) {
         auto const& desc = pr.second;
         reg.productList_.emplace(BranchKey{desc}, desc);
       }
     };
     for_each_branch_type(productDescriptionsToWrite);
     ProductRegistry const* regp = &reg;
     TBranch* b = metaDataTree_->Branch(
       metaBranchRootName<ProductRegistry>(), &regp, basketSize_, 0);
     // FIXME: Turn this into a throw!
     assert(b);
     b->Fill();
   }

void art::RootOutputFile::writeResults ( ResultsPrincipal & resp )

Definition at line 911 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     pResultsAux_ = &resp.resultsAux();
     fillBranches<InResults>(resp, pResultsProductProvenanceVector_);
   }

void art::RootOutputFile::writeRun ( RunPrincipal const & r )

Definition at line 680 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     pRunAux_ = &r.runAux();
     pRunAux_->setRangeSetID(runRSID_);
     fillBranches<InRun>(r, pRunProductProvenanceVector_);
     fileIndex_.addEntry(EventID::invalidEvent(pRunAux_->runID()),
                         fp_.runEntryNumber());
     fp_.update_run(status_);
   }

void art::RootOutputFile::writeSubRun ( SubRunPrincipal const & sr )

Definition at line 668 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     pSubRunAux_ = &sr.subRunAux();
     pSubRunAux_->setRangeSetID(subRunRSID_);
     fillBranches<InSubRun>(sr, pSubRunProductProvenanceVector_);
     fileIndex_.addEntry(EventID::invalidEvent(pSubRunAux_->subRunID()),
                         fp_.subRunEntryNumber());
     fp_.update_subRun(status_);
   }

void art::RootOutputFile::writeTTrees ( )

Definition at line 919 of file RootOutputFile.cc.

   {
     RecursiveMutexSentry sentry{mutex_, __func__};
     RootOutputTree::writeTTree(metaDataTree_);
     RootOutputTree::writeTTree(fileIndexTree_);
     RootOutputTree::writeTTree(parentageTree_);
     for_each_branch_type(
       [this](BranchType const bt) { treePointers_[bt]->writeTree(); });
   }

Member Data Documentation

int const art::RootOutputFile::basketSize_

private

Definition at line 145 of file RootOutputFile.h.

std::chrono::steady_clock::time_point art::RootOutputFile::beginTime_

private

Definition at line 178 of file RootOutputFile.h.

int const art::RootOutputFile::compressionLevel_

private

Definition at line 141 of file RootOutputFile.h.

bool art::RootOutputFile::dataTypeReported_

private

Definition at line 171 of file RootOutputFile.h.

std::array<ProductDescriptionsByID, NumBranchTypes> art::RootOutputFile::descriptionsToPersist_

private

Definition at line 172 of file RootOutputFile.h.

DropMetaData art::RootOutputFile::dropMetaData_

private

Definition at line 146 of file RootOutputFile.h.

bool art::RootOutputFile::dropMetaDataForDroppedData_

private

Definition at line 147 of file RootOutputFile.h.

detail::DummyProductCache art::RootOutputFile::dummyProductCache_

private

Definition at line 175 of file RootOutputFile.h.

TTree* art::RootOutputFile::eventHistoryTree_

private

Definition at line 156 of file RootOutputFile.h.

ProductProvenances art::RootOutputFile::eventProductProvenanceVector_

private

Definition at line 161 of file RootOutputFile.h.

bool art::RootOutputFile::fastCloningEnabledAtConstruction_

private

Definition at line 148 of file RootOutputFile.h.

std::string art::RootOutputFile::file_

private

Definition at line 138 of file RootOutputFile.h.

FileIndex art::RootOutputFile::fileIndex_

private

Definition at line 151 of file RootOutputFile.h.

TTree* art::RootOutputFile::fileIndexTree_

private

Definition at line 154 of file RootOutputFile.h.

std::unique_ptr<TFile> art::RootOutputFile::filePtr_

private

Definition at line 150 of file RootOutputFile.h.

ClosingCriteria art::RootOutputFile::fileSwitchCriteria_

private

Definition at line 139 of file RootOutputFile.h.

FileProperties art::RootOutputFile::fp_

private

Definition at line 152 of file RootOutputFile.h.

TTree* art::RootOutputFile::metaDataTree_

private

Definition at line 153 of file RootOutputFile.h.

hep::concurrency::RecursiveMutex art::RootOutputFile::mutex_

mutableprivate

Definition at line 136 of file RootOutputFile.h.

OutputModule const* art::RootOutputFile::om_

private

Definition at line 137 of file RootOutputFile.h.

TTree* art::RootOutputFile::parentageTree_

private

Definition at line 155 of file RootOutputFile.h.

EventAuxiliary const* art::RootOutputFile::pEventAux_

private

Definition at line 157 of file RootOutputFile.h.

ProductProvenances* art::RootOutputFile::pEventProductProvenanceVector_

private

Definition at line 165 of file RootOutputFile.h.

History const* art::RootOutputFile::pHistory_

private

Definition at line 169 of file RootOutputFile.h.

ResultsAuxiliary const* art::RootOutputFile::pResultsAux_

private

Definition at line 160 of file RootOutputFile.h.

ProductProvenances* art::RootOutputFile::pResultsProductProvenanceVector_

private

Definition at line 168 of file RootOutputFile.h.

RunAuxiliary const* art::RootOutputFile::pRunAux_

private

Definition at line 159 of file RootOutputFile.h.

ProductProvenances* art::RootOutputFile::pRunProductProvenanceVector_

private

Definition at line 167 of file RootOutputFile.h.

SubRunAuxiliary const* art::RootOutputFile::pSubRunAux_

private

Definition at line 158 of file RootOutputFile.h.

ProductProvenances* art::RootOutputFile::pSubRunProductProvenanceVector_

private

Definition at line 166 of file RootOutputFile.h.

ProductProvenances art::RootOutputFile::resultsProductProvenanceVector_

private

Definition at line 164 of file RootOutputFile.h.

std::unique_ptr<cet::sqlite::Connection> art::RootOutputFile::rootFileDB_

private

Definition at line 173 of file RootOutputFile.h.

ProductProvenances art::RootOutputFile::runProductProvenanceVector_

private

Definition at line 163 of file RootOutputFile.h.

unsigned art::RootOutputFile::runRSID_

private

Definition at line 177 of file RootOutputFile.h.

int64_t const art::RootOutputFile::saveMemoryObjectThreshold_

private

Definition at line 142 of file RootOutputFile.h.

std::array<std::set<OutputItem>, NumBranchTypes> art::RootOutputFile::selectedOutputItemList_

private

Definition at line 174 of file RootOutputFile.h.

int const art::RootOutputFile::splitLevel_

private

Definition at line 144 of file RootOutputFile.h.

OutputFileStatus art::RootOutputFile::status_

private

Definition at line 140 of file RootOutputFile.h.

ProductProvenances art::RootOutputFile::subRunProductProvenanceVector_

private

Definition at line 162 of file RootOutputFile.h.

unsigned art::RootOutputFile::subRunRSID_

private

Definition at line 176 of file RootOutputFile.h.

int64_t const art::RootOutputFile::treeMaxVirtualSize_

private

Definition at line 143 of file RootOutputFile.h.

RootOutputTreePtrArray art::RootOutputFile::treePointers_

private

Definition at line 170 of file RootOutputFile.h.

bool art::RootOutputFile::wasFastCloned_

private

Definition at line 149 of file RootOutputFile.h.

The documentation for this class was generated from the following files:

art/art/Framework/IO/Root/RootOutputFile.h
art/art/Framework/IO/Root/RootOutputFile.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation