#include "MixHelper.h"

Public Types
enum	Mode { Mode::SEQUENTIAL = 0, Mode::RANDOM_REPLACE, Mode::RANDOM_LIM_REPLACE, Mode::RANDOM_NO_REPLACE, Mode::UKNOWN }

Public Member Functions
	MixHelper (fhicl::ParameterSet const &pset, ProducerBase &producesProvider)

Mode	readMode () const

void	registerSecondaryFileNameProvider (ProviderFunc_ func)

template<class P >
void	produces (std::string const &instanceName={})

template<class P , BranchType B>
void	produces (std::string const &instanceName={})

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD >
void	declareMixOp (InputTag const &inputTag, MixFunc< PROD, OPROD > mixFunc, bool outputProduct=true)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD >
void	declareMixOp (InputTag const &inputTag, std::string const &outputInstanceLabel, MixFunc< PROD, OPROD > mixFunc, bool outputProduct=true)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, bool(T::mixfunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &), T &t, bool outputProduct=true)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, std::string const &outputInstanceLabel, bool(T::mixfunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &), T &t, bool outputProduct=true)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, bool(T::mixfunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const, T const &t, bool outputProduct=true)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, std::string const &outputInstanceLabel, bool(T::mixfunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const, T const &t, bool outputProduct=true)

bool	generateEventSequence (size_t nSecondaries, EntryNumberSequence &enSeq, EventIDSequence &eIDseq)

void	generateEventAuxiliarySequence (EntryNumberSequence const &, EventAuxiliarySequence &)

void	mixAndPut (EntryNumberSequence const &enSeq, EventIDSequence const &eIDseq, Event &e)

void	setEventsToSkipFunction (std::function< size_t()> eventsToSkip)

template<art::BranchType B, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, bool(T::mixFunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &), T &t, bool outputProduct)

template<art::BranchType B, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, std::string const &outputInstanceLabel, bool(T::mixFunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &), T &t, bool outputProduct)

template<art::BranchType B, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, bool(T::mixFunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const, T const &t, bool outputProduct)

template<art::BranchType B, typename PROD , typename OPROD , typename T >
void	declareMixOp (InputTag const &inputTag, std::string const &outputInstanceLabel, bool(T::mixFunc)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const, T const &t, bool outputProduct)

Private Types
typedef std::function< std::string()>	ProviderFunc_

using	MixOpList = std::vector< std::unique_ptr< MixOpBase >>

Private Member Functions
	MixHelper (MixHelper const &)=delete

MixHelper &	operator= (MixHelper const &)=delete

Mode	initReadMode_ (std::string const &mode) const

void	openAndReadMetaData_ (std::string fileName)

bool	openNextFile_ ()

void	buildProductIDTransMap_ (ProdToProdMapBuilder::ProductIDTransMap &transMap)

Private Attributes
ProducerBase &	producesProvider_

std::vector< std::string > const	filenames_

bool	compactMissingProducts_

ProviderFunc_	providerFunc_ {}

MixOpList	mixOps_ {}

PtrRemapper	ptrRemapper_ {}

std::vector< std::string >::const_iterator	fileIter_

Mode const	readMode_

double const	coverageFraction_

Long64_t	nEventsReadThisFile_ {}

Long64_t	nEventsInFile_ {}

Long64_t	totalEventsRead_ {}

bool const	canWrapFiles_

FileFormatVersion	ffVersion_ {}

std::unique_ptr< art::BranchIDLists >	branchIDLists_

ProdToProdMapBuilder	ptpBuilder_ {}

std::unique_ptr< CLHEP::RandFlat >	dist_

std::function< size_t()>	eventsToSkip_ {}

EntryNumberSequence	shuffledSequence_ {}

bool	haveSubRunMixOps_ {false}

bool	haveRunMixOps_ {false}

cet::value_ptr< TFile >	currentFile_ {}

cet::exempt_ptr< TTree >	currentMetaDataTree_ {nullptr}

