Inheritance diagram for arttest::SimpleDerivedAnalyzer:

Classes
struct	Config

Public Types
using	SimpleDerivedProduct = std::vector< SimpleDerived >

using	Parameters = Table< Config >

Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Public Member Functions
	SimpleDerivedAnalyzer (Parameters const &p)

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

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

std::string	workerType () const

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

	Analyzer (fhicl::ParameterSet const &pset)

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

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::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

std::string const &	processName () const

bool	wantAllEvents () const

bool	wantEvent (Event const &e)

fhicl::ParameterSetID	selectorConfig () const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

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)

Private Member Functions
void	analyze (art::Event const &e) override

void	test_getView (art::Event const &e) const

void	test_getViewReturnFalse (art::Event const &e) const

void	test_getViewThrowing (art::Event const &e) const

void	test_PtrVector (art::Event const &e) const

template<typename DATA_TYPE >
void	test_PtrVector (art::PtrVector< DATA_TYPE > const &v, art::EventNumber_t event_num, std::size_t nElements=expectedSize()) const

Static Private Member Functions
static constexpr std::size_t	expectedSize ()

Private Attributes
art::InputTag const	tagWithInstance_

art::InputTag const	tagForCurrentProcess_

std::size_t const	nvalues_

art::ProductToken< art::PtrVector< SimpleDerived > > const	ptrVectorToken_

art::ViewToken< dummy > const	dummyToken_

art::ViewToken< Simple > const	simpleToken_

art::ViewToken< Simple > const	simpleCurrentToken_

art::ViewToken< SimpleDerived > const	simpleDerivedToken_

art::ViewToken< SimpleDerived > const	simpleDerivedCurrentToken_

Additional Inherited Members
Protected Member Functions inherited from art::Observer
	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &paths, fhicl::ParameterSet const &config)

detail::ProcessAndEventSelectors &	processAndEventSelectors ()

Detailed Description

Definition at line 44 of file SimpleDerivedAnalyzer_module.cc.

Member Typedef Documentation

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

Definition at line 53 of file SimpleDerivedAnalyzer_module.cc.

using arttest::SimpleDerivedAnalyzer::SimpleDerivedProduct = std::vector<SimpleDerived>

Definition at line 46 of file SimpleDerivedAnalyzer_module.cc.

Constructor & Destructor Documentation

SimpleDerivedAnalyzer::SimpleDerivedAnalyzer ( Parameters const & p )

explicit

Definition at line 92 of file SimpleDerivedAnalyzer_module.cc.

   : art::EDAnalyzer{p}
   , tagWithInstance_{p().input_label(), "derived"}
   , tagForCurrentProcess_{p().input_label(), "derived", "DEVEL"}
   , nvalues_{p().nvalues()}
   , ptrVectorToken_{consumes<art::PtrVector<SimpleDerived>>(
       art::InputTag{p().input_label2()})}
   , dummyToken_{consumesView<dummy>(art::InputTag{p().input_label()})}
 {}

Member Function Documentation

void SimpleDerivedAnalyzer::analyze ( art::Event const & e )

overrideprivatevirtual

Implements art::EDAnalyzer.

Definition at line 103 of file SimpleDerivedAnalyzer_module.cc.

 {
   test_getView(e);
   // TODO: uncomment this when getView is modified to return false
   // upon not finding the right label.
   //  test_getViewReturnFalse(e);
   test_getViewThrowing(e);
   test_PtrVector(e);
   art::View<arttest::SimpleDerived> v;
   e.getView(simpleDerivedCurrentToken_, v);
   assert(v.isValid());
   check_for_conversion(v);
 
   art::View<arttest::Simple> vB;
   e.getView(simpleCurrentToken_, vB);
   assert(vB.isValid());
   check_for_conversion(vB);
 }

static constexpr std::size_t arttest::SimpleDerivedAnalyzer::expectedSize ( )

inlinestaticprivate

Definition at line 66 of file SimpleDerivedAnalyzer_module.cc.

   {
     return 16;
   }

void SimpleDerivedAnalyzer::test_getView ( art::Event const & e ) const

private

Definition at line 172 of file SimpleDerivedAnalyzer_module.cc.

 {
   // Make sure we can get views into products that are present.
   test_view(e, simpleToken_, simpleCurrentToken_, nvalues_);
   test_view(e, simpleDerivedToken_, simpleDerivedCurrentToken_, nvalues_);
 } // test_getView()

void SimpleDerivedAnalyzer::test_getViewReturnFalse ( art::Event const & e ) const

private

Definition at line 180 of file SimpleDerivedAnalyzer_module.cc.

 {
   std::vector<int const*> ints;
   try {
     assert(e.getView("nothing with this illegal label", ints) == false);
   }
   catch (std::exception& e) {
     std::cerr << e.what() << '\n';
     assert("Unexpected exception thrown" == 0);
   }
   catch (...) {
     assert("Unexpected exception thrown" == 0);
   }
 }

void SimpleDerivedAnalyzer::test_getViewThrowing ( art::Event const & e ) const

private

Definition at line 196 of file SimpleDerivedAnalyzer_module.cc.

 {
   //  Make sure attempts to get views into products that are not there
   //  fail correctly.
   std::vector<dummy const*> dummies;
   try {
     e.getView(dummyToken_, dummies);
     assert("Failed to throw required exception" == 0);
   }
   catch (art::Exception& e) {
     assert(e.categoryCode() == art::errors::ProductNotFound);
   }
   catch (...) {
     assert("Wrong exception thrown" == 0);
   }
 }

