Inheritance diagram for arttest::MixProducer:

Classes
struct	Config

Public Types
using	Parameters = Table< Config >

Public Types inherited from art::SharedProducer
using	ModuleType = SharedProducer

using	WorkerType = WorkerT< SharedProducer >

Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Public Member Functions
	MixProducer (Parameters const &p, art::ProcessingFrame const &)

Public Member Functions inherited from art::SharedProducer
	SharedProducer (fhicl::ParameterSet const &pset)

template<typename Config >
	SharedProducer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept

	Producer ()

	Producer (fhicl::ParameterSet const &)

	Producer (Producer const &)=delete

	Producer (Producer &&)=delete

Producer &	operator= (Producer const &)=delete

Producer &	operator= (Producer &&)=delete

void	doBeginJob ()

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Modifier
virtual	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Public Member Functions inherited from art::detail::SharedModule
	SharedModule ()

	SharedModule (std::string const &moduleLabel)

	~SharedModule () noexcept

hep::concurrency::SerialTaskQueueChain *	serialTaskQueueChain () const

void	createQueues ()

template<BranchType BT = InEvent, typename... T>
void	serialize (T const &...)

template<BranchType BT = InEvent>
void	async ()

template<BranchType , typename... T>
void	serialize (T const &...resources)

Private Types
using	mv_t = cet::map_vector< unsigned int >

using	mvv_t = mv_t::value_type

using	mvm_t = mv_t::mapped_type

Private Member Functions
void	produce (art::Event &e, art::ProcessingFrame const &) override

void	endSubRun (art::SubRun &sr, art::ProcessingFrame const &) override

void	endRun (art::Run &r, art::ProcessingFrame const &) override

Private Attributes
std::atomic< size_t >	eventCounter_ {}

std::atomic< size_t >	subrunCounter_ {}

std::atomic< size_t >	runCounter_ {}

Detailed Description

Definition at line 29 of file MixProducer_module.cc.

Member Typedef Documentation

using arttest::MixProducer::mv_t = cet::map_vector<unsigned int>

private

Definition at line 41 of file MixProducer_module.cc.

using arttest::MixProducer::mvm_t = mv_t::mapped_type

private

Definition at line 43 of file MixProducer_module.cc.

using arttest::MixProducer::mvv_t = mv_t::value_type

private

Definition at line 42 of file MixProducer_module.cc.

using arttest::MixProducer::Parameters = Table<Config>

Definition at line 33 of file MixProducer_module.cc.

Constructor & Destructor Documentation

arttest::MixProducer::MixProducer	(	Parameters const &	p,
		art::ProcessingFrame const &
	)

explicit

Definition at line 51 of file MixProducer_module.cc.

   : art::SharedProducer{p}
 {
   async<art::InEvent>();
 
   produces<double>("doubleLabel");
   produces<IntProduct>("IntProductLabel");
   produces<IntProduct>("SpottyProductLabel");
   produces<std::string>("stringLabel");
   produces<std::vector<double>>("doubleCollectionLabel");
   produces<std::vector<art::Ptr<double>>>("doubleVectorPtrLabel");
   produces<art::PtrVector<double>>("doublePtrVectorLabel");
   produces<ProductWithPtrs>("ProductWithPtrsLabel");
   produces<mv_t>("mapVectorLabel");
   produces<std::vector<art::Ptr<mvv_t>>>("intVectorPtrLabel");
   produces<double, art::InSubRun>("DoubleSRLabel");
   produces<double, art::InRun>("DoubleRLabel");
 }

Member Function Documentation

void arttest::MixProducer::endRun	(	art::Run &	r,
		art::ProcessingFrame const &
	)

overrideprivatevirtual

Reimplemented from art::SharedProducer.

Definition at line 161 of file MixProducer_module.cc.

 {
   ++runCounter_;
   r.put(std::make_unique<double>(runCounter_), "DoubleRLabel");
 }

void arttest::MixProducer::endSubRun	(	art::SubRun &	sr,
		art::ProcessingFrame const &
	)

overrideprivatevirtual

Reimplemented from art::SharedProducer.

Definition at line 154 of file MixProducer_module.cc.

 {
   ++subrunCounter_;
   sr.put(std::make_unique<double>(subrunCounter_), "DoubleSRLabel");
 }

void arttest::MixProducer::produce	(	art::Event &	e,
		art::ProcessingFrame const &
	)

overrideprivatevirtual

Implements art::SharedProducer.