std::array< cet::exempt_ptr< TTree >, art::BranchType::NumBranchTypes >	currentDataTrees_ {{nullptr}}

FileIndex	currentFileIndex_ {}

std::array< RootBranchInfoList, art::BranchType::NumBranchTypes >	dataBranches_

EventIDIndex	eventIDIndex_ {}

Detailed Description

Definition at line 244 of file MixHelper.h.

Member Typedef Documentation

using art::MixHelper::MixOpList = std::vector<std::unique_ptr<MixOpBase>>

private

Definition at line 355 of file MixHelper.h.

typedef std::function<std::string()> art::MixHelper::ProviderFunc_

private

Definition at line 246 of file MixHelper.h.

Member Enumeration Documentation

enum art::MixHelper::Mode

strong

Enumerator
SEQUENTIAL
RANDOM_REPLACE
RANDOM_LIM_REPLACE
RANDOM_NO_REPLACE
UKNOWN

Definition at line 249 of file MixHelper.h.

                   {
     SEQUENTIAL = 0,
     RANDOM_REPLACE,
     RANDOM_LIM_REPLACE,
     RANDOM_NO_REPLACE,
     UKNOWN
   };

Constructor & Destructor Documentation

art::MixHelper::MixHelper	(	fhicl::ParameterSet const &	pset,
		ProducerBase &	producesProvider
	)

Definition at line 119 of file MixHelper.cc.

References canWrapFiles_, compactMissingProducts_, coverageFraction_, dist_, fileIter_, filenames_, initReadMode_(), and readMode_.

   : producesProvider_{producesProvider}
   , filenames_{pset.get<std::vector<std::string>>("fileNames", {})}
   , compactMissingProducts_{pset.get<bool>("compactMissingProducts", false)}
   , fileIter_{filenames_.begin()}
   , readMode_{initReadMode_(pset.get<std::string>("readMode", "sequential"))}
   , coverageFraction_{initCoverageFraction(pset)}
   , canWrapFiles_{pset.get<bool>("wrapFiles", false)}
   , dist_{initDist(readMode_)}
 {}

art::MixHelper::MixHelper ( MixHelper const & )

privatedelete

Member Function Documentation

void art::MixHelper::buildProductIDTransMap_ ( ProdToProdMapBuilder::ProductIDTransMap & transMap )

private

Definition at line 456 of file MixHelper.cc.

References dataBranches_, art::InEvent, and mixOps_.

Referenced by openAndReadMetaData_().

 {
   for (auto& mixOp : mixOps_) {
     auto const bt = mixOp->branchType();
     mixOp->initializeBranchInfo(dataBranches_[bt]);
 #if ART_DEBUG_PTRREMAPPER
     std::cerr << "BranchIDTransMap: " << std::hex << std::setfill('0')
               << std::setw(8) << mixOp->incomingProductID() << " -> "
               << std::setw(8) << mixOp->outgoingProductID() << std::dec
               << ".\n";
 #endif
     if (bt == InEvent) {
       transMap[mixOp->incomingProductID()] = mixOp->outgoingProductID();
     }
   }
 }

template<art::BranchType B, typename PROD , typename OPROD >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		MixFunc< PROD, OPROD >	mixFunc,
		bool	outputProduct = `true`
	)

inline

Definition at line 423 of file MixHelper.h.

References art::InputTag::instance().

 {
   declareMixOp<B>(inputTag, inputTag.instance(), mixFunc, outputProduct); // 2.
 }

template<art::BranchType B, typename PROD , typename OPROD >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		std::string const &	outputInstanceLabel,
		MixFunc< PROD, OPROD >	mixFunc,
		bool	outputProduct = `true`
	)

Definition at line 433 of file MixHelper.h.

