TrackingTypes.h

Go to the documentation of this file.

#ifndef TRACKINGTYPE_H
#define TRACKINGTYPE_H

// LArSoft libraries
#include "larcorealg/Geometry/geo_vectors_utils.h"

// ROOT libraries
#include "Math/GenVector/Rotation3D.h"
#include "Math/GenVector/AxisAngle.h"
#include "Math/SMatrix.h"
#include "TVector3.h"

namespace recob {

  namespace tracking {

    using Coord_t = Double32_t;
    
    using Point_t = ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<Coord_t>, ROOT::Math::GlobalCoordinateSystemTag>;
    
    using Vector_t = ROOT::Math::DisplacementVector3D <ROOT::Math::Cartesian3D<Coord_t>, ROOT::Math::GlobalCoordinateSystemTag>;
    
    using Positions_t = std::vector<Point_t>;
    
    using Momenta_t = std::vector<Vector_t>;

    using Rotation_t = ROOT::Math::Rotation3D;

    template <typename To, typename From> std::vector<To> convertVec(std::vector<From> const& in) {
      std::vector<To> out;
      out.reserve(in.size());
      for (auto& i : in) out.push_back(To(i));
      return out;
    }
    template <typename From> std::vector<TVector3> convertVecPointToTVec3(std::vector<From> const& in) {
      std::vector<TVector3> out;
      out.reserve(in.size());
      for (auto& i : in) out.push_back(TVector3(i.X(),i.Y(),i.Z()));
      return out;
    }
    template <typename Point> Point_t toPoint(Point const& p) { return geo::vect::convertTo<Point_t>(p); }
    template <typename Point> std::vector<Point_t> convertCollToPoint (std::vector<Point> const& coll)
      { return geo::vect::convertCollTo<Point_t>(coll); }
    template <typename Vector> Vector_t toVector(Vector const& p) { return geo::vect::convertTo<Vector_t>(p); }
    template <typename Vector> std::vector<Vector_t> convertCollToVector (std::vector<Vector> const& coll)
      { return geo::vect::convertCollTo<Vector_t>(coll); }

    struct TrajectoryPoint_t {

      Point_t position; 
      Vector_t momentum; 

      TrajectoryPoint_t() = default;

      TrajectoryPoint_t(Point_t pos, Vector_t mom)
        : position(pos), momentum(mom) {}

      Vector_t direction() const
        { return momentum.Unit(); }

    }; // TrajectoryPoint_t

    using SMatrixSym22 = ROOT::Math::SMatrix<Double32_t,2,2,ROOT::Math::MatRepSym<Double32_t,2> >;
    using SMatrixSym33 = ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >;
    using SMatrixSym55 = ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >;
    using SMatrixSym66 = ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >;
    using SMatrix65    = ROOT::Math::SMatrix<Double32_t,6,5>;
    using SMatrix56    = ROOT::Math::SMatrix<Double32_t,5,6>;
    using SMatrix55    = ROOT::Math::SMatrix<Double32_t,5,5>;
    using SMatrix66    = ROOT::Math::SMatrix<Double32_t,6,6>;
    using SVector6     = ROOT::Math::SVector<Double32_t,6>;
    using SVector5     = ROOT::Math::SVector<Double32_t,5>;
    using SVector3     = ROOT::Math::SVector<Double32_t,3>;
    using SVector2     = ROOT::Math::SVector<Double32_t,2>;
    
  }
  
}

#endif