TrackProxyTest Class Reference

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

Inheritance diagram for TrackProxyTest:

Classes
struct	Config

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

Public Member Functions
	TrackProxyTest (Parameters const &config)
	TrackProxyTest (TrackProxyTest const &)=delete
	TrackProxyTest (TrackProxyTest &&)=delete
TrackProxyTest &	operator= (TrackProxyTest const &)=delete
TrackProxyTest &	operator= (TrackProxyTest &&)=delete
virtual void	analyze (art::Event const &event) override

Private Member Functions
void	proxyUsageExample (art::Event const &event) const
	An example of how to access the information via track proxy. More...
auto	getLongTracks (art::Event const &event, double minLength) const
	Returns proxies to tracks longer than a certain length. More...
void	testTracks (art::Event const &event)
	Performs the actual test. More...
template<typename Track >
void	processTrack (Track const &track) const
	Single-track processing function example. More...
template<typename TrackPoint >
void	processPoint (TrackPoint const &point) const
	Single-track-point processing function example. More...

Private Attributes
art::InputTag	tracksTag
	Tag for the input tracks. More...

Detailed Description

Runs a test of proxy::Tracks 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 50 of file TrackProxyTest_module.cc.

Member Typedef Documentation

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

Definition at line 64 of file TrackProxyTest_module.cc.

Constructor & Destructor Documentation

TrackProxyTest::TrackProxyTest ( Parameters const &  config )

inlineexplicit

Definition at line 66 of file TrackProxyTest_module.cc.

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

TrackProxyTest::TrackProxyTest ( TrackProxyTest const &  )

delete

TrackProxyTest::TrackProxyTest ( TrackProxyTest &&  )

delete

Member Function Documentation

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

overridevirtual

Definition at line 374 of file TrackProxyTest_module.cc.

                                                  {

  // "test" that track proxies survive their collection (part I)
  const double minLength = 30.0;
  auto const longTracks = getLongTracks(event, minLength);

  // usage example (supposed to be educational)
  proxyUsageExample(event);

  // actual test
  testTracks(event);

  // "test" that track proxies survive their collection (part II)
  mf::LogVerbatim("TrackProxyTest")
    << longTracks.size() << " tracks are longer than " << minLength << " cm:";
  std::for_each(longTracks.begin(), longTracks.end(),
    [this](auto const& track){ this->processTrack(track); });

} // TrackProxyTest::analyze()

auto TrackProxyTest::getLongTracks ( art::Event const &  event, double  minLength  ) const

private

Returns proxies to tracks longer than a certain length.

Definition at line 163 of file TrackProxyTest_module.cc.

{
  //
  // this code is not a particularly good practice, but it is aimed to check
  // that after the proxy collection is out of scope, elements copied from it
  // are still valid
  //
  auto tracks = proxy::getCollection<proxy::Tracks>
    (event, tracksTag, proxy::withFitHitInfo());

  std::vector<decltype(tracks)::element_proxy_t> longTracks;
  for (auto track: tracks) {
    if (track->Length() >= minLength) longTracks.push_back(track);
  } // for track
  return longTracks;

} // TrackProxyTest::proxyUsageExample()

TrackProxyTest& TrackProxyTest::operator= ( TrackProxyTest const &  )

delete

TrackProxyTest& TrackProxyTest::operator= ( TrackProxyTest &&  )

delete

template<typename TrackPoint >

void TrackProxyTest::processPoint ( TrackPoint const &  point ) const

private

Single-track-point processing function example.

Definition at line 104 of file TrackProxyTest_module.cc.

                                                               {

  mf::LogVerbatim log("TrackProxyTest");
  log <<
    "  [#" << point.index() << "] at " << point.position()
      << " (momentum: " << point.momentum() << "), flags: "
      << point.flags();

  recob::Hit const* hit = point.hit();
  if (hit) {
    log << " with a Q=" << hit->Integral() << " hit on channel "
      << hit->Channel() << " at tick " << hit->PeakTime()
      << ", measured: " << point.fitInfoPtr()->hitMeas();
  }
  else
    log << " (no associated hit)";

} // TrackProxyTest::processPoint()

template<typename Track >

void TrackProxyTest::processTrack ( Track const &  track ) const

private

Single-track processing function example.

Definition at line 126 of file TrackProxyTest_module.cc.

                                                          {

  recob::Track const& trackRef = track.track();

  mf::LogVerbatim("TrackProxyTest")
    << "[#" << track.index() << "] track " << trackRef
    << "  " << track->Length() << " cm long, with "
    << trackRef.NPoints() << " points and " << track.nHits()
    << " hits:";

  for (auto point: track.points()) {
    processPoint(point);
  } // for points in track

} // TrackProxyTest::processTrack()

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