References B, compactMissingProducts_, haveRunMixOps_, haveSubRunMixOps_, art::InRun, art::InSubRun, and mixOps_.

 {
   if (outputProduct) {
     produces<OPROD>(outputInstanceLabel);
   }
   if (B == art::InSubRun) {
     haveSubRunMixOps_ = true;
   } else if (B == art::InRun) {
     haveRunMixOps_ = true;
   }
   mixOps_.emplace_back(new MixOp<PROD, OPROD>(inputTag,
                                               outputInstanceLabel,
                                               mixFunc,
                                               outputProduct,
                                               compactMissingProducts_,
                                               B));
 }

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &)	mixfunc,
		T &	t,
		bool	outputProduct = `true`
	)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		std::string const &	outputInstanceLabel,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &)	mixfunc,
		T &	t,
		bool	outputProduct = `true`
	)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const	mixfunc,
		T const &	t,
		bool	outputProduct = `true`
	)

template<art::BranchType B = art::InEvent, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		std::string const &	outputInstanceLabel,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const	mixfunc,
		T const &	t,
		bool	outputProduct = `true`
	)

template<art::BranchType B, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &)	mixFunc,
		T &	t,
		bool	outputProduct
	)

inline

Definition at line 457 of file MixHelper.h.

References art::InputTag::instance().

 {
   declareMixOp<B>(
     inputTag, inputTag.instance(), mixFunc, t, outputProduct); // 4.
 }

template<art::BranchType B, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		std::string const &	outputInstanceLabel,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &)	mixFunc,
		T &	t,
		bool	outputProduct
	)

Definition at line 471 of file MixHelper.h.

 {
   using std::placeholders::_1;
   using std::placeholders::_2;
   using std::placeholders::_3;
   declareMixOp<B>(
     inputTag,
     outputInstanceLabel,
     static_cast<MixFunc<PROD, OPROD>>(std::bind(mixFunc, &t, _1, _2, _3)),
     outputProduct); // 2.
 }

template<art::BranchType B, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const	mixFunc,
		T const &	t,
		bool	outputProduct
	)

inline

Definition at line 492 of file MixHelper.h.

References art::InputTag::instance().

 {
   declareMixOp<B>(
     inputTag, inputTag.instance(), mixFunc, t, outputProduct); // 6.
 }

template<art::BranchType B, typename PROD , typename OPROD , typename T >

void art::MixHelper::declareMixOp	(	InputTag const &	inputTag,
		std::string const &	outputInstanceLabel,
		bool(T::)(std::vector< PROD const > const &, OPROD &, PtrRemapper const &) const	mixFunc,
		T const &	t,
		bool	outputProduct
	)

Definition at line 506 of file MixHelper.h.

 {
   using std::placeholders::_1;
   using std::placeholders::_2;
   using std::placeholders::_3;
   declareMixOp<B>(
     inputTag,
     outputInstanceLabel,
     static_cast<MixFunc<PROD, OPROD>>(std::bind(mixFunc, &t, _1, _2, _3)),
     outputProduct); // 2.
 }

void art::MixHelper::generateEventAuxiliarySequence	(	EntryNumberSequence const &	enseq,
		EventAuxiliarySequence &	auxseq
	)

Definition at line 212 of file MixHelper.cc.

References art::BranchTypeToAuxiliaryBranchName(), currentDataTrees_, art::input::getEntry(), and art::InEvent.

Referenced by art::detail::call_processEventAuxiliaries< T >::operator()().

 {
   auto const eventTree = currentDataTrees_[InEvent];
   auto auxBranch =
     eventTree->GetBranch(BranchTypeToAuxiliaryBranchName(InEvent).c_str());
   auto aux = std::make_unique<EventAuxiliary>();
   auto pAux = aux.get();
   auxBranch->SetAddress(&pAux);
   for (auto const entry : enseq) {
     auto err = eventTree->LoadTree(entry);
     if (err == -2) {
       // FIXME: Throw an error here, taking care to disconnect the
       // branch from the i/o buffer.
       // FIXME: -2 means entry number too big.
     }
     // Note: Root will overwrite the old event
     //       auxiliary with the new one.
     input::getEntry(auxBranch, entry);
     // Note: We are intentionally making a copy here
     //       of the fetched event auxiliary!
     auxseq.push_back(*pAux);
   }
   // Disconnect the branch from the i/o buffer.
   auxBranch->SetAddress(nullptr);
 }

