Track.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_TRACK_H
#define LARDATAOBJ_RECOBASE_TRACK_H

#include "larcoreobj/SimpleTypesAndConstants/PhysicalConstants.h"
#include "lardataobj/RecoBase/TrackTrajectory.h"
#include "lardataobj/RecoBase/TrackingTypes.h"

#include <iosfwd>
#include <stddef.h>

namespace recob {

  class Track {

  public:
    using Point_t = tracking::Point_t;
    using Vector_t = tracking::Vector_t;
    using Positions_t = tracking::Positions_t;
    using Momenta_t = tracking::Momenta_t;
    using Rotation_t = tracking::Rotation_t;
    using TrajectoryPoint_t = tracking::TrajectoryPoint_t;

    using SMatrixSym55 = tracking::SMatrixSym55;
    using SMatrixSym66 = tracking::SMatrixSym66;
    using SMatrix65 = tracking::SMatrix65;
    using SMatrix56 = tracking::SMatrix56;
    using SVector6 = tracking::SVector6;
    using SVector5 = tracking::SVector5;

    using PointFlags_t = TrackTrajectory::PointFlags_t;
    using Flags_t = TrackTrajectory::Flags_t;

  protected:
    TrackTrajectory fTraj; 
    int fPId = 0;          
    float fChi2 = -1.;     
    int fNdof = 0.;        
    SMatrixSym55
      fCovVertex;         
    SMatrixSym55 fCovEnd; 
    int fID = -1;         

  public:
    //Default constructor
    Track() = default;

    Track(TrackTrajectory const& Traj,
          int PId,
          float Chi2,
          int Ndof,
          SMatrixSym55 const& CovVertex,
          SMatrixSym55 const& CovEnd,
          int tkID)
      : fTraj(Traj)
      , fPId(PId)
      , fChi2(Chi2)
      , fNdof(Ndof)
      , fCovVertex(CovVertex)
      , fCovEnd(CovEnd)
      , fID(tkID){};

    Track(TrackTrajectory&& Traj,
          int PId,
          float Chi2,
          int Ndof,
          SMatrixSym55&& CovVertex,
          SMatrixSym55&& CovEnd,
          int tkID)
      : fTraj(std::move(Traj))
      , fPId(PId)
      , fChi2(Chi2)
      , fNdof(Ndof)
      , fCovVertex(std::move(CovVertex))
      , fCovEnd(std::move(CovEnd))
      , fID(tkID){};

    Track(Positions_t&& positions,
          Momenta_t&& momenta,
          Flags_t&& flags,
          bool hasMomenta,
          int PId,
          float Chi2,
          int Ndof,
          SMatrixSym55&& CovVertex,
          SMatrixSym55&& CovEnd,
          int tkID)
      : fTraj(std::move(positions), std::move(momenta), std::move(flags), hasMomenta)
      , fPId(PId)
      , fChi2(Chi2)
      , fNdof(Ndof)
      , fCovVertex(std::move(CovVertex))
      , fCovEnd(std::move(CovEnd))
      , fID(tkID){};

    inline const recob::TrackTrajectory& Trajectory() const { return fTraj; }

    inline size_t NumberTrajectoryPoints() const { return fTraj.NumberTrajectoryPoints(); }
    inline size_t NPoints() const { return fTraj.NPoints(); }
    inline size_t FirstPoint() const { return fTraj.FirstPoint(); }
    inline size_t LastPoint() const { return fTraj.LastPoint(); }
    inline size_t FirstValidPoint() const { return fTraj.FirstValidPoint(); }
    inline size_t NextValidPoint(size_t index) const { return fTraj.NextValidPoint(index); }
    inline size_t PreviousValidPoint(size_t index) const { return fTraj.PreviousValidPoint(index); }
    inline size_t LastValidPoint() const { return fTraj.LastValidPoint(); }
    inline bool HasPoint(size_t i) const { return fTraj.HasPoint(i); }
    inline bool HasValidPoint(size_t i) const { return fTraj.HasValidPoint(i); }
    inline unsigned int CountValidPoints() const { return fTraj.CountValidPoints(); }

