GPUTrackingRefit.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef GPUTRACKINGREFIT_H
#define GPUTRACKINGREFIT_H
 
#include "GPUDef.h"
#include "GPUProcessor.h"
 
namespace o2::dataformats
{
template <typename FirstEntry, typename NElem>
class RangeReference;
}
namespace o2::track
{
template <typename T>
class TrackParametrizationWithError;
using TrackParCov = TrackParametrizationWithError<float>;
} // namespace o2::track
namespace o2::base
{
template <typename>
class PropagatorImpl;
using Propagator = PropagatorImpl<float>;
class MatLayerCylSet;
} // namespace o2::base
namespace o2::tpc
{
struct ClusterNativeAccess;
class TrackTPC;
using TrackTPCClusRef = o2::dataformats::RangeReference<uint32_t, uint16_t>;
} // namespace o2::tpc
 
namespace o2::gpu
{
class TPCFastTransformPOD;
class GPUTPCGMTrackParam;
class GPUTPCGMMergedTrack;
struct GPUConstantMem;
struct GPUParam;
struct GPUTPCGMMergedTrackHit;
 
class GPUTrackingRefit
{
 public:
  void SetClusterStateArray(const uint8_t* v) { mPclusterState = v; }
  void SetPtrsFromGPUConstantMem(const GPUConstantMem* v, GPUParam* p = nullptr);
  void SetPropagator(const o2::base::Propagator* v) { mPpropagator = v; }
  void SetClusterNative(const o2::tpc::ClusterNativeAccess* v) { mPclusterNative = v; }
  void SetTrackHits(const GPUTPCGMMergedTrackHit* v) { mPtrackHits = v; }
  void SetTrackHitReferences(const uint32_t* v) { mPtrackHitReferences = v; }
  void SetFastTransform(const TPCFastTransformPOD* v) { mPfastTransform = v; }
  void SetGPUParam(const GPUParam* v) { mPparam = v; }
  GPUd() int32_t RefitTrackAsGPU(GPUTPCGMMergedTrack& trk, bool outward = false, bool resetCov = false) { return RefitTrack<GPUTPCGMMergedTrack, GPUTPCGMTrackParam>(trk, outward, resetCov); }
  GPUd() int32_t RefitTrackAsTrackParCov(GPUTPCGMMergedTrack& trk, bool outward = false, bool resetCov = false) { return RefitTrack<GPUTPCGMMergedTrack, o2::track::TrackParCov>(trk, outward, resetCov); }
  GPUd() int32_t RefitTrackAsGPU(o2::tpc::TrackTPC& trk, bool outward = false, bool resetCov = false) { return RefitTrack<o2::tpc::TrackTPC, GPUTPCGMTrackParam>(trk, outward, resetCov); }
  GPUd() int32_t RefitTrackAsTrackParCov(o2::tpc::TrackTPC& trk, bool outward = false, bool resetCov = false) { return RefitTrack<o2::tpc::TrackTPC, o2::track::TrackParCov>(trk, outward, resetCov); }
 
  struct TrackParCovWithArgs {
    o2::track::TrackParCov& trk;
    const o2::tpc::TrackTPCClusRef& clusRef;
    float time0;
    float* chi2;
    int32_t eLossSign = 0; // energy-loss sign of the TrackParCov propagations: 0 along the track parameters (loss forward), +1 gain, -1 loss
  };
  GPUd() int32_t RefitTrackAsGPU(o2::track::TrackParCov& trk, const o2::tpc::TrackTPCClusRef& clusRef, float time0, float* chi2 = nullptr, bool outward = false, bool resetCov = false)
  {
    TrackParCovWithArgs x{trk, clusRef, time0, chi2};
    return RefitTrack<TrackParCovWithArgs, GPUTPCGMTrackParam>(x, outward, resetCov);
  }
  GPUd() int32_t RefitTrackAsTrackParCov(o2::track::TrackParCov& trk, const o2::tpc::TrackTPCClusRef& clusRef, float time0, float* chi2 = nullptr, bool outward = false, bool resetCov = false, int32_t eLossSign = 0)
  {
    TrackParCovWithArgs x{trk, clusRef, time0, chi2, eLossSign};
    return RefitTrack<TrackParCovWithArgs, o2::track::TrackParCov>(x, outward, resetCov);
  }
 
  bool mIgnoreErrorsOnTrackEnds = true; // Ignore errors during propagation / update at the beginning / end of tracks for int16_t tracks / tracks with high incl. angle
 
 private:
  const uint8_t* mPclusterState = nullptr;                       // Ptr to shared cluster state
  const o2::base::Propagator* mPpropagator = nullptr;            // Ptr to propagator for TrackParCov track model
  const o2::base::MatLayerCylSet* mPmatLUT = nullptr;            // Ptr to material LUT
  const o2::tpc::ClusterNativeAccess* mPclusterNative = nullptr; // Ptr to cluster native access structure
  const GPUTPCGMMergedTrackHit* mPtrackHits = nullptr;           // Ptr to hits for GPUTPCGMMergedTrack tracks
  const uint32_t* mPtrackHitReferences = nullptr;                // Ptr to hits for TrackTPC tracks
  const TPCFastTransformPOD* mPfastTransform = nullptr;          // Ptr to TPC fast transform object helper
  const GPUParam* mPparam = nullptr;                             // Ptr to GPUParam
  template <class T, class S>
  GPUd() int32_t RefitTrack(T& trk, bool outward, bool resetCov);
  template <class T, class S, class U>
  GPUd() void convertTrack(T& trk, const S& trkX, U& prop, float* chi2);
  template <class U>
  GPUd() void initProp(U& prop);
};
 
class GPUTrackingRefitProcessor : public GPUTrackingRefit, public GPUProcessor
{
 public:
#ifndef GPUCA_GPUCODE
  void InitializeProcessor();
  void RegisterMemoryAllocation();
  void SetMaxData(const GPUTrackingInOutPointers& io);
#endif
  GPUTPCGMMergedTrack* mPTracks = nullptr;
};
 
} // namespace o2::gpu
 
#endif