Trajectory.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_TRAJECTORY_H
#define LARDATAOBJ_RECOBASE_TRAJECTORY_H

#include "TMatrixDfwd.h" // forward declarations for legacy interface

#include "lardataobj/RecoBase/TrackingTypes.h"

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


// ROOT forward declarations (for legacy interface)
class TVector3;

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