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 <vector>
#include <iosfwd> // std::ostream
#include <limits> // std::numeric_limits<>


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