Track.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_TRACK_H
#define LARDATA_RECOBASEPROXY_TRACK_H

// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase.h" // proxy namespace
#include "lardata/Utilities/filterRangeFor.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/Track.h"
#include "lardataobj/RecoBase/TrackFitHitInfo.h"
#include "lardataobj/RecoBase/TrackTrajectory.h"

// framework libraries
#include "canvas/Persistency/Common/Ptr.h"

#include <limits>
#include <tuple>
#include <vector>

namespace proxy {

  //----------------------------------------------------------------------------
  // forward declarations
  template <typename TrackProxy>
  class TrackPointIterator;

  template <typename Data>
  class TrackPointWrapper;

  //----------------------------------------------------------------------------
  namespace details {

    template <typename CollProxy>
    struct TrackPointIteratorBox;

    template <typename T>
    struct isTrackProxy;

    template <typename Obj>
    struct StaticAsserts;

    template <typename Data>
    struct StaticAsserts<TrackPointWrapper<Data>> : public std::true_type {
      using Wrapper_t = TrackPointWrapper<Data>;

      static_assert(sizeof(Wrapper_t) == 1U, "Wrapper carries data!");

      static_assert(std::is_same<std::decay_t<decltype(std::declval<Wrapper_t>().position())>,
                                 recob::Track::Point_t>(),
                    "position() is not a recob::Track::Point_t");
      static_assert(std::is_same<std::decay_t<decltype(std::declval<Wrapper_t>().momentum())>,
                                 recob::Track::Vector_t>(),
                    "momentum() is not a recob::Track::Vector_t");
      static_assert(std::is_same<std::decay_t<decltype(std::declval<Wrapper_t>().flags())>,
                                 recob::Track::PointFlags_t>(),
                    "flags() is not a recob::Track::PointFlags_t");
      static_assert(std::is_same<std::decay_t<decltype(std::declval<Wrapper_t>().hitPtr())>,
                                 art::Ptr<recob::Hit>>(),
                    "hit() is not a art::Ptr<recob::Hit>");
      static_assert(
        std::is_same<std::decay_t<decltype(std::declval<Wrapper_t>().index())>, std::size_t>(),
        "index() is not a std::size_t");

    }; // StaticAsserts<TrackPointWrapper<Data>>

  } // namespace details

  //----------------------------------------------------------------------------

  struct Tracks {

    using TrackDataProduct_t = std::vector<recob::Track>;

    using TrackTrajectoryTag = recob::TrackTrajectory;

    using TrackFitHitInfoTag = recob::TrackFitHitInfo;

    using HitTag = recob::Hit;

    typedef enum {
      Unfitted, 
      Fitted,   
      NTypes    
    } TrackType_t;

  }; // struct Tracks

  //----------------------------------------------------------------------------
  //---  track point information
  //---
  using TrackPointData = std::
    tuple<recob::Track const*, art::Ptr<recob::Hit>, recob::TrackFitHitInfo const*, std::size_t>;

  template <typename Data>
  class TrackPointWrapper {
    using This_t = TrackPointWrapper<Data>;
    using Wrapped_t = std::add_const_t<Data>;

    static constexpr std::size_t TrackIndex = 0;
    static constexpr std::size_t HitIndex = 1;
    static constexpr std::size_t FitHitInfoIndex = 2;
    static constexpr std::size_t IndexIndex = 3;
    static constexpr std::size_t NIndices = 4;

    static_assert(std::tuple_size<Data>::value == NIndices, "Unexpected data size.");

    Wrapped_t const& base() const { return reinterpret_cast<Wrapped_t const&>(*this); }

    template <std::size_t N>
    auto get() const -> decltype(auto)
    {
      return std::get<N>(base());
    }

  protected:
    TrackPointWrapper() = default;
    TrackPointWrapper(TrackPointWrapper const&) = default;
    TrackPointWrapper(TrackPointWrapper&&) = default;
    TrackPointWrapper& operator=(TrackPointWrapper const&) = default;
    TrackPointWrapper& operator=(TrackPointWrapper&&) = default;

  public:
    recob::Track const& track() const { return *get<TrackIndex>(); }

    auto position() const -> decltype(auto)
    {
      return track().Trajectory().LocationAtPoint(index());
    }

    auto momentum() const -> decltype(auto)
    {
      return track().Trajectory().MomentumVectorAtPoint(index());
    }

    auto flags() const -> decltype(auto) { return track().Trajectory().FlagsAtPoint(index()); }

    bool isPointValid() const { return flags().isPointValid(); }


    art::Ptr<recob::Hit> hitPtr() const { return get<HitIndex>(); }

    recob::TrackFitHitInfo const* fitInfoPtr() const { return get<FitHitInfoIndex>(); }

    auto index() const -> decltype(auto) { return get<IndexIndex>(); }

    recob::Hit const* hit() const
    {
      decltype(auto) ptr = hitPtr();
      return ptr ? ptr.get() : nullptr;
    }

  }; // TrackPointWrapper<>

  struct TrackPoint : private TrackPointData, public TrackPointWrapper<TrackPointData> {
    using TrackPointData::TrackPointData;
    TrackPoint(TrackPointData const& data) : TrackPointData(data) {}
    TrackPoint(TrackPointData&& data) : TrackPointData(std::move(data)) {}

  private:
    static constexpr bool asserts =
      details::StaticAsserts<TrackPointWrapper<TrackPointData>>::value;
  }; // class TrackPoint

  template <typename TrackProxy>
  TrackPointData makeTrackPointData(TrackProxy const& track, std::size_t index)
  {
    static_assert(details::isTrackProxy<TrackProxy>(), "Not a proxy::Track!");
    return {&(track.track()), track.hitAtPoint(index), track.fitInfoAtPoint(index), index};
  } // makeTrackPointData()

  //--------------------------------------------------------------------------
  template <typename CollProxy>
  struct TrackCollectionProxyElement : public CollectionProxyElement<CollProxy> {
    using base_t = CollectionProxyElement<CollProxy>; 
    using base_t::base_t;                             // inherit constructors

    using track_proxy_t = TrackCollectionProxyElement<CollProxy>;

  public:
    using point_iterator = TrackPointIterator<track_proxy_t>;

    recob::Track const& track() const { return base_t::operator*(); }

    recob::TrackTrajectory const* operator()(proxy::Tracks::TrackType_t type) const noexcept;

    // --- BEGIN Direct hit interface ------------------------------------------

    auto hits() const -> decltype(auto) { return base_t::template get<Tracks::HitTag>(); }

    auto hitAtPoint(std::size_t index) const -> decltype(auto) { return hits()[index]; }

    std::size_t nHits() const { return hits().size(); }

    // --- END Direct hit interface --------------------------------------------

    recob::TrackFitHitInfo const* fitInfoAtPoint(std::size_t index) const;

    // --- BEGIN Direct track trajectory interface -----------------------------

    bool hasOriginalTrajectory() const { return !originalTrajectoryPtr().isNull(); }

    art::Ptr<recob::TrackTrajectory> const& originalTrajectoryPtr() const
    {
      return base_t::template get<Tracks::TrackTrajectoryTag>();
    }

    recob::TrackTrajectory const& originalTrajectory() const { return *originalTrajectoryPtr(); }

    // --- END Direct track trajectory interface -------------------------------

    // --- BEGIN Point-by-point iteration interface ----------------------------

    auto points() const { return details::TrackPointIteratorBox<CollProxy>(*this); }

    template <typename Pred>
    auto selectPoints(Pred&& pred) const;

    auto pointsWithFlags(recob::TrackTrajectory::PointFlags_t::Mask_t mask) const;

    std::size_t nPoints() const { return track().NPoints(); }

    point_iterator beginPoint() const { return {*this, 0}; }

    point_iterator endPoint() const { return {*this, nPoints()}; }

    TrackPoint point(std::size_t index) const { return {makeTrackPointData(track(), index)}; }

    TrackPoint operator[](std::size_t index) const { return point(index); }

    // --- END Point-by-point iteration interface ------------------------------

    // --- BEGIN Additional utilities ------------------------------------------

    // --- END Additional utilities --------------------------------------------

