Runs a test of proxy::ChargedSpacePoints interface. More...

Inheritance diagram for ChargedSpacePointProxyTest:

Classes
struct	Config

Public Types
using	Parameters = art::EDAnalyzer::Table< Config >

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

using	ModuleType = EDAnalyzer

Public Member Functions
	ChargedSpacePointProxyTest (Parameters const &config)

	ChargedSpacePointProxyTest (ChargedSpacePointProxyTest const &)=delete

	ChargedSpacePointProxyTest (ChargedSpacePointProxyTest &&)=delete

ChargedSpacePointProxyTest &	operator= (ChargedSpacePointProxyTest const &)=delete

ChargedSpacePointProxyTest &	operator= (ChargedSpacePointProxyTest &&)=delete

virtual void	analyze (art::Event const &event) override

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 (SharedResources const &resources)

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 &)

fhicl::ParameterSetID	selectorConfig () const

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

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

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	proxyUsageExample (art::Event const &event) const
	An example of how to access the information via proxy. More...

void	testChargedSpacePoints (art::Event const &event)
	Performs the actual test. More...

Private Attributes
art::InputTag	pointsTag
	Tag for the input. More...

Additional Inherited Members
Protected Member Functions inherited from art::Observer
std::string const &	processName () const

bool	wantAllEvents () const noexcept

bool	wantEvent (ScheduleID id, Event const &e) const

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

	Observer (fhicl::ParameterSet const &config)

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

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

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 ()

Detailed Description

Runs a test of proxy::ChargedSpacePoints interface.

This module is that it uses Boost unit test library, and as such it must be run with lar_ut instead of lar.

Definition at line 45 of file ChargedSpacePointProxyTest_module.cc.

Member Typedef Documentation

using ChargedSpacePointProxyTest::Parameters = art::EDAnalyzer::Table<Config>

Definition at line 60 of file ChargedSpacePointProxyTest_module.cc.

Constructor & Destructor Documentation

ChargedSpacePointProxyTest::ChargedSpacePointProxyTest ( Parameters const & config )

inlineexplicit

Definition at line 62 of file ChargedSpacePointProxyTest_module.cc.

     : art::EDAnalyzer(config)
     , pointsTag(config().pointsTag())
     {}

ChargedSpacePointProxyTest::ChargedSpacePointProxyTest ( ChargedSpacePointProxyTest const & )

delete

ChargedSpacePointProxyTest::ChargedSpacePointProxyTest ( ChargedSpacePointProxyTest && )

delete

Member Function Documentation

void ChargedSpacePointProxyTest::analyze ( art::Event const & event )

overridevirtual

Implements art::EDAnalyzer.

Definition at line 183 of file ChargedSpacePointProxyTest_module.cc.

                                                               {
 
   // usage example (supposed to be educational)
   proxyUsageExample(event);
 
   // actual test
   testChargedSpacePoints(event);
 
 } // ChargedSpacePointProxyTest::analyze()

ChargedSpacePointProxyTest& ChargedSpacePointProxyTest::operator= ( ChargedSpacePointProxyTest const & )

delete

ChargedSpacePointProxyTest& ChargedSpacePointProxyTest::operator= ( ChargedSpacePointProxyTest && )

delete

void ChargedSpacePointProxyTest::proxyUsageExample ( art::Event const & event ) const

private

An example of how to access the information via proxy.

Definition at line 91 of file ChargedSpacePointProxyTest_module.cc.

 {
 
   auto points = proxy::getChargedSpacePoints(event, pointsTag);
 
   if (points.empty()) {
     mf::LogVerbatim("ProxyTest")
       << "No points in '" << pointsTag.encode() << "'";
     return;
   }
 
   mf::LogVerbatim log("ProxyTest");
   for (auto point: points) {
     log << "\nPoint at " << point.position() << " (ID=" << point.ID()
       << ") has ";
     if (point.hasCharge()) log << "charge " << point.charge();
     else                   log << "no charge";
   } // for point
 
   mf::LogVerbatim("ProxyTest") << "Collection '" << pointsTag.encode()
     << "' contains " << points.size() << " points.";
 
 } // ChargedSpacePointProxyTest::proxyUsageExample()

void ChargedSpacePointProxyTest::testChargedSpacePoints ( art::Event const & event )

private

Performs the actual test.

Definition at line 118 of file ChargedSpacePointProxyTest_module.cc.

 {
 
   auto const& expectedSpacePoints
     = *(event.getValidHandle<std::vector<recob::SpacePoint>>(pointsTag));
 
   auto const& expectedCharges
     = *(event.getValidHandle<std::vector<recob::PointCharge>>(pointsTag));
 
   mf::LogInfo("ProxyTest")
     << "Starting test on " << expectedSpacePoints.size() << " points and "
     << expectedCharges.size() << " charges from '"
     << pointsTag.encode() << "'";
 
   // this assertion fails on invalid input (test bug)
   assert(expectedSpacePoints.size() == expectedCharges.size());
 
   auto points = proxy::getChargedSpacePoints(event, pointsTag);
 
   static_assert(points.has<recob::PointCharge>(), "recob::Charge not found!!!");
 
   BOOST_TEST(points.empty() == expectedSpacePoints.empty());
   BOOST_TEST(points.size() == expectedSpacePoints.size());
 
   decltype(auto) spacePoints = points.spacePoints();
   BOOST_TEST
     (std::addressof(spacePoints) == std::addressof(expectedSpacePoints));
   BOOST_TEST(spacePoints.size() == expectedSpacePoints.size());
 
   decltype(auto) charges = points.charges();
   BOOST_TEST(std::addressof(charges) == std::addressof(expectedCharges));
   BOOST_TEST(charges.size() == expectedCharges.size());
 
   std::size_t iExpectedPoint = 0;
   for (auto pointProxy: points) {
     auto const& expectedSpacePoint = expectedSpacePoints[iExpectedPoint];
     auto const& expectedChargeInfo = expectedCharges[iExpectedPoint];
 
     recob::SpacePoint const& spacePointRef = *pointProxy;
 
     BOOST_TEST
       (std::addressof(spacePointRef) == std::addressof(expectedSpacePoint));
     BOOST_TEST
       (std::addressof(pointProxy.point()) == std::addressof(expectedSpacePoint));
     BOOST_TEST(pointProxy.position() == geo::vect::makePointFromCoords(expectedSpacePoint.XYZ()));
     BOOST_TEST(pointProxy.ID() == expectedSpacePoint.ID());
     BOOST_TEST(pointProxy.hasCharge() == expectedChargeInfo.hasCharge());
     BOOST_TEST(pointProxy.charge() == expectedChargeInfo.charge());
 
     decltype(auto) chargeInfo = pointProxy.get<recob::PointCharge>();
     static_assert(
       std::is_lvalue_reference<decltype(chargeInfo)>(),
       "Copy of parallel data element!"
       );
     BOOST_TEST
       (std::addressof(chargeInfo) == std::addressof(expectedChargeInfo));
 
     ++iExpectedPoint;
   } // for
   BOOST_TEST(iExpectedPoint == expectedSpacePoints.size());
 
 } // ChargedSpacePointProxyTest::testChargedSpacePoints()

Member Data Documentation

art::InputTag ChargedSpacePointProxyTest::pointsTag

private

Tag for the input.

Definition at line 77 of file ChargedSpacePointProxyTest_module.cc.

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

lardata/test/RecoBaseProxy/ChargedSpacePointProxyTest_module.cc

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation