Start of the generic CRTP interface to tracks

Author: mpuccio

DataFormats/Reconstruction/include/ReconstructionDataFormats/Track.h

@@ -32,8 +32,8 @@ using TrackParCovF = TrackParametrizationWithError<float>;
 using TrackParCovD = TrackParametrizationWithError<double>;
 using TrackParCov = TrackParCovF;
 
-static_assert(sizeof(TrackPar) == sizeof(TrackPar::base_t) + 8);
-static_assert(sizeof(TrackParCov) == sizeof(TrackPar) + sizeof(TrackParCov::covMat_t));
+static_assert(sizeof(TrackPar) == sizeof(TrackPar::base_t));
+static_assert(sizeof(TrackParCov) == sizeof(TrackPar) + sizeof(TrackParCov::cov_base_t));
 
 } // namespace track
 } // namespace o2

DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h

@@ -24,7 +24,7 @@
 #endif
 #include "MathUtils/Utils.h"
 #include "ReconstructionDataFormats/TrackUtils.h"
-#include "ReconstructionDataFormats/TrackParametrizationData.h"
+#include "ReconstructionDataFormats/TrackParametrizationInterface.h"
 #include "MathUtils/Primitive2D.h"
 
 namespace o2::track
@@ -36,11 +36,12 @@ class TrackParametrization; // fwd declaration for conversion method
 template <typename value_T>
 class TrackParametrizationWithError; // fwd declaration for conversion method
 
-class TrackParFwd : public TrackParametrizationData<float, 5>
+class TrackParFwd : public TrackParametrizationData<float, 5>, public TrackParFwdInterface<TrackParFwd, float>
 { // Forward track parameterization, kinematics only.
  public:
   using value_t = float;
   using base_t = TrackParametrizationData<value_t, 5>;
+  using fwd_interface_t = TrackParFwdInterface<TrackParFwd, value_t>;
   using params_t = std::array<value_t, 5>;
 
   TrackParFwd() = default;
@@ -141,11 +142,6 @@ class TrackParFwd : public TrackParametrizationData<float, 5>
     }
   }
 
-  /// return the chi2 of the track when the associated cluster was attached
-  value_t getTrackChi2() const { return mTrackChi2; }
-  /// set the chi2 of the track when the associated cluster was attached
-  void setTrackChi2(value_t chi2) { mTrackChi2 = chi2; }
-
   // Track parameter propagation
   void propagateParamToZlinear(double zEnd);
   void propagateParamToZquadratic(double zEnd, double zField);
@@ -162,15 +158,15 @@ class TrackParFwd : public TrackParametrizationData<float, 5>
   /// PHI     = azimutal angle
   /// TANL    = tangent of \lambda (dip angle)
   /// INVQPT    = Inverse transverse momentum (GeV/c ** -1) times charge (assumed forward motion)  </pre>
-  value_t mTrackChi2 = 0.; ///< Chi2 of the track when the associated cluster was attached
 
   ClassDefNV(TrackParFwd, 1);
 };
 
-class TrackParCovFwd : public TrackParFwd, public TrackCovarianceData<TrackParFwd::value_t, 15>
+class TrackParCovFwd : public TrackParFwd, public TrackCovarianceData<TrackParFwd::value_t, 15>, public TrackParCovFwdInterface<TrackParCovFwd, TrackParFwd::value_t>
 { // Forward track+error parameterization
  public:
   using cov_base_t = TrackCovarianceData<value_t, 15>;
+  using cov_interface_t = TrackParCovFwdInterface<TrackParCovFwd, value_t>;
   using covMat_t = std::array<value_t, 15>;
   struct cov_view_t {
     const value_t* data = nullptr;
@@ -237,8 +233,8 @@ class TrackParCovFwd : public TrackParFwd, public TrackCovarianceData<TrackParFw
   ClassDefNV(TrackParCovFwd, 1);
 };
 
-static_assert(sizeof(TrackParFwd) == sizeof(TrackParFwd::base_t) + sizeof(TrackParFwd::value_t));
-static_assert(sizeof(TrackParCovFwd) == sizeof(TrackParFwd) + 15 * sizeof(TrackParFwd::value_t));
+static_assert(sizeof(TrackParFwd) == sizeof(TrackParFwd::base_t));
+static_assert(sizeof(TrackParCovFwd) == sizeof(TrackParFwd) + sizeof(TrackParCovFwd::cov_base_t));
 
 #ifndef GPUCA_GPUCODE_DEVICE
 inline std::ostream& operator<<(std::ostream& os, const TrackParCovFwd::cov_view_t& cov)

DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h

@@ -274,25 +274,22 @@ class TrackParametrization : public TrackParametrizationData<value_T, kNParams>
  protected:
   using base_t::mP;
   using base_t::mX;
+  using base_t::mAlpha;
+  using base_t::mAbsCharge;
+  using base_t::mPID;
+  using base_t::mUserField;
 
  private:
-  //
   static constexpr value_t InvalidX = -99999.f;
-  value_t mAlpha = 0.f;    /// track frame angle
-  char mAbsCharge = 1;     /// Extra info about the abs charge, to be taken into account only if not 1
-  PID mPID{PID::Pion};     /// 8 bit PID
-  uint16_t mUserField = 0; /// field provided to user
 
   ClassDefNV(TrackParametrization, 3);
 };
 
 //____________________________________________________________
 template <typename value_T>
 GPUdi() TrackParametrization<value_T>::TrackParametrization(value_t x, value_t alpha, const params_t& par, int charge, const PID pid)
