TrackTrajectory.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_TRACKTRAJECTORY_H
#define LARDATAOBJ_RECOBASE_TRACKTRAJECTORY_H

// ROOT libraries
#include "lardataobj/RecoBase/Trajectory.h"
#include "lardataobj/RecoBase/TrajectoryPointFlags.h"

// C/C++ standard libraries
#include <iosfwd> // std::ostream
#include <limits> // std::numeric_limits<>
#include <vector>

namespace recob {

  class TrackTrajectory : private recob::Trajectory {
    using Trajectory_t = recob::Trajectory;

  public:
    using Coord_t = tracking::Coord_t;

    using Point_t = tracking::Point_t;

    using Vector_t = tracking::Vector_t;

    using PointFlags_t = recob::TrajectoryPointFlags;

    using flag = PointFlags_t::flag;

    using Positions_t = tracking::Positions_t;

    using Momenta_t = tracking::Momenta_t;

    using Flags_t = std::vector<PointFlags_t>;

    using Ends_t = Trajectory_t::Ends_t;

    using TrajectoryPoint_t = tracking::TrajectoryPoint_t;

    using Rotation_t = tracking::Rotation_t;

    TrackTrajectory() = default;

    TrackTrajectory(Positions_t&& positions, Momenta_t&& momenta, Flags_t&& flags, bool hasMomenta);

    TrackTrajectory(const Trajectory& traj, Flags_t&& flags)
      : TrackTrajectory(Positions_t(traj.Positions()),
                        Momenta_t(traj.Momenta()),
                        std::move(flags),
                        traj.HasMomentum())
    {}

    Trajectory_t const& Trajectory() const { return static_cast<Trajectory_t const&>(*this); }

    using Trajectory_t::NumberTrajectoryPoints;

    using Trajectory_t::NPoints;

    using Trajectory_t::FirstPoint;

    using Trajectory_t::LastPoint;

    using Trajectory_t::HasPoint;

    PointFlags_t const& FlagsAtPoint(size_t i) const { return fFlags[i]; }

    Flags_t const& Flags() const { return fFlags; }

    bool HasValidPoint(size_t i) const
    {
      return Trajectory().HasPoint(i) && !FlagsAtPoint(i).isSet(flag::NoPoint);
    }

    size_t FirstValidPoint() const { return NextValidPoint(0U); }

    size_t NextValidPoint(size_t index) const { return ToValidPoint<+1>(index); }

    size_t PreviousValidPoint(size_t index) const { return ToValidPoint<-1>(index); }

    size_t LastValidPoint() const { return PreviousValidPoint(LastPoint()); }

    unsigned int CountValidPoints() const;

    using Trajectory_t::TrajectoryPoint;

    Point_t const& Vertex() const { return Start(); }

    Point_t const& Start() const { return LocationAtPoint(FirstValidPoint()); }

    Point_t const& End() const { return LocationAtPoint(LastValidPoint()); }

    using Trajectory_t::LocationAtPoint;

    template <typename T>
    std::pair<T, T> Extent() const
    {
      return {Vertex<T>(), End<T>()};
    }

    std::pair<Point_t, Point_t> Extent() const { return {Start(), End()}; }

    double Length(size_t startAt = 0) const;

    Vector_t VertexDirection() const { return StartDirection(); }

    Vector_t StartDirection() const { return DirectionAtPoint(FirstValidPoint()); }

    Vector_t EndDirection() const { return DirectionAtPoint(LastValidPoint()); }

    double Theta(size_t p) const { return Trajectory().Theta(p); }

    double Theta() const { return Theta(FirstValidPoint()); }

    double Phi(size_t p) const { return Trajectory().Phi(p); }

    double Phi() const { return Phi(FirstValidPoint()); }

    double ZenithAngle(size_t p) const { return Trajectory().ZenithAngle(p); }

    double ZenithAngle() const { return ZenithAngle(FirstValidPoint()); }

    double AzimuthAngle(size_t p) const { return Trajectory().AzimuthAngle(p); }

    double AzimuthAngle() const { return AzimuthAngle(FirstValidPoint()); }

    Vector_t const& VertexMomentumVector() const { return StartMomentumVector(); }

    Vector_t const& StartMomentumVector() const { return MomentumVectorAtPoint(FirstValidPoint()); }

    Vector_t const& EndMomentumVector() const { return MomentumVectorAtPoint(LastValidPoint()); }

    double VertexMomentum() const { return StartMomentum(); }