    inline TrajectoryPoint_t TrajectoryPoint(size_t i) const { return fTraj.TrajectoryPoint(i); }
    inline PointFlags_t const& FlagsAtPoint(size_t i) const { return fTraj.FlagsAtPoint(i); }

    inline Point_t const& Start() const { return fTraj.Start(); }
    inline Point_t const& Vertex() const { return fTraj.Vertex(); }
    inline Point_t const& End() const { return fTraj.End(); }
    inline Point_t const& LocationAtPoint(size_t i) const { return fTraj.LocationAtPoint(i); }

    inline Vector_t StartDirection() const { return fTraj.StartDirection(); }
    inline Vector_t VertexDirection() const { return fTraj.VertexDirection(); }
    inline Vector_t EndDirection() const { return fTraj.EndDirection(); }
    inline Vector_t DirectionAtPoint(size_t i) const { return fTraj.DirectionAtPoint(i); }

    inline bool HasMomentum() const { return fTraj.HasMomentum(); }
    inline double MomentumAtPoint(unsigned int p) const { return fTraj.MomentumAtPoint(p); }
    inline double VertexMomentum() const { return fTraj.VertexMomentum(); }
    inline double StartMomentum() const { return fTraj.StartMomentum(); }
    inline double EndMomentum() const { return fTraj.EndMomentum(); }
    inline Vector_t const& VertexMomentumVector() const { return fTraj.VertexMomentumVector(); }
    inline Vector_t const& StartMomentumVector() const { return fTraj.StartMomentumVector(); }
    inline Vector_t const& EndMomentumVector() const { return fTraj.EndMomentumVector(); }
    inline Vector_t const& MomentumVectorAtPoint(size_t i) const
    {
      return fTraj.MomentumVectorAtPoint(i);
    }

    const SMatrixSym55& StartCovariance() const { return fCovVertex; }
    const SMatrixSym55& VertexCovariance() const { return fCovVertex; }
    const SMatrixSym55& EndCovariance() const { return fCovEnd; }

    inline std::pair<Point_t, Point_t> Extent() const { return fTraj.Extent(); }
    inline std::pair<Vector_t, Vector_t> Direction() const { return fTraj.Direction(); }
    inline std::pair<SMatrixSym55, SMatrixSym55> Covariances() const
    {
      return std::pair<SMatrixSym55, SMatrixSym55>(fCovVertex, fCovEnd);
    }

    inline double Length(size_t p = 0) const { return fTraj.Length(p); }
    inline float Chi2() const { return fChi2; }
    inline float Chi2PerNdof() const { return fNdof > 0 ? fChi2 / float(fNdof) : util::kBogusF; }
    inline int Ndof() const { return fNdof; }
    inline int ParticleId() const { return fPId; }

    inline double Theta() const { return fTraj.Theta(); }
    inline double Theta(size_t p) const { return fTraj.Theta(p); }
    inline double Phi() const { return fTraj.Phi(); }
    inline double Phi(size_t p) const { return fTraj.Phi(p); }
    inline double ZenithAngle() const { return fTraj.ZenithAngle(); }
    inline double ZenithAngle(size_t p) const { return fTraj.ZenithAngle(p); }
    inline double AzimuthAngle() const { return fTraj.AzimuthAngle(); }
    inline double AzimuthAngle(size_t p) const { return fTraj.AzimuthAngle(p); }

    // Calculate rotation matrices between global (x,y,z) and local (u,v,w)
    // coordinate systems based on track direction (fDir).
    // The local w-axis points along the track direction.
    inline Rotation_t GlobalToLocalRotationAtPoint(size_t p) const
    {
      return fTraj.GlobalToLocalRotationAtPoint(p);
    }
    inline Rotation_t LocalToGlobalRotationAtPoint(size_t p) const
    {
      return fTraj.LocalToGlobalRotationAtPoint(p);
    }