-  : base_t{x}, mAlpha{alpha}, mAbsCharge{char(gpu::CAMath::Abs(charge))}, mPID{pid}
+  : base_t{x, alpha, charge, pid}
 {
-  // explicit constructor
-  math_utils::detail::bringToPMPi<value_t>(mAlpha);
   for (int i = 0; i < kNParams; i++) {
     mP[i] = par[i];
   }

DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationData.h

@@ -17,12 +17,21 @@
 
 #include "GPUCommonDef.h"
 #include "GPUCommonRtypes.h"
+#include "MathUtils/Utils.h"
+#include "ReconstructionDataFormats/PID.h"
 
 #include <array>
+#include <cstdint>
 
 namespace o2::track
 {
 
+template <typename derived_T, typename value_T, int nParams>
+class TrackParametrizationInterface;
+
+template <typename derived_T, typename value_T, int nCov>
+class TrackCovarianceInterface;
+
 template <typename value_T, int nParams>
 class TrackParametrizationData
 {
@@ -31,15 +40,27 @@ class TrackParametrizationData
 
   GPUdDefault() TrackParametrizationData() = default;
   GPUd() explicit TrackParametrizationData(value_t s) : mX{s} {}
+  GPUd() TrackParametrizationData(value_t s, value_t alpha, int charge, PID pid = PID::Pion)
+    : mX{s}, mAlpha{alpha}, mAbsCharge{static_cast<char>(charge < 0 ? -charge : charge)}, mPID{pid}
+  {
+    math_utils::detail::bringToPMPi<value_t>(mAlpha);
+  }
   GPUdDefault() TrackParametrizationData(const TrackParametrizationData&) = default;
   GPUdDefault() TrackParametrizationData(TrackParametrizationData&&) = default;
   GPUhdDefault() TrackParametrizationData& operator=(const TrackParametrizationData&) = default;
   GPUhdDefault() TrackParametrizationData& operator=(TrackParametrizationData&&) = default;
   GPUdDefault() ~TrackParametrizationData() = default;
 
  protected:
-  value_t mX = 0;          ///< Intrinsic coordinate of the track parameterization
+  value_t mX = 0;           ///< Intrinsic coordinate of the track parameterization
   value_t mP[nParams] = {}; ///< Local track parameters
+  value_t mAlpha = 0;       ///< Track frame angle (where applicable)
+  char mAbsCharge = 1;      ///< Extra info about the abs charge, to be taken into account only if not 1
+  PID mPID{PID::Pion};      ///< 8 bit PID
+  uint16_t mUserField = 0;  ///< Field provided to user
+
+  template <typename, typename, int>
+  friend class TrackParametrizationInterface;
 
   ClassDefNV(TrackParametrizationData, 1);
 };
@@ -59,6 +80,10 @@ class TrackCovarianceData
 
  protected:
   std::array<value_t, nCov> mC{}; ///< Packed covariance matrix
+  value_t mTrackChi2 = 0;         ///< Chi2 of the track fit
+
+  template <typename, typename, int>
+  friend class TrackCovarianceInterface;
 
   ClassDefNV(TrackCovarianceData, 1);
 };