bool art::MixHelper::generateEventSequence	(	size_t	nSecondaries,
		EntryNumberSequence &	enSeq,
		EventIDSequence &	eIDseq
	)

Definition at line 143 of file MixHelper.cc.

References evd::details::begin(), coverageFraction_, dist_, evd::details::end(), eventIDIndex_, ffVersion_, art::FileFormatVersion::isValid(), art::errors::LogicError, nEventsInFile_, nEventsReadThisFile_, openNextFile_(), RANDOM_LIM_REPLACE, RANDOM_NO_REPLACE, RANDOM_REPLACE, readMode_, SEQUENTIAL, and shuffledSequence_.

Referenced by art::MixFilter< T >::filter().

 {
   assert(enSeq.empty());
   assert(eIDseq.empty());
   assert(nEventsInFile_ >= 0);
   bool over_threshold =
     (readMode_ == Mode::SEQUENTIAL || readMode_ == Mode::RANDOM_NO_REPLACE) ?
       ((nEventsReadThisFile_ + nSecondaries) >
        static_cast<size_t>(nEventsInFile_)) :
       ((nEventsReadThisFile_ + nSecondaries) >
        (nEventsInFile_ * coverageFraction_));
   if (over_threshold || (!ffVersion_.isValid())) {
     if (openNextFile_()) {
       return generateEventSequence(nSecondaries, enSeq, eIDseq);
     } else {
       return false;
     }
   }
   switch (readMode_) {
     case Mode::SEQUENTIAL:
       enSeq.reserve(nSecondaries);
       for (size_t i = nEventsReadThisFile_,
                   end = nEventsReadThisFile_ + nSecondaries;
            i < end;
            ++i) {
         enSeq.push_back(i);
       }
       break;
     case Mode::RANDOM_REPLACE:
       std::generate_n(std::back_inserter(enSeq), nSecondaries, [this] {
         return dist_.get()->fireInt(nEventsInFile_);
       });
       std::sort(enSeq.begin(), enSeq.end());
       break;
     case Mode::RANDOM_LIM_REPLACE: {
       std::unordered_set<EntryNumberSequence::value_type>
         entries; // Guaranteed unique.
       while (entries.size() < nSecondaries) {
         std::generate_n(
           std::inserter(entries, entries.begin()),
           nSecondaries - entries.size(),
           [this] { return dist_.get()->fireInt(nEventsInFile_); });
       }
       enSeq.assign(cbegin(entries), cend(entries));
       std::sort(begin(enSeq), end(enSeq));
       // Since we need to sort at the end anyway, it's unclear whether
       // unordered_set is faster than set even though inserts are
       // approximately linear time. Since the complexity of the sort is
       // NlogN, we'd need a profile run for it all to come out in the
       // wash.
       assert(enSeq.size() == nSecondaries); // Should be true by construction.
     } break;
     case Mode::RANDOM_NO_REPLACE: {
       auto i = cbegin(shuffledSequence_) + nEventsReadThisFile_;
       enSeq.assign(i, i + nSecondaries);
     } break;
     default:
       throw Exception(errors::LogicError)
         << "Unrecognized read mode " << static_cast<int>(readMode_)
         << ". Contact the art developers.\n";
   }
   cet::transform_all(
     enSeq, std::back_inserter(eIDseq), EventIDLookup{eventIDIndex_});
   return true;
 }

auto art::MixHelper::initReadMode_ ( std::string const & mode ) const

private

Definition at line 316 of file MixHelper.cc.

References art::errors::Configuration.

