#include <MixHelper.h>

Inheritance diagram for art::MixHelper:

Classes
struct	Config

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

Public Member Functions
	MixHelper (Config const &config, std::string const &moduleLabel, ProducesCollector &collector, std::unique_ptr< MixIOPolicy > ioHandle)

	MixHelper (fhicl::ParameterSet const &pset, std::string const &moduleLabel, ProducesCollector &collector, std::unique_ptr< MixIOPolicy > ioHandle)

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)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

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

EventAuxiliarySequence	generateEventAuxiliarySequence (EntryNumberSequence const &)

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
using	ProviderFunc_ = std::function< std::string()>

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

Private Types inherited from art::detail::EngineCreator
using	base_engine_t = CLHEP::HepRandomEngine

using	label_t = RNGsnapshot::label_t

using	seed_t = long

using	engine_state_t = RNGsnapshot::engine_state_t

Private Member Functions
	MixHelper (MixHelper const &)=delete

MixHelper &	operator= (MixHelper const &)=delete

cet::exempt_ptr< base_engine_t >	initEngine_ (seed_t seed, Mode readMode)

std::unique_ptr< CLHEP::RandFlat >	initDist_ (cet::exempt_ptr< base_engine_t > engine) const

bool	consistentRequest_ (std::string const &kind_of_engine_to_make, label_t const &engine_label) const

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

bool	openNextFile_ ()

ProdToProdMapBuilder::ProductIDTransMap	buildProductIDTransMap_ (MixOpList &mixOps)

Private Member Functions inherited from art::detail::EngineCreator
	EngineCreator (std::string const &label, ScheduleID sid)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

Private Attributes
ProducesCollector &	collector_

std::string const	moduleLabel_

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_

std::size_t	nEventsReadThisFile_ {}

std::size_t	totalEventsRead_ {}

bool const	canWrapFiles_

unsigned	nOpensOverThreshold_ {}

ProdToProdMapBuilder	ptpBuilder_ {}

cet::exempt_ptr< base_engine_t >	engine_

std::unique_ptr< CLHEP::RandFlat >	dist_

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

EntryNumberSequence	shuffledSequence_ {}

bool	haveSubRunMixOps_ {false}

bool	haveRunMixOps_ {false}

EventIDIndex	eventIDIndex_ {}

std::unique_ptr< MixIOPolicy >	ioHandle_ {nullptr}

Detailed Description

Definition at line 245 of file MixHelper.h.

Member Typedef Documentation

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

private

Definition at line 381 of file MixHelper.h.

using art::MixHelper::ProviderFunc_ = std::function<std::string()>

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
UNKNOWN

Definition at line 249 of file MixHelper.h.

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

Constructor & Destructor Documentation

art::MixHelper::MixHelper	(	Config const &	config,
		std::string const &	moduleLabel,
		ProducesCollector &	collector,
		std::unique_ptr< MixIOPolicy >	ioHandle
	)

explicit

Definition at line 99 of file MixHelper.cc.

   : detail::EngineCreator{moduleLabel, art::ScheduleID::first()}
   , collector_{collector}
   , moduleLabel_{moduleLabel}
   , filenames_{config.filenames()}
   , compactMissingProducts_{config.compactMissingProducts()}
   , fileIter_{filenames_.begin()}
   , readMode_{initReadMode_(config.readMode())}
   , coverageFraction_{initCoverageFraction(config.coverageFraction())}
   , canWrapFiles_{config.wrapFiles()}
   , engine_{initEngine_(config.seed(), readMode_)}
   , dist_{initDist_(engine_)}
   , ioHandle_{move(ioHandle)}
 {}

art::MixHelper::MixHelper	(	fhicl::ParameterSet const &	pset,
		std::string const &	moduleLabel,
		ProducesCollector &	collector,
		std::unique_ptr< MixIOPolicy >	ioHandle
	)

explicit

