#include "RootOutputFile.h"

Classes
struct	OutputItem

Public Types
enum	ClosureRequestMode { ClosureRequestMode::MaxEvents, ClosureRequestMode::MaxSize, ClosureRequestMode::Unset }

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

using	OutputItemList = std::set< OutputItem >

using	OutputItemListArray = std::array< OutputItemList, NumBranchTypes >

Public Member Functions
	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)

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>
std::enable_if_t<!RangeSetsSupported< BT >::value, art::EDProduct const * >	getProduct (art::OutputHandle const &oh, art::RangeSet const &, std::string const &wrappedName)

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

Private Member Functions
void	createDatabaseTables ()

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

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

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

Private Attributes
OutputModule const *	om_

std::string	file_

ClosingCriteria	fileSwitchCriteria_

OutputFileStatus	status_ {OutputFileStatus::Closed}

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_ {false}

std::unique_ptr< TFile >	filePtr_

FileIndex	fileIndex_ {}

FileProperties	fp_ {}

TTree *	metaDataTree_ {nullptr}

TTree *	fileIndexTree_ {nullptr}

TTree *	parentageTree_ {nullptr}

TTree *	eventHistoryTree_ {nullptr}

EventAuxiliary const *	pEventAux_ {nullptr}

SubRunAuxiliary const *	pSubRunAux_ {nullptr}

RunAuxiliary const *	pRunAux_ {nullptr}

ResultsAuxiliary const *	pResultsAux_ {nullptr}

ProductProvenances	eventProductProvenanceVector_ {}

ProductProvenances	subRunProductProvenanceVector_ {}

ProductProvenances	runProductProvenanceVector_ {}

ProductProvenances	resultsProductProvenanceVector_ {}

ProductProvenances *	pEventProductProvenanceVector_

ProductProvenances *	pSubRunProductProvenanceVector_

ProductProvenances *	pRunProductProvenanceVector_

ProductProvenances *	pResultsProductProvenanceVector_

History const *	pHistory_ {nullptr}

RootOutputTreePtrArray	treePointers_

bool	dataTypeReported_ {false}

std::set< ProductID >	branchesWithStoredHistory_ {}

cet::sqlite::Connection	rootFileDB_

OutputItemListArray	selectedOutputItemList_ {{}}

detail::DummyProductCache	dummyProductCache_ {}

unsigned	subRunRSID_ {-1u}

unsigned	runRSID_ {-1u}

std::chrono::steady_clock::time_point	beginTime_

Detailed Description

Definition at line 50 of file RootOutputFile.h.

Member Typedef Documentation

using art::RootOutputFile::OutputItemList = std::set<OutputItem>

Definition at line 76 of file RootOutputFile.h.

using art::RootOutputFile::OutputItemListArray = std::array<OutputItemList, NumBranchTypes>

Definition at line 77 of file RootOutputFile.h.

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

Definition at line 54 of file RootOutputFile.h.

Member Enumeration Documentation

enum art::RootOutputFile::ClosureRequestMode

strong

Enumerator
MaxEvents
MaxSize
Unset

Definition at line 52 of file RootOutputFile.h.

52 { MaxEvents, MaxSize, Unset };

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