private

An example of how to access the information via track proxy.

Definition at line 144 of file TrackProxyTest_module.cc.

                                                                  {

  auto tracks = proxy::getCollection<proxy::Tracks>
    (event, tracksTag, proxy::withFitHitInfo());

  if (tracks.empty()) {
    mf::LogVerbatim("TrackProxyTest") << "No tracks in '" << tracksTag.encode()
      << "'";
    return;
  }

  mf::LogVerbatim("TrackProxyTest") << "Collection '" << tracksTag.encode()
    << "' contains " << tracks.size() << " tracks.";

} // TrackProxyTest::proxyUsageExample()

void TrackProxyTest::testTracks ( art::Event const &  event )

private

Performs the actual test.

Definition at line 187 of file TrackProxyTest_module.cc.

                                                     {

  auto expectedTracksHandle
    = event.getValidHandle<std::vector<recob::Track>>(tracksTag);
  auto const& expectedTracks = *expectedTracksHandle;

  mf::LogInfo("TrackProxyTest")
    << "Starting test on " << expectedTracks.size() << " tracks from '"
    << tracksTag.encode() << "'";

  art::FindManyP<recob::Hit> hitsPerTrack
    (expectedTracksHandle, event, tracksTag);

  art::FindOneP<recob::TrackTrajectory> trajectoryPerTrack
    (expectedTracksHandle, event, tracksTag);

  auto const& expectedTrackFitHitInfo
    = *(event.getValidHandle<std::vector<std::vector<recob::TrackFitHitInfo>>>
    (tracksTag));

  auto tracks = proxy::getCollection<proxy::Tracks>(event, tracksTag
    , proxy::withAssociatedAs<recob::Hit, tag::SpecialHits>()
    , proxy::withFitHitInfo()
    , proxy::withOriginalTrajectory()
    );

  //
  // we try to access something we did not "register" in the proxy: space points
  //
  static_assert(!tracks.has<recob::SpacePoint>(),
    "Track proxy does NOT have space points available!!!");

  static_assert(
    tracks.has<recob::TrackFitHitInfo>(),
    "recob::TrackFitHitInfo not found!!!"
    );


  BOOST_TEST(tracks.empty() == expectedTracks.empty());
  BOOST_TEST(tracks.size() == expectedTracks.size());

  BOOST_TEST(tracks.size() == expectedTrackFitHitInfo.size());
  decltype(auto) allFitHitInfo = tracks.get<recob::TrackFitHitInfo>();
  static_assert(
    std::is_lvalue_reference<decltype(allFitHitInfo)>(),
    "Copy of parallel data!"
    );
  BOOST_TEST
    (allFitHitInfo.data() == std::addressof(expectedTrackFitHitInfo));

  auto fitHitInfoSize
    = std::distance(allFitHitInfo.begin(), allFitHitInfo.end());
  BOOST_TEST(fitHitInfoSize == expectedTrackFitHitInfo.size());

  std::size_t iExpectedTrack = 0;
  for (auto const& trackProxy: tracks) {
    BOOST_TEST_CHECKPOINT("Track #" << trackProxy.index());

    auto const& expectedTrack = expectedTracks[iExpectedTrack];
    auto const& expectedHits = hitsPerTrack.at(iExpectedTrack);
    auto const& expectedFitHitInfo = expectedTrackFitHitInfo[iExpectedTrack];
    auto const& expectedTrajPtr = trajectoryPerTrack.at(iExpectedTrack);
    recob::TrackTrajectory const* expectedTrajCPtr
      = expectedTrajPtr.isNull()? nullptr: expectedTrajPtr.get();

    recob::Track const& trackRef = *trackProxy;

    BOOST_TEST
      (std::addressof(trackRef) == std::addressof(expectedTrack));
    BOOST_TEST
      (std::addressof(trackProxy.track()) == std::addressof(expectedTrack));
    BOOST_TEST(trackProxy.nHits() == expectedHits.size());
    BOOST_TEST(trackProxy.index() == iExpectedTrack);

    decltype(auto) fitHitInfo = trackProxy.get<recob::TrackFitHitInfo>();
    static_assert(
      std::is_lvalue_reference<decltype(fitHitInfo)>(),
      "Copy of parallel data element!"
      );
    BOOST_TEST
      (std::addressof(fitHitInfo), std::addressof(expectedFitHitInfo));
    BOOST_TEST(fitHitInfo.size() == expectedFitHitInfo.size());

    BOOST_TEST
      (trackProxy.get<tag::SpecialHits>().size(), expectedHits.size());

    // trajectory?
    BOOST_TEST
      (trackProxy.hasOriginalTrajectory() == !expectedTrajPtr.isNull());
    if (expectedTrajCPtr) {
      BOOST_TEST(trackProxy.originalTrajectoryPtr() == expectedTrajPtr);
      BOOST_TEST(&trackProxy.originalTrajectory() == expectedTrajPtr.get());
    }
    else {
      BOOST_TEST(!(trackProxy.originalTrajectoryPtr()));
    }

    BOOST_TEST(
      trackProxy(proxy::Tracks::Fitted) ==
      std::addressof(expectedTrack.Trajectory())
      );
    BOOST_TEST(trackProxy(proxy::Tracks::Unfitted) == expectedTrajCPtr);
    BOOST_TEST(trackProxy(proxy::Tracks::NTypes) == nullptr);

    // direct interface to recob::Track
    BOOST_TEST(trackProxy->NPoints() == expectedTrack.NPoints());


    std::array<unsigned int, recob::TrajectoryPointFlagTraits::maxFlags()>
      flagCounts;
    flagCounts.fill(0U);
    std::size_t iPoint = 0;
    for (auto const& pointInfo: trackProxy.points()) {
      BOOST_TEST_CHECKPOINT("  point #" << pointInfo.index());

      decltype(auto) expectedPointFlags = expectedTrack.FlagsAtPoint(iPoint);

      BOOST_TEST(pointInfo.index() == iPoint);
      BOOST_TEST(
        pointInfo.position() ==
        expectedTrack.Trajectory().LocationAtPoint(iPoint)
        );
      BOOST_TEST
        (pointInfo.momentum() == expectedTrack.MomentumVectorAtPoint(iPoint));
      BOOST_TEST(pointInfo.flags() == expectedPointFlags);
      if (expectedPointFlags.hasOriginalHitIndex()) {
        BOOST_TEST
          (pointInfo.hitPtr().key() == expectedPointFlags.fromHit());
      }
      else {
        BOOST_TEST(!pointInfo.hitPtr());
      }

      // collect the count of each flag type
      for (auto flag: {
        recob::TrajectoryPointFlags::flag::NoPoint,
        recob::TrajectoryPointFlags::flag::HitIgnored,
        recob::TrajectoryPointFlags::flag::Suspicious,
        recob::TrajectoryPointFlags::flag::DetectorIssue
        })
      {
        if (!expectedPointFlags.isDefined(flag)) continue;
        if (expectedPointFlags.isSet(flag)) ++flagCounts[flag.index()];
      }

      BOOST_TEST
        (fitHitInfo[iPoint].WireId() == expectedFitHitInfo[iPoint].WireId());
      BOOST_TEST
        (pointInfo.fitInfoPtr() == std::addressof(expectedFitHitInfo[iPoint]));
      BOOST_TEST(
        std::addressof(fitHitInfo[iPoint]) ==
        std::addressof(expectedFitHitInfo[iPoint])
        );

      ++iPoint;
    } // for
    BOOST_TEST(iPoint == expectedTrack.NPoints());

    // testing pointsWithFlags() with some single flags
    for (auto flag: {
      recob::TrajectoryPointFlags::flag::NoPoint,
      recob::TrajectoryPointFlags::flag::HitIgnored,
      recob::TrajectoryPointFlags::flag::Suspicious,
      recob::TrajectoryPointFlags::flag::DetectorIssue
      })
    {
      BOOST_TEST_CHECKPOINT("  flag: " << flag);
      unsigned int flagCount = 0U;
      for (auto const& pointInfo: trackProxy.pointsWithFlags(flag)) {

        BOOST_TEST_CHECKPOINT("    point #" << pointInfo.index());
        BOOST_TEST(pointInfo.flags().isDefined(flag));
        BOOST_TEST(pointInfo.flags().isSet(flag));

        ++flagCount;
      } // for pointInfo
      BOOST_TEST(flagCount == flagCounts[flag.index()]);
    } // for flag

    ++iExpectedTrack;
  } // for
  BOOST_TEST(iExpectedTrack == expectedTracks.size());

} // TrackProxyTest::testTracks()

Member Data Documentation

art::InputTag TrackProxyTest::tracksTag

private

Tag for the input tracks.

Definition at line 80 of file TrackProxyTest_module.cc.

---

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

• TrackProxyTest_module.cc