Definition at line 80 of file MixHelper.cc.

   : detail::EngineCreator{moduleLabel, art::ScheduleID::first()}
   , collector_{collector}
   , moduleLabel_{moduleLabel}
   , 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.get<double>("coverageFraction", 1.0))}
   , canWrapFiles_{pset.get<bool>("wrapFiles", false)}
   , engine_{initEngine_(pset.get<long>("seed", -1), readMode_)}
   , dist_{initDist_(engine_)}
   , ioHandle_{move(ioHandle)}
 {}

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

privatedelete

Member Function Documentation

ProdToProdMapBuilder::ProductIDTransMap art::MixHelper::buildProductIDTransMap_ ( MixOpList & mixOps )

private

bool art::MixHelper::consistentRequest_	(	std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)		const

private

Definition at line 432 of file MixHelper.cc.

 {
   auto const& default_engine_kind =
     ServiceHandle<RandomNumberGenerator const>()->defaultEngineKind();
   if (kind_of_engine_to_make == default_engine_kind && engine_label.empty()) {
     mf::LogInfo{"RANDOM"} << "A random number engine has already been created "
                              "since the read mode is "
                           << readMode_ << '.';
     return true;
   }
   throw Exception{errors::Configuration,
                   "An error occurred while creating a random number engine "
                   "within a MixFilter detail class.\n"}
     << "A random number engine with an empty label has already been created "
        "with an engine type of "
     << default_engine_kind << ".\n"
     << "If you would like to use a different engine type, please supply a "
        "different engine label.\n";
 }

art::MixHelper::base_engine_t & art::MixHelper::createEngine ( seed_t seed )

Definition at line 148 of file MixHelper.cc.

 {
   if (engine_ &&
       consistentRequest_(
         ServiceHandle<RandomNumberGenerator const>()->defaultEngineKind(),
         ""s)) {
     return *engine_;
   }
   return detail::EngineCreator::createEngine(seed);
 }

art::MixHelper::base_engine_t & art::MixHelper::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make
	)

Definition at line 160 of file MixHelper.cc.

 {
   if (engine_ && consistentRequest_(kind_of_engine_to_make, ""s)) {
     return *engine_;
   }
   return detail::EngineCreator::createEngine(seed, kind_of_engine_to_make);
 }

art::MixHelper::base_engine_t & art::MixHelper::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)