    double StartMomentum() const { return StartMomentumVector().R(); }

    double EndMomentum() const { return EndMomentumVector().R(); }

    using Trajectory_t::DirectionAtPoint;

    using Trajectory_t::HasMomentum;

    using Trajectory_t::MomentumAtPoint;

    using Trajectory_t::MomentumVectorAtPoint;

    template <typename T>
    std::pair<T, T> Direction() const
    {
      return {VertexDirection<T>(), EndDirection<T>()};
    }

    std::pair<Vector_t, Vector_t> Direction() const { return {StartDirection(), EndDirection()}; }

    using Trajectory_t::GlobalToLocalRotationAtPoint;

    using Trajectory_t::LocalToGlobalRotationAtPoint;


    template <typename T>
    inline T Start() const
    {
      auto& loc = Start();
      return T(loc.X(), loc.Y(), loc.Z());
    }

    template <typename T>
    inline T Vertex() const
    {
      auto& loc = Vertex();
      return T(loc.X(), loc.Y(), loc.Z());
    }

    template <typename T>
    inline T End() const
    {
      auto& loc = End();
      return T(loc.X(), loc.Y(), loc.Z());
    }

    template <typename T>
    inline T LocationAtPoint(unsigned int p) const
    {
      auto& loc = LocationAtPoint(p);
      return T(loc.X(), loc.Y(), loc.Z());
    }

    template <typename T>
    inline T StartDirection() const
    {
      auto dir = StartDirection();
      return T(dir.X(), dir.Y(), dir.Z());
    }

    template <typename T>
    inline T VertexDirection() const
    {
      auto dir = VertexDirection();
      return T(dir.X(), dir.Y(), dir.Z());
    }

    template <typename T>
    inline T EndDirection() const
    {
      auto dir = EndDirection();
      return T(dir.X(), dir.Y(), dir.Z());
    }

    template <typename T>
    inline T DirectionAtPoint(unsigned int p) const
    {
      auto dir = DirectionAtPoint(p);
      return T(dir.X(), dir.Y(), dir.Z());
    }

    template <typename T>
    inline T StartMomentumVector() const
    {
      auto mom = StartMomentumVector();
      return T(mom.X(), mom.Y(), mom.Z());
    }

    template <typename T>
    inline T VertexMomentumVector() const
    {
      auto mom = VertexMomentumVector();
      return T(mom.X(), mom.Y(), mom.Z());
    }

    template <typename T>
    inline T EndMomentumVector() const
    {
      auto mom = EndMomentumVector();
      return T(mom.X(), mom.Y(), mom.Z());
    }

    template <typename T>
    inline T MomentumVectorAtPoint(unsigned int p) const
    {
      auto mom = MomentumVectorAtPoint(p);
      return T(mom.X(), mom.Y(), mom.Z());
    }

    template <typename T>
    inline T GlobalToLocalRotationAtPoint(unsigned int p) const
    {
      T rot(3, 3);
      GlobalToLocalRotationAtPoint(p).GetRotationMatrix(rot);
      return rot;
    }

    template <typename T>
    inline T LocalToGlobalRotationAtPoint(unsigned int p) const
    {
      T rot(3, 3);
      LocalToGlobalRotationAtPoint(p).GetRotationMatrix(rot);
      return rot;
    }

    template <typename Stream>
    void Dump(Stream&& out,
              unsigned int verbosity,
              std::string indent,
              std::string indentFirst) const;

    template <typename Stream>
    void Dump(Stream&& out, unsigned int verbosity = 1, std::string indent = {}) const
    {
      Dump(std::forward<Stream>(out), verbosity, indent, indent);
    }

    template <typename Stream>
    void LowLevelDump(Stream&& out, std::string indent, std::string indentFirst) const;

    static constexpr unsigned int MaxDumpVerbosity = 7;

    static constexpr size_t InvalidIndex = std::numeric_limits<size_t>::max();

  private:
    Flags_t fFlags; 

    template <int Dir>
    size_t ToValidPoint(size_t index) const;

    bool AtLeastValidTrajectoryPoints(unsigned int left) const;

  }; // class TrackTrajectory

  std::ostream& operator<<(std::ostream&& out, TrackTrajectory const& traj);

} // namespace recob

//------------------------------------------------------------------------------
//--- Inline implementation
//---

//------------------------------------------------------------------------------
//--- Template implementation
//---
#include "TrackTrajectory.tcc"

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

#endif // LARDATAOBJ_RECOBASE_TRACKTRAJECTORY_H