References basketSize_, compressionLevel_, createDatabaseTables(), dropMetaData_, dropMetaDataForDroppedData_, art::rootNames::eventHistoryBranchName(), eventHistoryTree_, art::rootNames::eventHistoryTreeName(), fastCloningEnabledAtConstruction_, art::errors::FatalRootError, file_, fileIndexTree_, art::rootNames::fileIndexTreeName(), filePtr_, fileSwitchCriteria_, art::ServiceHandle< T, SCOPE >::get(), art::InEvent, art::InResults, art::InRun, art::InSubRun, art::RootOutputTree::makeTTree(), metaDataTree_, art::rootNames::metaDataTreeName(), art::Open, parentageTree_, art::rootNames::parentageTreeName(), pEventAux_, pEventProductProvenanceVector_, pHistory_, pResultsAux_, pResultsProductProvenanceVector_, pRunAux_, pRunProductProvenanceVector_, pSubRunAux_, pSubRunProductProvenanceVector_, rootFileDB_, saveMemoryObjectThreshold_, splitLevel_, treeMaxVirtualSize_, and treePointers_.

   : om_{om}
   , file_{fileName}
   , fileSwitchCriteria_{fileSwitchCriteria}
   , compressionLevel_{compressionLevel}
   , saveMemoryObjectThreshold_{saveMemoryObjectThreshold}
   , treeMaxVirtualSize_{treeMaxVirtualSize}
   , splitLevel_{splitLevel}
   , basketSize_{basketSize}
   , dropMetaData_{dropMetaData}
   , dropMetaDataForDroppedData_{dropMetaDataForDroppedData}
   , fastCloningEnabledAtConstruction_{fastCloningRequested}
   , filePtr_{TFile::Open(file_.c_str(), "recreate", "", compressionLevel)}
   , treePointers_{{// Order (and number) must match BranchTypes.h!
                    std::make_unique<RootOutputTree>(
                      filePtr_.get(),
                      InEvent,
                      pEventAux_,
                      pEventProductProvenanceVector_,
                      basketSize,
                      splitLevel,
                      treeMaxVirtualSize,
                      saveMemoryObjectThreshold),
                    std::make_unique<RootOutputTree>(
                      filePtr_.get(),
                      InSubRun,
                      pSubRunAux_,
                      pSubRunProductProvenanceVector_,
                      basketSize,
                      splitLevel,
                      treeMaxVirtualSize,
                      saveMemoryObjectThreshold),
                    std::make_unique<RootOutputTree>(
                      filePtr_.get(),
                      InRun,
                      pRunAux_,
                      pRunProductProvenanceVector_,
                      basketSize,
                      splitLevel,
                      treeMaxVirtualSize,
                      saveMemoryObjectThreshold),
                    std::make_unique<RootOutputTree>(
                      filePtr_.get(),
                      InResults,
                      pResultsAux_,
                      pResultsProductProvenanceVector_,
                      basketSize,
                      splitLevel,
                      treeMaxVirtualSize,
                      saveMemoryObjectThreshold)}}
   , rootFileDB_{ServiceHandle<DatabaseConnection>{}->get<TKeyVFSOpenPolicy>(
       "RootFileDB",
       filePtr_.get(),
       SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE)}
 {
   // 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 art::Exception(art::errors::FatalRootError)
       << "Failed to create the tree for History objects\n";
   }
 
   pHistory_ = new History;
   if (!eventHistoryTree_->Branch(rootNames::eventHistoryBranchName().c_str(),
                                  &pHistory_,
                                  basketSize,
                                  0)) {
     throw art::Exception(art::errors::FatalRootError)
       << "Failed to create a branch for History in the output file\n";
   }
   delete pHistory_;
   pHistory_ = nullptr;
 
   // Check that dictionaries for the auxiliaries exist
   root::DictionaryChecker checker{};
   checker.checkDictionaries<EventAuxiliary>();
   checker.checkDictionaries<SubRunAuxiliary>();
   checker.checkDictionaries<RunAuxiliary>();
   checker.checkDictionaries<ResultsAuxiliary>();
   checker.reportMissingDictionaries();
 
   createDatabaseTables();
 }

Member Function Documentation

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

Definition at line 477 of file RootOutputFile.cc.

References fastCloningEnabledAtConstruction_, art::InEvent, selectProducts(), art::detail::shouldFastClone(), treePointers_, and wasFastCloned_.

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

void art::RootOutputFile::createDatabaseTables ( )

private

Definition at line 415 of file RootOutputFile.cc.

References rootFileDB_.

Referenced by currentFileName(), and RootOutputFile().

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

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

inline

Definition at line 125 of file RootOutputFile.h.

References createDatabaseTables(), file_, fillBranches(), getProduct(), maxEventsPerFileReached(), maxSizeReached(), and fhicl::detail::atom::value().

   {
     return file_;
   }

template<art::BranchType BT>

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

private

Definition at line 833 of file RootOutputFile.cc.