Definition at line 72 of file MixProducer_module.cc.

 {
   ++eventCounter_;
 
   // double
   e.put(std::make_unique<double>(eventCounter_), "doubleLabel");
 
   // IntProduct
   e.put(std::make_unique<IntProduct>(eventCounter_ + 1000000),
         "IntProductLabel");
 
   // SpottyProduct
   if (e.event() % 100) {
     e.put(std::make_unique<IntProduct>(eventCounter_), "SpottyProductLabel");
   }
 
   // std::string
   std::ostringstream s;
   s << "string value: " << std::setfill('0') << std::setw(7) << eventCounter_
     << "\n";
   e.put(std::make_unique<std::string>(s.str()), "stringLabel");
 
   // 1. std::vector<double>
   //
   // 2. std::vector<art::Ptr<double>>
   //
   // 3. art::PtrVector<double>
   //
   // 4. ProductWithPtrs
   auto coll = std::make_unique<std::vector<double>>();
   coll->reserve(10);
   for (size_t i = 1; i < 11; ++i) {
     coll->push_back(i + 10 * (eventCounter_ - 1));
   }
   e.put(move(coll), "doubleCollectionLabel"); // 1.
   auto vpd = std::make_unique<std::vector<art::Ptr<double>>>();
   vpd->reserve(3);
   auto pvd = std::make_unique<art::PtrVector<double>>();
   pvd->reserve(3);
   art::ProductID const collID{
     e.getProductID<std::vector<double>>("doubleCollectionLabel")};
   vpd->emplace_back(collID, 0, e.productGetter(collID));
   vpd->emplace_back(collID, 4, e.productGetter(collID));
   vpd->emplace_back(collID, 8, e.productGetter(collID));
   pvd->push_back(art::Ptr<double>(collID, 1, e.productGetter(collID)));
   pvd->push_back(art::Ptr<double>(collID, 5, e.productGetter(collID)));
   pvd->push_back(art::Ptr<double>(collID, 9, e.productGetter(collID)));
   auto pwp = std::make_unique<ProductWithPtrs>(
 #ifndef ART_NO_MIX_PTRVECTOR
     *pvd.get(),
 #endif
     *vpd.get());
   e.put(move(vpd), "doubleVectorPtrLabel");      // 2.
   e.put(std::move(pvd), "doublePtrVectorLabel"); // 3.
   e.put(move(pwp), "ProductWithPtrsLabel");      // 4.
 
   // map_vector, .
   auto mv = std::make_unique<mv_t>();
   static size_t constexpr mv_size{5};
   mv->reserve(mv_size);
   for (size_t i = 0; i < mv_size; ++i) {
     (*mv)[cet::map_vector_key(
       static_cast<mvm_t>(1 + i * 2 + 10 * (eventCounter_ - 1)))] =
       (eventCounter_ - 1) * mv_size + i + 1;
   }
 
   // Ptr into map_vector.
   auto mvvp = std::make_unique<std::vector<art::Ptr<mvv_t>>>();
   mvvp->reserve(mv_size);
   art::ProductID const mvID{e.getProductID<mv_t>("mapVectorLabel")};
   mvvp->emplace_back(mvID, 10 * (eventCounter_ - 1) + 7, e.productGetter(mvID));
   mvvp->emplace_back(mvID, 10 * (eventCounter_ - 1) + 1, e.productGetter(mvID));
   mvvp->emplace_back(mvID, 10 * (eventCounter_ - 1) + 3, e.productGetter(mvID));
   mvvp->emplace_back(mvID, 10 * (eventCounter_ - 1) + 9, e.productGetter(mvID));
   mvvp->emplace_back(mvID, 10 * (eventCounter_ - 1) + 5, e.productGetter(mvID));
 
   e.put(move(mvvp), "intVectorPtrLabel");
   e.put(move(mv), "mapVectorLabel"); // Note we're putting these into the event
                                      // in the "wrong" order.
 }

Member Data Documentation

std::atomic<size_t> arttest::MixProducer::eventCounter_ {}

private

Definition at line 46 of file MixProducer_module.cc.

std::atomic<size_t> arttest::MixProducer::runCounter_ {}

private

Definition at line 48 of file MixProducer_module.cc.

std::atomic<size_t> arttest::MixProducer::subrunCounter_ {}

private

Definition at line 47 of file MixProducer_module.cc.

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

art/art/test/Integration/MixProducer_module.cc

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation