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; }
    
    bool TrajectoryAtPoint(size_t i, TVector3& pos, TVector3& dir) const;
    
    
    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]; }
    
    
    [[deprecated("Use point interface instead")]]
    void Extent(std::vector<double>& start, std::vector<double>& end) const;
    
    std::pair<Point_t, Point_t> Extent() const
      { return { Start(), End() }; }
    
    
    double Length (size_t startAt = 0) const;
    
    
    
    
    [[deprecated("Use NumberTrajectoryPoints() instead")]]
    size_t NumberFitMomentum() const
      { return HasMomentum()? NPoints(): 0U; }
    
    
    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]; }
    
    void Direction(double* start, double* end) const;
    
    
    std::pair<Vector_t, Vector_t> Direction() const
      { return { StartDirection(), EndDirection() }; }
    
    
    
    Rotation_t GlobalToLocalRotationAtPoint(size_t p) const;
    
    void GlobalToLocalRotationAtPoint(unsigned int p, TMatrixD &rot) const;
    
    Rotation_t LocalToGlobalRotationAtPoint(size_t p) const;
    
    void LocalToGlobalRotationAtPoint(unsigned int p, TMatrixD &rot) const;
    
    
    
    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