Definition at line 170 of file MixHelper.cc.

 {
   if (engine_ && consistentRequest_(kind_of_engine_to_make, engine_label)) {
     return *engine_;
   }
   return detail::EngineCreator::createEngine(
     seed, kind_of_engine_to_make, engine_label);
 }

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 448 of file MixHelper.h.

 {
   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 458 of file MixHelper.h.

 {
   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>(moduleLabel_,
                                               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 483 of file MixHelper.h.

 {
   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 500 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 521 of file MixHelper.h.

 {
   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 538 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.
 }

art::EventAuxiliarySequence art::MixHelper::generateEventAuxiliarySequence ( EntryNumberSequence const & enSeq )

Definition at line 268 of file MixHelper.cc.

 {
   return ioHandle_->generateEventAuxiliarySequence(enSeq);
 }

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

Definition at line 182 of file MixHelper.cc.

 {
   assert(enSeq.empty());
   assert(eIDseq.empty());
   if (not ioHandle_->fileOpen() and not openNextFile_()) {
     return false;
   }
 
   auto const nEventsInFile = ioHandle_->nEventsInFile();
   bool const over_threshold =
     (readMode_ == Mode::SEQUENTIAL || readMode_ == Mode::RANDOM_NO_REPLACE) ?
       ((nEventsReadThisFile_ + nSecondaries) > nEventsInFile) :
       ((nEventsReadThisFile_ + nSecondaries) >
        (nEventsInFile * coverageFraction_));
   if (over_threshold) {
     if (!providerFunc_) {
       ++nOpensOverThreshold_;
       if (nOpensOverThreshold_ > filenames_.size()) {
         throw Exception{errors::UnimplementedFeature,
                         "An error occurred while preparing product-mixing for "
                         "the current event.\n"}
           << "The number of requested secondaries (" << nSecondaries
           << ") exceeds the number of events in any\n"
           << "of the files specified for product mixing.  For a read mode of '"
           << readMode_ << "',\n"
           << "the framework does not currently allow product-mixing to span "
              "multiple secondary\n"
           << "input files for a given event.  Please contact artists@fnal.gov "
              "for more information.\n";
       }
     }
     if (openNextFile_()) {
       return generateEventSequence(nSecondaries, enSeq, eIDseq);
     } else {
       return false;
     }
   }
 
   nOpensOverThreshold_ = {};
   switch (readMode_) {
   case Mode::SEQUENTIAL:
     enSeq.resize(nSecondaries);
     std::iota(begin(enSeq), end(enSeq), nEventsReadThisFile_);
     break;
   case Mode::RANDOM_REPLACE:
     std::generate_n(
       std::back_inserter(enSeq), nSecondaries, [this, nEventsInFile] {
         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, nEventsInFile] { 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 = shuffledSequence_.cbegin() + 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, back_inserter(eIDseq), EventIDLookup{eventIDIndex_});
   return true;
 }

std::unique_ptr< CLHEP::RandFlat > art::MixHelper::initDist_ ( cet::exempt_ptr< base_engine_t > engine ) const

private

Definition at line 472 of file MixHelper.cc.

 {
   std::unique_ptr<CLHEP::RandFlat> result{nullptr};
   if (engine) {
     result = std::make_unique<CLHEP::RandFlat>(*engine);
   }
   return result;
 }

cet::exempt_ptr< art::MixHelper::base_engine_t > art::MixHelper::initEngine_	(	seed_t	seed,
		Mode	readMode
	)

private

Definition at line 454 of file MixHelper.cc.

 {
   using namespace art;
   if (readMode > MixHelper::Mode::SEQUENTIAL) {
     if (ServiceRegistry::isAvailable<RandomNumberGenerator>()) {
       return cet::make_exempt_ptr(&detail::EngineCreator::createEngine(seed));
     } else {
       throw Exception{errors::Configuration, "MixHelper"}
         << "Random event mixing selected but RandomNumberGenerator service "
            "not loaded.\n"
         << "Ensure service is loaded with: \n"
         << "services.RandomNumberGenerator: {}\n";
     }
   }
   return nullptr;
 }

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

private

Definition at line 357 of file MixHelper.cc.

 {
   // 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 278 of file MixHelper.cc.

 {
   // Create required info only if we're likely to need it.
   EntryNumberSequence subRunEntries;
   EntryNumberSequence runEntries;
   auto const& fileIndex = ioHandle_->fileIndex();
   if (haveSubRunMixOps_) {
     subRunEntries.reserve(eIDseq.size());
     for (auto const& eID : eIDseq) {
       auto const it = fileIndex.findPosition(eID.subRunID(), true);
       if (it != std::cend(fileIndex)) {
         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 " << *fileIter_ << ".\n";
       }
     }
   }
   if (haveRunMixOps_) {
     runEntries.reserve(eIDseq.size());
     for (auto const& eID : eIDseq) {
       auto const it = fileIndex.findPosition(eID.runID(), true);
       if (it != std::cend(fileIndex)) {
         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 " << *fileIter_ << ".\n";
       }
     }
   }
 
   // Populate the remapper in case we need to remap any Ptrs.
   ptrRemapper_ = ptpBuilder_.getRemapper(e);
 
   // Do the branch-wise read, mix and put.
   for (auto const& op : mixOps_) {
     switch (op->branchType()) {
     case InEvent: {
       auto const inProducts = ioHandle_->readFromFile(*op, eventEntries);
       op->mixAndPut(e, inProducts, ptrRemapper_);
       break;
     }
     case InSubRun: {
       auto const inProducts = ioHandle_->readFromFile(*op, subRunEntries);
       // Ptrs not supported for subrun product mixing.
       op->mixAndPut(e, inProducts, nopRemapper);
       break;
     }
     case InRun: {
       auto const inProducts = ioHandle_->readFromFile(*op, runEntries);
       // Ptrs not support for run product mixing.
       op->mixAndPut(e, inProducts, 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();
 }

bool art::MixHelper::openNextFile_ ( )

private

Definition at line 384 of file MixHelper.cc.

 {
   std::string filename;
   if (providerFunc_) {
     filename = providerFunc_();
     if (filename.empty()) {
       return false;
     }
   } else if (filenames_.empty()) {
     return false;
   } else {
     if (ioHandle_->fileOpen()) { // 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.
   ioHandle_->openAndReadMetaData(filename, mixOps_);
 
   eventIDIndex_ = buildEventIDIndex(ioHandle_->fileIndex());
   auto transMap = buildProductIDTransMap(mixOps_);
   ptpBuilder_.prepareTranslationTables(transMap);
 
   if (readMode_ == Mode::RANDOM_NO_REPLACE) {
     // Prepare shuffled event sequence.
     shuffledSequence_.resize(ioHandle_->nEventsInFile());
     std::iota(shuffledSequence_.begin(), shuffledSequence_.end(), 0);
     std::random_device rd;
     std::mt19937 g{rd()};
     std::shuffle(shuffledSequence_.begin(), shuffledSequence_.end(), g);
   }
 
   return true;
 }

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

privatedelete

template<class P >

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

inline

Definition at line 432 of file MixHelper.h.

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

template<class P , art::BranchType B>

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

inline

Definition at line 440 of file MixHelper.h.

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

auto art::MixHelper::readMode ( ) const

inline

Definition at line 424 of file MixHelper.h.

 {
   return readMode_;
 }

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

Definition at line 137 of file MixHelper.cc.

 {
   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 351 of file MixHelper.cc.

 {
   eventsToSkip_ = eventsToSkip;
 }

Member Data Documentation

bool const art::MixHelper::canWrapFiles_

private

Definition at line 406 of file MixHelper.h.

ProducesCollector& art::MixHelper::collector_

private

Definition at line 394 of file MixHelper.h.

bool art::MixHelper::compactMissingProducts_

private

Definition at line 397 of file MixHelper.h.

double const art::MixHelper::coverageFraction_

private

Definition at line 403 of file MixHelper.h.

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

private

Definition at line 410 of file MixHelper.h.

cet::exempt_ptr<base_engine_t> art::MixHelper::engine_

private

Definition at line 409 of file MixHelper.h.

EventIDIndex art::MixHelper::eventIDIndex_ {}

private

Definition at line 415 of file MixHelper.h.

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

private

Definition at line 411 of file MixHelper.h.

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

private

Definition at line 401 of file MixHelper.h.

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

private

Definition at line 396 of file MixHelper.h.

bool art::MixHelper::haveRunMixOps_ {false}

private

Definition at line 414 of file MixHelper.h.

bool art::MixHelper::haveSubRunMixOps_ {false}

private

Definition at line 413 of file MixHelper.h.

std::unique_ptr<MixIOPolicy> art::MixHelper::ioHandle_ {nullptr}

private

Definition at line 417 of file MixHelper.h.

MixOpList art::MixHelper::mixOps_ {}

private

Definition at line 399 of file MixHelper.h.

std::string const art::MixHelper::moduleLabel_

private

Definition at line 395 of file MixHelper.h.

std::size_t art::MixHelper::nEventsReadThisFile_ {}

private

Definition at line 404 of file MixHelper.h.

unsigned art::MixHelper::nOpensOverThreshold_ {}

private

Definition at line 407 of file MixHelper.h.

ProviderFunc_ art::MixHelper::providerFunc_ {}

private

Definition at line 398 of file MixHelper.h.

ProdToProdMapBuilder art::MixHelper::ptpBuilder_ {}

private

Definition at line 408 of file MixHelper.h.

PtrRemapper art::MixHelper::ptrRemapper_ {}

private

Definition at line 400 of file MixHelper.h.

Mode const art::MixHelper::readMode_

private

Definition at line 402 of file MixHelper.h.

EntryNumberSequence art::MixHelper::shuffledSequence_ {}

private

Definition at line 412 of file MixHelper.h.

std::size_t art::MixHelper::totalEventsRead_ {}

private

Definition at line 405 of file MixHelper.h.

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

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

Classes

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