  private:
    recob::TrackTrajectory const* originalTrajectoryCPtr() const noexcept
    {
      return hasOriginalTrajectory() ? &originalTrajectory() : nullptr;
    }

  }; // TrackCollectionProxyElement<>

  template <typename TrackCollProxy>
  using Track = TrackCollectionProxyElement<TrackCollProxy>;

  // --- BEGIN Auxiliary data --------------------------------------------------
  inline auto withOriginalTrajectory(art::InputTag const& inputTag)
  {
    return proxy::withZeroOrOneAs<recob::TrackTrajectory, Tracks::TrackTrajectoryTag>(inputTag);
  }

  inline auto withOriginalTrajectory()
  {
    return proxy::withZeroOrOneAs<recob::TrackTrajectory, Tracks::TrackTrajectoryTag>();
  }

  //----------------------------------------------------------------------------
  inline auto withFitHitInfo(art::InputTag const& inputTag)
  {
    return proxy::withParallelDataAs<std::vector<recob::TrackFitHitInfo>,
                                     Tracks::TrackFitHitInfoTag>(inputTag);
  }

  inline auto withFitHitInfo()
  {
    return proxy::withParallelDataAs<std::vector<recob::TrackFitHitInfo>,
                                     Tracks::TrackFitHitInfoTag>();
  }

  // --- END Auxiliary data ----------------------------------------------------

  //----------------------------------------------------------------------------
  template <>
  struct CollectionProxyMakerTraits<Tracks>
    : public CollectionProxyMakerTraits<Tracks::TrackDataProduct_t> {
    // default traits, plus a collection proxy class with a custom element:
    template <typename MainColl, typename... AuxColl>
    using collection_proxy_impl_t = CollectionProxyBase<Track, MainColl, AuxColl...>;
  };

  //----------------------------------------------------------------------------
  template <>
  struct CollectionProxyMaker<Tracks> : public CollectionProxyMakerBase<Tracks> {

    using maker_base_t = CollectionProxyMakerBase<Tracks>;

    template <typename Event, typename... WithArgs>
    static auto make(Event const& event, art::InputTag const& tag, WithArgs&&... withArgs)
    {
      // automatically add associated hits with the same input tag;
      // IDEA: allow a withAssociated<recob::Hit>() from withArgs to override
      // this one; the pattern may be:
      // - if withArgs contains a withAssociated<recob::Hit>(), produce a new
      //   withArgs with that one pushed first
      // - otherwise, produce a new withArgs with a new
      //   withAssociated<recob::Hit>(tag) as first element
      // In principle there is no need for these hits to be first; code might
      // be simpler when assuming that though.
      return maker_base_t::make(event,
                                tag,
                                withAssociatedAs<recob::Hit, Tracks::HitTag>(),
                                std::forward<WithArgs>(withArgs)...);
    } // make()

  }; // struct CollectionProxyMaker<>

  template <typename Data>
  auto wrapTrackPoint(Data const& wrappedData)
  {
    (void)details::StaticAsserts<TrackPointWrapper<Data>>();
    return reinterpret_cast<TrackPointWrapper<Data> const&>(wrappedData);
  }

  template <typename TrackProxy>
  class TrackPointIterator {

    /*
     * So, let's go through the list of iterator traits from cppreference.com:
     * [x] Iterator
     *   [x] CopyConstructible
     *   [x] CopyAssignable
     *   [x] Destructible
     *   [x] lvalues are Swappable
     *   [x] value_type
     *   [x] difference_type
     *   [x] reference
     *   [x] pointer
     *   [x] iterator_category
     *   [x] operator*()
     *   [x] operator++()
     * [ ] InputIterator
     *   [x] Iterator (above)
     *   [x] EqualityComparable (operator== (A, B))
     *   [x] operator!= ()
     *   [ ] reference operator*() (convertible to value_type)
     *   [ ] operator->()
     *   [x] It& operator++()
     *   [x] operator++(int)
     *   [x] *i++ equivalent to { auto v = *i; ++i; return v; }
     * [ ] Forward Iterator
     *   [ ] InputIterator (above)
     *   [x] DefaultConstructible
     *   [x] multipass guarantee: a == b => ++a == ++b
     *   [ ] reference = value_type const&
     *   [x] It operator++(int)
     *   [ ] *i++ returns reference
     * That's it! :-|
     */