    inline int ID() const { return fID; }
    friend bool operator<(const Track& a, const Track& b);

    SVector5 VertexParametersLocal5D() const;
    SVector5 EndParametersLocal5D() const;
    const SMatrixSym55& VertexCovarianceLocal5D() const { return fCovVertex; }
    const SMatrixSym55& EndCovarianceLocal5D() const { return fCovEnd; }
    SVector6 VertexParametersGlobal6D() const;
    SVector6 EndParametersGlobal6D() const;
    SMatrixSym66 VertexCovarianceGlobal6D() const;
    SMatrixSym66 EndCovarianceGlobal6D() const;


    template <typename T>
    inline T Start() const
    {
      return fTraj.Start<T>();
    }

    template <typename T>
    inline T Vertex() const
    {
      return fTraj.Vertex<T>();
    }

    template <typename T>
    inline T End() const
    {
      return fTraj.End<T>();
    }

    template <typename T>
    inline T LocationAtPoint(unsigned int p) const
    {
      return fTraj.LocationAtPoint<T>(p);
    }

    template <typename T>
    inline T StartDirection() const
    {
      return fTraj.StartDirection<T>();
    }

    template <typename T>
    inline T VertexDirection() const
    {
      return fTraj.VertexDirection<T>();
    }

    template <typename T>
    inline T EndDirection() const
    {
      return fTraj.EndDirection<T>();
    }

    template <typename T>
    inline T DirectionAtPoint(unsigned int p) const
    {
      return fTraj.DirectionAtPoint<T>(p);
    }

    template <typename T>
    inline T StartMomentumVector() const
    {
      return fTraj.StartMomentumVector<T>();
    }

    template <typename T>
    inline T VertexMomentumVector() const
    {
      return fTraj.VertexMomentumVector<T>();
    }

    template <typename T>
    inline T EndMomentumVector() const
    {
      return fTraj.EndMomentumVector<T>();
    }

    template <typename T>
    inline T MomentumVectorAtPoint(unsigned int p) const
    {
      return fTraj.MomentumVectorAtPoint<T>(p);
    }

    template <typename T>
    inline T StartCovariance() const;

    template <typename T>
    inline T VertexCovariance() const
    {
      return StartCovariance<T>();
    }

    template <typename T>
    inline T EndCovariance() const;

    template <typename T>
    inline std::pair<T, T> Extent() const
    {
      return fTraj.Extent<T>();
    }

    template <typename T>
    inline std::pair<T, T> Direction() const
    {
      return fTraj.Direction<T>();
    }

    template <typename T>
    inline T GlobalToLocalRotationAtPoint(unsigned int p) const
    {
      return fTraj.GlobalToLocalRotationAtPoint<T>(p);
    }

    template <typename T>
    inline T LocalToGlobalRotationAtPoint(unsigned int p) const
    {
      return fTraj.LocalToGlobalRotationAtPoint<T>(p);
    }

  protected:
    friend std::ostream& operator<<(std::ostream& stream, Track const& a);
  };
}

template <typename T>
inline T recob::Track::StartCovariance() const
{
  T result = T(5, 5);
  for (unsigned int i = 0; i < 5; i++) {
    for (unsigned int j = 0; j < 5; j++) {
      result(i, j) = fCovVertex.At(i, j);
    }
  }
  return result;
}

template <typename T>
inline T recob::Track::EndCovariance() const
{
  T result = T(5, 5);
  for (unsigned int i = 0; i < 5; i++) {
    for (unsigned int j = 0; j < 5; j++) {
      result(i, j) = fCovEnd.At(i, j);
    }
  }
  return result;
}

#endif // LARDATAOBJ_RECOBASE_TRACK_H