References branchesWithStoredHistory_, dropMetaData_, dropMetaDataForDroppedData_, art::DropMetaData::DropNone, art::productstatus::dropped(), art::DropMetaData::DropPrior, art::Principal::getForOutput(), art::InEvent, art::RangeSet::is_valid(), art::productstatus::neverCreated(), art::OutputHandle::productProvenance(), rootFileDB_, art::Principal::seenRanges(), selectedOutputItemList_, treePointers_, art::productstatus::unknown(), fhicl::detail::atom::value(), and wasFastCloned_.

Referenced by currentFileName().

 {
   bool const fastCloning = (BT == InEvent) && wasFastCloned_;
   detail::KeptProvenance keptProvenance{
     dropMetaData_, dropMetaDataForDroppedData_, branchesWithStoredHistory_};
   map<unsigned, unsigned> checksumToIndex;
 
   auto const& principalRS = principal.seenRanges();
 
   for (auto const& val : selectedOutputItemList_[BT]) {
     auto const* pd = val.branchDescription_;
     auto const pid = pd->productID();
     branchesWithStoredHistory_.insert(pid);
     bool const produced{pd->produced()};
     bool const resolveProd = (produced || !fastCloning ||
                               treePointers_[BT]->uncloned(pd->branchName()));
 
     // Update the kept provenance
     bool const keepProvenance =
       (dropMetaData_ == DropMetaData::DropNone ||
        (dropMetaData_ == DropMetaData::DropPrior && produced));
     auto const& oh = principal.getForOutput(pid, resolveProd);
 
     unique_ptr<ProductProvenance> prov{nullptr};
     if (keepProvenance) {
       if (oh.productProvenance()) {
         prov = std::make_unique<ProductProvenance>(
           keptProvenance.insert(*oh.productProvenance()));
         keptProvenance.insertAncestors(*oh.productProvenance(), principal);
       } else {
         // No provenance, product was either not produced, or was
         // dropped, create provenance to remember that.
         auto const status =
           produced ? productstatus::neverCreated() : productstatus::dropped();
         prov = std::make_unique<ProductProvenance>(
           keptProvenance.emplace(pid, status));
       }
     }
 
     // Resolve the product if necessary
     if (resolveProd) {
       auto const& rs = getRangeSet<BT>(oh, principalRS, produced);
       if (RangeSetsSupported<BT>::value && !rs.is_valid()) {
         // Unfortunately, 'unknown' is the only viable product status
         // when this condition is triggered (due to the assert
         // statement in ProductStatus::setNotPresent).  Whenever the
         // metadata revolution comes, this should be revised.
         keptProvenance.setStatus(*prov, productstatus::unknown());
       }
 
       auto const* product = getProduct<BT>(oh, rs, pd->wrappedName());
       setProductRangeSetID<BT>(
         rs, rootFileDB_, const_cast<EDProduct*>(product), checksumToIndex);
       val.product_ = product;
     }
   }
   vpp->assign(keptProvenance.begin(), keptProvenance.end());
   treePointers_[BT]->fillTree();
   vpp->clear();
 }

template<BranchType BT>

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

private

Referenced by currentFileName().

template<BranchType BT>

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

private

template<BranchType BT>

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

Definition at line 915 of file RootOutputFile.cc.

References dummyProductCache_, art::OutputHandle::isValid(), art::detail::DummyProductCache::product(), fhicl::detail::atom::value(), and art::OutputHandle::wrapper().

 {
   return oh.isValid() ? oh.wrapper() : dummyProductCache_.product(wrappedName);
 }

template<BranchType BT>

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

Definition at line 924 of file RootOutputFile.cc.

References dummyProductCache_, art::RangeSet::is_valid(), art::OutputHandle::isValid(), art::detail::DummyProductCache::product(), and art::OutputHandle::wrapper().

 {
   return (oh.isValid() && prunedProductRS.is_valid()) ?
            oh.wrapper() :
            dummyProductCache_.product(wrappedName);
 }

void art::RootOutputFile::incrementInputFileNumber ( )

Definition at line 518 of file RootOutputFile.cc.

References fp_, art::Granularity::InputFile, and art::FileProperties::update().

 {
   fp_.update<Granularity::InputFile>();
 }

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

