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/Track.h"
#include "lardataobj/RecoBase/TrackTrajectory.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/TrackFitHitInfo.h"

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

// range library
#include "range/v3/view/filter.hpp" // range::view::filter()

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 (!base_t::template has<Tracks::TrackFitHitInfoTag>())
      return nullptr;
    auto&& fitInfo = base_t::template getIf<
      Tracks::TrackFitHitInfoTag,
      std::vector<recob::TrackFitHitInfo> const&
      >();
    return &(fitInfo[index]);
  } // 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