Referenced by MixHelper().

 {
   // These regexes must correspond by index to the valid Mode enumerator
   // values.
   static std::regex const robjs[4]{
     std::regex("^seq", std::regex_constants::icase),
     std::regex("^random(replace)?$", std::regex_constants::icase),
     std::regex("^randomlimreplace$", std::regex_constants::icase),
     std::regex("^randomnoreplace$", std::regex_constants::icase)};
   int i{0};
   for (auto const& r : robjs) {
     if (std::regex_search(mode, r)) {
       return Mode(i);
     } else {
       ++i;
     }
   }
   throw Exception(errors::Configuration)
     << "Unrecognized value of readMode parameter: \"" << mode
     << "\". Valid values are:\n"
     << "  sequential,\n"
     << "  randomReplace (random is accepted for reasons of legacy),\n"
     << "  randomLimReplace,\n"
     << "  randomNoReplace.\n";
 }

void art::MixHelper::mixAndPut	(	EntryNumberSequence const &	enSeq,
		EventIDSequence const &	eIDseq,
		Event &	e
	)

Definition at line 240 of file MixHelper.cc.

References branchIDLists_, art::FileIndex::cend(), currentFile_, currentFileIndex_, art::FileIndex::findPosition(), haveRunMixOps_, haveSubRunMixOps_, art::InEvent, art::InRun, art::InSubRun, art::errors::LogicError, mixOps_, nEventsReadThisFile_, art::errors::NotFound, art::ProdToProdMapBuilder::populateRemapper(), ptpBuilder_, ptrRemapper_, and totalEventsRead_.

Referenced by art::MixFilter< T >::filter().

 {
   // Populate the remapper in case we need to remap any Ptrs.
   ptpBuilder_.populateRemapper(ptrRemapper_, e);
   // Dummy remapper in case we need it.
   static PtrRemapper const nopRemapper;
   // Create required info only if we're likely to need it:
   EntryNumberSequence subRunEntries;
   EntryNumberSequence runEntries;
   if (haveSubRunMixOps_) {
     subRunEntries.reserve(eIDseq.size());
     for (auto const& eID : eIDseq) {
       auto const it = currentFileIndex_.findPosition(eID.subRunID(), true);
       if (it != currentFileIndex_.cend()) {
         subRunEntries.emplace_back(it->entry_);
       } else {
         throw Exception(errors::NotFound, "NO_SUBRUN")
           << "- Unable to find an entry in the SubRun tree corresponding to "
              "event ID "
           << eID << " in secondary mixing input file "
           << currentFile_->GetName() << ".\n";
       }
     }
   }
   if (haveRunMixOps_) {
     runEntries.reserve(eIDseq.size());
     for (auto const& eID : eIDseq) {
       auto const it = currentFileIndex_.findPosition(eID.runID(), true);
       if (it != currentFileIndex_.cend()) {
         runEntries.emplace_back(it->entry_);
       } else {
         throw Exception(errors::NotFound, "NO_RUN")
           << "- Unable to find an entry in the Run tree corresponding to event "
              "ID "
           << eID << " in secondary mixing input file "
           << currentFile_->GetName() << ".\n";
       }
     }
   }
   // Do the branch-wise read, mix and put.
   for (auto const& op : mixOps_) {
     switch (op->branchType()) {
       case InEvent:
         op->readFromFile(eventEntries, branchIDLists_.get());
         op->mixAndPut(e, ptrRemapper_);
         break;
       case InSubRun:
         op->readFromFile(subRunEntries, nullptr);
         // No Ptrs in subrun products.
         op->mixAndPut(e, nopRemapper);
         break;
       case InRun:
         op->readFromFile(runEntries, nullptr);
         // No Ptrs in run products.
         op->mixAndPut(e, nopRemapper);
         break;
       default:
         throw Exception(errors::LogicError, "Unsupported BranchType")
           << "- MixHelper::mixAndPut() attempted to handle unsupported branch "
              "type "
           << op->branchType() << ".\n";
     }
   }
   nEventsReadThisFile_ += eventEntries.size();
   totalEventsRead_ += eventEntries.size();
 }

void art::MixHelper::openAndReadMetaData_ ( std::string fileName )

private

Definition at line 343 of file MixHelper.cc.