    using track_proxy_t = TrackProxy;

    track_proxy_t const* track = nullptr;
    std::size_t index = std::numeric_limits<std::size_t>::max();

  public:
    using difference_type = std::ptrdiff_t;
    using value_type = TrackPoint;
    using pointer = TrackPoint const*;
    using reference = TrackPoint; // booo!
    // not quite an input iterator (see above)
    using iterator_category = std::input_iterator_tag;

    TrackPointIterator() = default;

    TrackPointIterator(track_proxy_t const& track, std::size_t index) : track(&track), index(index)
    {}

    TrackPointIterator& operator++()
    {
      ++index;
      return *this;
    }

    TrackPointIterator operator++(int)
    {
      auto it = *this;
      this->operator++();
      return it;
    }

    // we make sure the return value is a temporary
    value_type operator*() const
    {
      return static_cast<value_type>(makeTrackPointData(*track, index));
    }

    bool operator==(TrackPointIterator const& other) const
    {
      return (index == other.index) && (track == other.track);
    }

    bool operator!=(TrackPointIterator const& other) const
    {
      return (index != other.index) || (track != other.track);
    }

  }; // class TrackPointIterator

} // namespace proxy

namespace proxy {

  //----------------------------------------------------------------------------
  namespace details {

    //--------------------------------------------------------------------------
    template <typename T>
    struct isTrackProxy : public std::false_type {};

    template <typename TrackCollProxy>
    struct isTrackProxy<Track<TrackCollProxy>> : public std::true_type {};

    //--------------------------------------------------------------------------
    template <typename CollProxy>
    struct TrackPointIteratorBox {
      using track_proxy_t = Track<CollProxy>;
      using const_iterator = typename track_proxy_t::point_iterator;

      TrackPointIteratorBox(track_proxy_t const& track) : track(&track) {}

      const_iterator begin() const { return track->beginPoint(); }

      const_iterator end() const { return track->endPoint(); }

    private:
      track_proxy_t const* track = nullptr;

    }; // TrackPointIteratorBox<>

    //--------------------------------------------------------------------------

  } // namespace details

  //----------------------------------------------------------------------------
  template <typename CollProxy>
  recob::TrackTrajectory const* TrackCollectionProxyElement<CollProxy>::operator()(
    proxy::Tracks::TrackType_t type) const noexcept
  {
    switch (type) {
    case proxy::Tracks::Fitted: return &(track().Trajectory());
    case proxy::Tracks::Unfitted: return originalTrajectoryCPtr();
    default: return nullptr;
    } // switch
  }   // TrackCollectionProxyElement<>::operator()

  //----------------------------------------------------------------------------
  template <typename CollProxy>
  recob::TrackFitHitInfo const* TrackCollectionProxyElement<CollProxy>::fitInfoAtPoint(
    std::size_t index) const
  {
    if constexpr (base_t::template has<Tracks::TrackFitHitInfoTag>()) {
      auto const& fitInfo = base_t::template get<Tracks::TrackFitHitInfoTag>();
      return &(fitInfo[index]);
    }
    else
      return nullptr;
  } // TrackCollectionProxyElement<>::fitInfoAtPoint()

  //----------------------------------------------------------------------------
  template <typename CollProxy>
  template <typename Pred>
  auto TrackCollectionProxyElement<CollProxy>::selectPoints(Pred&& pred) const
  {
    return util::filterRangeFor(points(), std::forward<Pred>(pred));
  }

  //----------------------------------------------------------------------------
  template <typename CollProxy>
  auto TrackCollectionProxyElement<CollProxy>::pointsWithFlags(
    recob::TrackTrajectory::PointFlags_t::Mask_t mask) const
  {
    return selectPoints([mask](auto&& point) { return point.flags().match(mask); });
  } // TrackCollectionProxyElement<>::pointsWithFlags()

  //----------------------------------------------------------------------------

} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_TRACK_H