Referenced by currentFileName().

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

Referenced by currentFileName().

bool art::RootOutputFile::requestsToCloseFile ( )

Definition at line 530 of file RootOutputFile.cc.

References beginTime_, filePtr_, fileSwitchCriteria_, fp_, art::ClosingCriteria::should_close(), art::FileProperties::updateAge(), and art::FileProperties::updateSize().

 {
   using namespace std::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 524 of file RootOutputFile.cc.

References treePointers_.

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

void art::RootOutputFile::selectProducts ( )

Definition at line 446 of file RootOutputFile.cc.

References art::checkDictionaries(), art::InEvent, art::InResults, art::OutputModule::keptProducts(), art::NumBranchTypes, om_, selectedOutputItemList_, and treePointers_.

Referenced by beginInputFile(), and setFileStatus().

 {
   for (int i = InEvent; i < NumBranchTypes; ++i) {
     auto const bt = static_cast<BranchType>(i);
     auto& items = selectedOutputItemList_[bt];
 
     for (auto const& pd : om_->keptProducts()[bt]) {
       // 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_);
     }
   }
 }

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

inline

Definition at line 117 of file RootOutputFile.h.

References selectProducts(), and status_.

   {
     status_ = ofs;
   }

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

Definition at line 905 of file RootOutputFile.cc.

References art::InRun, rootFileDB_, art::RangeSet::run(), runRSID_, and fhicl::detail::atom::value().

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

References art::InSubRun, rootFileDB_, art::RangeSet::run(), and subRunRSID_.

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

void art::RootOutputFile::writeEventHistory ( )

Definition at line 658 of file RootOutputFile.cc.

References eventHistoryTree_, and art::RootOutputTree::writeTTree().

 {
   RootOutputTree::writeTTree(eventHistoryTree_);
 }

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

Definition at line 690 of file RootOutputFile.cc.

References art::FileStatsCollector::eventsThisFile(), art::getFileFormatEra(), art::getFileFormatVersion(), art::FileStatsCollector::highestEventID(), art::FileStatsCollector::lowestEventID(), art::FileStatsCollector::outputFileOpenTime(), art::FileStatsCollector::parents(), rootFileDB_, art::FileStatsCollector::seenSubRuns(), and art::to_string().

 {
   using namespace cet::sqlite;
   Ntuple<std::string, std::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",
                              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", 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 629 of file RootOutputFile.cc.

References basketSize_, art::getFileFormatEra(), art::getFileFormatVersion(), and metaDataTree_.

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

References basketSize_, fileIndex_, fileIndexTree_, and art::FileIndex::sortBy_Run_SubRun_Event().

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

References art::FileIndex::addEntry(), art::History::addEventSelectionEntry(), art::EventPrincipal::aux(), dataTypeReported_, e, art::Granularity::Event, art::FileProperties::eventEntryNumber(), eventHistoryTree_, art::errors::FatalRootError, fileIndex_, fp_, art::EventAuxiliary::id(), art::EventAuxiliary::isRealData(), om_, pEventAux_, pEventProductProvenanceVector_, pHistory_, art::EventObserverBase::selectorConfig(), status_, and art::FileProperties::update().

 {
   // Auxiliary branch.
   // Note: pEventAux_ must be set before calling fillBranches
   // since it gets written out in that routine.
   pEventAux_ = &e.aux();
   // 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 art::Exception(art::errors::FatalRootError)
       << "Failed to fill the History tree for event: " << e.id()
       << "\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_->id(), fp_.eventEntryNumber());
   fp_.update<Granularity::Event>(status_);
 }

void art::RootOutputFile::writeParameterSetRegistry ( )

Definition at line 772 of file RootOutputFile.cc.

References fhicl::ParameterSetRegistry::exportTo(), and rootFileDB_.

 {
   fhicl::ParameterSetRegistry::exportTo(rootFileDB_);
 }

void art::RootOutputFile::writeParentageRegistry ( )

Definition at line 597 of file RootOutputFile.cc.

References basketSize_, art::errors::FatalRootError, art::thread_safe_registry_via_id< K, M >::get(), art::rootNames::parentageBranchName(), art::rootNames::parentageIDBranchName(), and parentageTree_.

 {
   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 art::Exception(art::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 664 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 671 of file RootOutputFile.cc.

References basketSize_, art::thread_safe_registry_via_id< K, M >::get(), art::errors::LogicError, and metaDataTree_.

 {
   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) {
     b->Fill();
   } else {
     throw Exception(errors::LogicError) << "Unable to locate required "
                                            "ProcessHistoryMap branch in output "
                                            "metadata tree.\n";
   }
 }

void art::RootOutputFile::writeProductDependencies ( )

Definition at line 801 of file RootOutputFile.cc.

References basketSize_, art::OutputModule::branchChildren(), metaDataTree_, and om_.

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

References basketSize_, branchesWithStoredHistory_, evd::details::end(), art::ProductMetaData::instance(), metaDataTree_, and art::ProductRegistry::productList_.

 {
   // Make a local copy of the MasterProductRegistry's ProductList,
   // removing any transient or pruned products.
   auto end = branchesWithStoredHistory_.end();
 
   ProductRegistry reg;
   for (auto const& pr : ProductMetaData::instance().productList()) {
     if (branchesWithStoredHistory_.find(pr.second.productID()) == end) {
       continue;
     }
     reg.productList_.emplace_hint(reg.productList_.end(), pr);
   }
 
   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 812 of file RootOutputFile.cc.

References art::ResultsPrincipal::aux(), pResultsAux_, and pResultsProductProvenanceVector_.

 {
   pResultsAux_ = &resp.aux();
   fillBranches<InResults>(resp, pResultsProductProvenanceVector_);
 }

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

Definition at line 586 of file RootOutputFile.cc.

References art::FileIndex::addEntry(), art::RunPrincipal::aux(), fileIndex_, fp_, art::RunAuxiliary::id(), art::EventID::invalidEvent(), pRunAux_, pRunProductProvenanceVector_, art::Granularity::Run, art::FileProperties::runEntryNumber(), runRSID_, art::RunAuxiliary::setRangeSetID(), status_, and art::FileProperties::update().

 {
   pRunAux_ = &r.aux();
   pRunAux_->setRangeSetID(runRSID_);
   fillBranches<InRun>(r, pRunProductProvenanceVector_);
   fileIndex_.addEntry(EventID::invalidEvent(pRunAux_->id()),
                       fp_.runEntryNumber());
   fp_.update<Granularity::Run>(status_);
 }

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

Definition at line 575 of file RootOutputFile.cc.

References art::FileIndex::addEntry(), art::SubRunPrincipal::aux(), fileIndex_, fp_, art::SubRunAuxiliary::id(), art::EventID::invalidEvent(), pSubRunAux_, pSubRunProductProvenanceVector_, art::SubRunAuxiliary::setRangeSetID(), status_, art::Granularity::SubRun, art::FileProperties::subRunEntryNumber(), subRunRSID_, and art::FileProperties::update().

 {
   pSubRunAux_ = &sr.aux();
   pSubRunAux_->setRangeSetID(subRunRSID_);
   fillBranches<InSubRun>(sr, pSubRunProductProvenanceVector_);
   fileIndex_.addEntry(EventID::invalidEvent(pSubRunAux_->id()),
                       fp_.subRunEntryNumber());
   fp_.update<Granularity::SubRun>(status_);
 }

void art::RootOutputFile::writeTTrees ( )

Definition at line 819 of file RootOutputFile.cc.

References fileIndexTree_, art::InEvent, metaDataTree_, art::NumBranchTypes, parentageTree_, treePointers_, and art::RootOutputTree::writeTTree().

 {
   RootOutputTree::writeTTree(metaDataTree_);
   RootOutputTree::writeTTree(fileIndexTree_);
   RootOutputTree::writeTTree(parentageTree_);
   // Write out the tree corresponding to each BranchType
   for (int i = InEvent; i < NumBranchTypes; ++i) {
     auto const branchType = static_cast<BranchType>(i);
     treePointers_[branchType]->writeTree();
   }
 }