References branchIDLists_, buildProductIDTransMap_(), currentDataTrees_, currentFile_, currentFileIndex_, currentMetaDataTree_, dataBranches_, dist_, e, art::FileFormatVersion::era_, eventIDIndex_, ffVersion_, art::errors::FileOpenError, art::errors::FileReadError, art::getFileFormatEra(), art::InEvent, art::rootNames::metaDataTreeName(), n, nEventsInFile_, art::Open, art::ProdToProdMapBuilder::prepareTranslationTables(), ptpBuilder_, RANDOM_NO_REPLACE, art::detail::readFileIndex(), art::detail::readMetadata(), readMode_, and shuffledSequence_.

Referenced by openNextFile_().

 {
   // Open file.
   try {
     currentFile_.reset(TFile::Open(filename.c_str()));
   }
   catch (std::exception const& e) {
     throw Exception(errors::FileOpenError, e.what())
       << "Unable to open specified secondary event stream file " << filename
       << ".\n";
   }
   if (!currentFile_ || currentFile_->IsZombie()) {
     throw Exception(errors::FileOpenError)
       << "Unable to open specified secondary event stream file " << filename
       << ".\n";
   }
   // Obtain meta data tree.
   currentMetaDataTree_.reset(static_cast<TTree*>(
     currentFile_->Get(rootNames::metaDataTreeName().c_str())));
   if (currentMetaDataTree_.get() == nullptr) {
     throw Exception(errors::FileReadError)
       << "Unable to read meta data tree from secondary event stream file "
       << filename << ".\n";
   }
   currentDataTrees_ = initDataTrees(currentFile_);
   nEventsInFile_ = currentDataTrees_[InEvent]->GetEntries();
 
   ffVersion_ =
     detail::readMetadata<FileFormatVersion>(currentMetaDataTree_.get());
 
   // Read file index
   FileIndex* fileIndexPtr = &currentFileIndex_;
   detail::readFileIndex(
     currentFile_.get(), currentMetaDataTree_.get(), fileIndexPtr);
 
   // To support files that contain BranchIDLists
   BranchIDLists branchIDLists{};
   if (detail::readMetadata(currentMetaDataTree_.get(), branchIDLists)) {
     branchIDLists_ = std::make_unique<BranchIDLists>(std::move(branchIDLists));
     configureProductIDStreamer(branchIDLists_.get());
   }
 
   // Check file format era.
   std::string const expected_era = getFileFormatEra();
   if (ffVersion_.era_ != expected_era) {
     throw Exception(errors::FileReadError)
       << "Can only read files written during the \"" << expected_era
       << "\" era: "
       << "Era of "
       << "\"" << filename << "\" was "
       << (ffVersion_.era_.empty() ? "not set" :
                                     ("set to \"" + ffVersion_.era_ + "\" "))
       << ".\n";
   }
   auto dbCount = 0;
   for (auto const tree : currentDataTrees_) {
     if (tree.get()) {
       dataBranches_[dbCount].reset(tree.get());
     }
     ++dbCount;
   }
 
   eventIDIndex_ = buildEventIDIndex(currentFileIndex_);
   ProdToProdMapBuilder::ProductIDTransMap transMap;
   buildProductIDTransMap_(transMap);
   ptpBuilder_.prepareTranslationTables(transMap);
   if (readMode_ == Mode::RANDOM_NO_REPLACE) {
     // Prepare shuffled event sequence.
     shuffledSequence_.resize(static_cast<size_t>(nEventsInFile_));
     std::iota(shuffledSequence_.begin(), shuffledSequence_.end(), 0);
     std::random_shuffle(shuffledSequence_.begin(),
                         shuffledSequence_.end(),
                         [this](EntryNumberSequence::difference_type const& n) {
                           return dist_.get()->fireInt(n);
                         });
   }
 }

bool art::MixHelper::openNextFile_ ( )

private

Definition at line 422 of file MixHelper.cc.

References canWrapFiles_, eventsToSkip_, ffVersion_, fileIter_, filenames_, art::FileFormatVersion::isValid(), nEventsReadThisFile_, openAndReadMetaData_(), providerFunc_, readMode_, SEQUENTIAL, and totalEventsRead_.