void SimpleDerivedAnalyzer::test_PtrVector ( art::Event const & e ) const

private

Definition at line 214 of file SimpleDerivedAnalyzer_module.cc.

 {
   auto const event_num = e.id().event();
   using product_t = art::PtrVector<arttest::SimpleDerived>;
   using base_product_t = art::PtrVector<arttest::Simple>;
 
   // Read the data.
   auto const& d = *e.getValidHandle(ptrVectorToken_);
   auto const sz = d.size();
   if (sz != expectedSize()) {
     throw cet::exception("SizeMismatch")
       << "Expected a PtrVector of size " << expectedSize()
       << " but the obtained size is " << sz << '\n';
   }
   // Test the data
   test_PtrVector(d, event_num);
   // Construct from PtrVector<U>
   {
     base_product_t s{d};
     test_PtrVector(s, event_num);
     product_t p{s};
     test_PtrVector(p, event_num);
   }
   // Construct from initializer list.
   {
     auto i(d.cbegin());
     auto il = {*(i++), *i};
     base_product_t s{il};
     test_PtrVector(s, event_num, 2);
     product_t p({s.front(), s.back()});
     test_PtrVector(p, event_num, 2);
   }
   // Operator= from PtrVector<U>.
   {
     base_product_t s;
     s = d;
     test_PtrVector(s, event_num);
     product_t p;
     p = s;
     test_PtrVector(p, event_num);
   }
   // Operator= from initializer list.
   {
     auto i(d.cbegin());
     base_product_t s;
     s = {*(i++), *i};
     test_PtrVector(s, event_num, 2);
     product_t p;
     p = {s.front(), s.back()};
     test_PtrVector(p, event_num, 2);
   }
   // Assign from Ptr<U>.
   {
     base_product_t s{d};
     s.assign(1, d.front());
     test_PtrVector(s, event_num, 1);
     product_t p{s};
     p.assign(1, s.front());
     test_PtrVector(p, event_num, 1);
   }
   // Assign from iterators.
   {
     base_product_t s{d};
     s.assign(d.cbegin(), d.cend());
     test_PtrVector(s, event_num);
     product_t p{s};
     p.assign(s.cbegin(), s.cend());
     test_PtrVector(p, event_num);
   }
   // Assign from initializer list.
   {
     auto i(d.cbegin());
     base_product_t s{d};
     s.assign({*(i++), *i});
     test_PtrVector(s, event_num, 2);
     product_t p{s};
     p.assign({s.front(), s.back()});
     test_PtrVector(p, event_num, 2);
   }
   // Push back.
   {
     base_product_t s;
     s.push_back(d.front());
     test_PtrVector(s, event_num, 1);
     product_t p;
     p.push_back(s.front());
     test_PtrVector(p, event_num, 1);
   }
   // Insert from Ptr<U>.
   {
     base_product_t s({d[1]});
     s.insert(s.begin(), d.front());
     test_PtrVector(s, event_num, 2);
     base_product_t p({s.back()});
     p.insert(p.begin(), s.front());
     test_PtrVector(p, event_num, 2);
   }
   // Insert from iterators.
   {
     base_product_t s;
     s.insert(s.begin(), d.cbegin(), d.cend());
     test_PtrVector(s, event_num);
     product_t p;
     p.insert(p.begin(), s.cbegin(), s.cend());
     test_PtrVector(p, event_num);
   }
   // Erase.
   {
     base_product_t s{d};
     s.erase(s.end() - 1);
     test_PtrVector(s, event_num, expectedSize() - 1);
     s.erase(s.begin() + 1, s.end());
     test_PtrVector(s, event_num, 1);
   }
 }

template<typename DATA_TYPE >

void SimpleDerivedAnalyzer::test_PtrVector	(	art::PtrVector< DATA_TYPE > const &	v,
		art::EventNumber_t	event_num,
		std::size_t	nElements = `expectedSize()`
	)		const

private

Definition at line 332 of file SimpleDerivedAnalyzer_module.cc.

 {
   auto const sz(v.size());
   if (sz != nElements) {
     throw cet::exception("SizeMismatch")
       << "Expected size " << nElements << " but got " << sz << ".\n";
   }
   auto const b = v.cbegin();
   auto const e = v.cbegin() + nElements;
   for (auto i = b; i != e; ++i) {
     std::size_t const k = i - b;
     if (static_cast<std::size_t>((*i)->key) != expectedSize() - k + event_num) {
       throw cet::exception("KeyMismatch")
         << "At position " << k << " expected key "
         << expectedSize() - k + event_num << " but obtained " << (*i)->key
         << ".\n";
     }
     assert(*i == *i); // Check operator ==.
     if (k == 0 && sz > 1) {
       assert(*i != *(i + 1));  // Check operator !=.
       assert(*(i) < *(i + 1)); // Check operator <.
     }
 
     double const expect{1.5 * k + 100.0};
     if ((*i)->value != expect) {
       throw cet::exception("ValueMismatch")
         << "At position " << k << " expected value " << expect
         << " but obtained " << (*i)->value << ".\n";
     }
     if ((*i)->dummy() != 16.25) {
       throw cet::exception("ValueMismatch")
         << "At position " << k << " expected dummy value " << 16.25
         << " but obtained " << (*i)->dummy() << ".\n";
     }
   }
 } // test_PtrVector()