Trajectory.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_TRAJECTORY_H
#define LARDATAOBJ_RECOBASE_TRAJECTORY_H

#include "lardataobj/RecoBase/TrackingTypes.h"

// C/C++ standard libraries
#include <iosfwd>  // std::ostream
#include <utility> // std::pair<>
#include <vector>

namespace recob {

  class Trajectory {
  public:
    using Coord_t = tracking::Coord_t;

    using Point_t = tracking::Point_t;

    using Vector_t = tracking::Vector_t;

    using Positions_t = tracking::Positions_t;

    using Momenta_t = tracking::Momenta_t;

    enum Ends_t {
      kStart,           
      kVertex = kStart, 
      kEnd,             
      NEnds             
    };                  // enum Ends_t

    using TrajectoryPoint_t = tracking::TrajectoryPoint_t;

    using Rotation_t = tracking::Rotation_t;

    Trajectory() = default;

    Trajectory(Positions_t&& positions, Momenta_t&& momenta, bool hasMomenta);

    Trajectory(Positions_t const& positions, Momenta_t const& momenta, bool hasMomenta)
      : Trajectory(Positions_t(positions), Momenta_t(momenta), hasMomenta)
    {}


    size_t NumberTrajectoryPoints() const { return NPoints(); }

    size_t NPoints() const { return fPositions.size(); }

    size_t FirstPoint() const { return 0U; }

    size_t LastPoint() const { return NPoints() - 1; }

    bool HasPoint(size_t i) const { return i < NPoints(); }

    const Positions_t& Positions() const { return fPositions; }

    const Momenta_t& Momenta() const { return fMomenta; }

    TrajectoryPoint_t TrajectoryPoint(size_t i) const
    {
      return {LocationAtPoint(i), MomentumVectorAtPoint(i)};
    }

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

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

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

    Point_t const& LocationAtPoint(size_t i) const { return fPositions[i]; }

    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(FirstPoint()); }

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

    double Theta(size_t p = 0) const { return MomentumVectorAtPoint(p).Theta(); }

    double Phi(size_t p = 0) const { return MomentumVectorAtPoint(p).Phi(); }

    double ZenithAngle(size_t p = 0) const;

    double AzimuthAngle(size_t p = 0) const;

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

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

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

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

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

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

    Vector_t DirectionAtPoint(size_t i) const;

    bool HasMomentum() const { return fHasMomentum; }

    double MomentumAtPoint(size_t i) const { return MomentumVectorAtPoint(i).R(); }

    Vector_t const& MomentumVectorAtPoint(size_t i) const { return fMomenta[i]; }

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

    Rotation_t GlobalToLocalRotationAtPoint(size_t p) const;

    Rotation_t LocalToGlobalRotationAtPoint(size_t p) const;


    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 = 6;

  protected:
  private:
    Positions_t fPositions; 
    Momenta_t fMomenta;     

    bool fHasMomentum = true; 

  }; // class Trajectory

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

  //----------------------------------------------------------------------------
  namespace details {
    namespace legacy {
      // These implementation details are shared with other classes
      // until the legacy support is gone.

      template <typename Vect>
      void FillVector(Vect const& source, std::vector<double>& dest);

      template <typename Vect>
      void FillVector(Vect const& source, double* dest);

      template <typename SrcVect, typename DestVect>
      void FillTwoVectors(SrcVect const& firstSource,
                          SrcVect const& secondSource,
                          DestVect&& firstDest,
                          DestVect&& secondDest);

    } // namespace legacy
  }   // namespace details

} // namespace recob

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

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

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

#endif // LARDATAOBJ_RECOBASE_TRAJECTORY_H