Referenced by generateEventSequence().

 {
   std::string filename;
   if (providerFunc_) {
     filename = providerFunc_();
     if (filename.empty()) {
       return false;
     }
   } else if (filenames_.empty()) {
     return false;
   } else {
     if (ffVersion_.isValid()) { // Already seen one file.
       ++fileIter_;
     }
     if (fileIter_ == filenames_.end()) {
       if (canWrapFiles_) {
         mf::LogWarning("MixingInputWrap")
           << "Wrapping around to initial input file for mixing after "
           << totalEventsRead_ << " secondary events read.";
         fileIter_ = filenames_.begin();
       } else {
         return false;
       }
     }
     filename = *fileIter_;
   }
   nEventsReadThisFile_ = (readMode_ == Mode::SEQUENTIAL && eventsToSkip_) ?
                            eventsToSkip_() :
                            0; // Reset for this file.
   openAndReadMetaData_(filename);
   return true;
 }

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

privatedelete

template<class P >

void art::MixHelper::produces ( std::string const & instanceName = {} )

inline

Definition at line 407 of file MixHelper.h.

References art::ProductRegistryHelper::produces(), and producesProvider_.

 {
   producesProvider_.produces<P>(instanceName);
 }

template<class P , art::BranchType B>

void art::MixHelper::produces ( std::string const & instanceName = {} )

inline

Definition at line 415 of file MixHelper.h.

References B, art::ProductRegistryHelper::produces(), and producesProvider_.

 {
   producesProvider_.produces<P, B>(instanceName);
 }

auto art::MixHelper::readMode ( ) const

inline

Definition at line 399 of file MixHelper.h.

References readMode_.

 {
   return readMode_;
 }

void art::MixHelper::registerSecondaryFileNameProvider ( ProviderFunc_ func )

Definition at line 132 of file MixHelper.cc.

References art::errors::Configuration, filenames_, and providerFunc_.

 {
   if (!filenames_.empty()) {
     throw Exception(errors::Configuration)
       << "Provision of a secondary file name provider is incompatible"
       << " with a\nnon-empty fileNames parameter to the mix filter.\n";
   }
   providerFunc_ = func;
 }

void art::MixHelper::setEventsToSkipFunction ( std::function< size_t()> eventsToSkip )

Definition at line 310 of file MixHelper.cc.

References eventsToSkip_.

Referenced by art::detail::setup_eventsToSkip< T >::setup_eventsToSkip().

 {
   eventsToSkip_ = eventsToSkip;
 }

Member Data Documentation

std::unique_ptr<art::BranchIDLists> art::MixHelper::branchIDLists_

private

Initial value:

{

nullptr}

Definition at line 378 of file MixHelper.h.

Referenced by mixAndPut(), and openAndReadMetaData_().

bool const art::MixHelper::canWrapFiles_

private

Definition at line 376 of file MixHelper.h.

Referenced by MixHelper(), and openNextFile_().

bool art::MixHelper::compactMissingProducts_

private

Definition at line 366 of file MixHelper.h.

Referenced by declareMixOp(), and MixHelper().

double const art::MixHelper::coverageFraction_

private

Definition at line 372 of file MixHelper.h.

Referenced by generateEventSequence(), and MixHelper().

std::array<cet::exempt_ptr<TTree>, art::BranchType::NumBranchTypes> art::MixHelper::currentDataTrees_ {{nullptr}}

private

Definition at line 391 of file MixHelper.h.

Referenced by generateEventAuxiliarySequence(), and openAndReadMetaData_().

cet::value_ptr<TFile> art::MixHelper::currentFile_ {}

private

Definition at line 388 of file MixHelper.h.

Referenced by mixAndPut(), and openAndReadMetaData_().

FileIndex art::MixHelper::currentFileIndex_ {}

private

Definition at line 392 of file MixHelper.h.

Referenced by mixAndPut(), and openAndReadMetaData_().

cet::exempt_ptr<TTree> art::MixHelper::currentMetaDataTree_ {nullptr}

private

Definition at line 389 of file MixHelper.h.

Referenced by openAndReadMetaData_().

std::array<RootBranchInfoList, art::BranchType::NumBranchTypes> art::MixHelper::dataBranches_

private

Initial value:

{

{}}

Definition at line 393 of file MixHelper.h.

Referenced by buildProductIDTransMap_(), and openAndReadMetaData_().

std::unique_ptr<CLHEP::RandFlat> art::MixHelper::dist_

private

Definition at line 381 of file MixHelper.h.

Referenced by generateEventSequence(), MixHelper(), and openAndReadMetaData_().

EventIDIndex art::MixHelper::eventIDIndex_ {}

private

Definition at line 395 of file MixHelper.h.

Referenced by generateEventSequence(), and openAndReadMetaData_().

std::function<size_t()> art::MixHelper::eventsToSkip_ {}

private

Definition at line 382 of file MixHelper.h.

Referenced by openNextFile_(), and setEventsToSkipFunction().

FileFormatVersion art::MixHelper::ffVersion_ {}

private

Definition at line 377 of file MixHelper.h.

Referenced by generateEventSequence(), openAndReadMetaData_(), and openNextFile_().

std::vector<std::string>::const_iterator art::MixHelper::fileIter_

private

Definition at line 370 of file MixHelper.h.

Referenced by MixHelper(), and openNextFile_().

std::vector<std::string> const art::MixHelper::filenames_

private

Definition at line 365 of file MixHelper.h.

Referenced by MixHelper(), openNextFile_(), and registerSecondaryFileNameProvider().

bool art::MixHelper::haveRunMixOps_ {false}

private

Definition at line 385 of file MixHelper.h.

Referenced by declareMixOp(), and mixAndPut().

bool art::MixHelper::haveSubRunMixOps_ {false}

private

Definition at line 384 of file MixHelper.h.

Referenced by declareMixOp(), and mixAndPut().

MixOpList art::MixHelper::mixOps_ {}

private

Definition at line 368 of file MixHelper.h.

Referenced by buildProductIDTransMap_(), declareMixOp(), and mixAndPut().

Long64_t art::MixHelper::nEventsInFile_ {}

private

Definition at line 374 of file MixHelper.h.

Referenced by generateEventSequence(), and openAndReadMetaData_().

Long64_t art::MixHelper::nEventsReadThisFile_ {}

private

Definition at line 373 of file MixHelper.h.

Referenced by generateEventSequence(), mixAndPut(), and openNextFile_().

ProducerBase& art::MixHelper::producesProvider_

private

Definition at line 364 of file MixHelper.h.

Referenced by produces().

ProviderFunc_ art::MixHelper::providerFunc_ {}

private

Definition at line 367 of file MixHelper.h.

Referenced by openNextFile_(), and registerSecondaryFileNameProvider().

ProdToProdMapBuilder art::MixHelper::ptpBuilder_ {}

private

Definition at line 380 of file MixHelper.h.

Referenced by mixAndPut(), and openAndReadMetaData_().

PtrRemapper art::MixHelper::ptrRemapper_ {}

private

Definition at line 369 of file MixHelper.h.

Referenced by mixAndPut().

Mode const art::MixHelper::readMode_

private

Definition at line 371 of file MixHelper.h.

Referenced by generateEventSequence(), MixHelper(), openAndReadMetaData_(), openNextFile_(), and readMode().

EntryNumberSequence art::MixHelper::shuffledSequence_ {}

private

Definition at line 383 of file MixHelper.h.

Referenced by generateEventSequence(), and openAndReadMetaData_().

Long64_t art::MixHelper::totalEventsRead_ {}

private

Definition at line 375 of file MixHelper.h.

Referenced by mixAndPut(), and openNextFile_().

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

art/Framework/IO/ProductMix/MixHelper.h
art/Framework/IO/ProductMix/MixHelper.cc

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation