GPUTPCTrackParam.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 GPUTPCTRACKPARAM_H
#define GPUTPCTRACKPARAM_H
 
#include "GPUTPCBaseTrackParam.h"
#include "GPUTPCDef.h"
#include "GPUCommonMath.h"
 
namespace o2::gpu
{
class GPUTPCTrackLinearisation;
 
class GPUTPCTrackParam
{
 public:
  struct GPUTPCTrackFitParam {
    float bethe, e, theta2, EP2, sigmadE2, k22, k33, k43, k44; // parameters
  };
 
  GPUd() const GPUTPCBaseTrackParam& GetParam() const { return mParam; }
  GPUd() void SetParam(const GPUTPCBaseTrackParam& v) { mParam = v; }
  GPUd() void InitParam();
 
  GPUd() float X() const { return mParam.X(); }
  GPUd() float Y() const { return mParam.Y(); }
  GPUd() float Z() const { return mParam.Z(); }
  GPUd() float SinPhi() const { return mParam.SinPhi(); }
  GPUd() float DzDs() const { return mParam.DzDs(); }
  GPUd() float QPt() const { return mParam.QPt(); }
  GPUd() float ZOffset() const { return mParam.ZOffset(); }
  GPUd() float SignCosPhi() const { return mSignCosPhi; }
  GPUd() float Chi2() const { return mChi2; }
  GPUd() int32_t NDF() const { return mNDF; }
 
  GPUd() float Err2Y() const { return mParam.Err2Y(); }
  GPUd() float Err2Z() const { return mParam.Err2Z(); }
  GPUd() float Err2SinPhi() const { return mParam.Err2SinPhi(); }
  GPUd() float Err2DzDs() const { return mParam.Err2DzDs(); }
  GPUd() float Err2QPt() const { return mParam.Err2QPt(); }
 
  GPUd() float GetX() const { return mParam.GetX(); }
  GPUd() float GetY() const { return mParam.GetY(); }
  GPUd() float GetZ() const { return mParam.GetZ(); }
  GPUd() float GetSinPhi() const { return mParam.GetSinPhi(); }
  GPUd() float GetDzDs() const { return mParam.GetDzDs(); }
  GPUd() float GetQPt() const { return mParam.GetQPt(); }
  GPUd() float GetSignCosPhi() const { return mSignCosPhi; }
  GPUd() float GetChi2() const { return mChi2; }
  GPUd() int32_t GetNDF() const { return mNDF; }
 
  GPUd() float GetKappa(float Bz) const { return mParam.GetKappa(Bz); }
  GPUd() float GetCosPhi() const { return mSignCosPhi * CAMath::Sqrt(1 - SinPhi() * SinPhi()); }
 
  GPUhd() const float* Par() const { return mParam.Par(); }
  GPUhd() const float* Cov() const { return mParam.Cov(); }
 
  GPUd() const float* GetPar() const { return mParam.GetPar(); }
  GPUd() float GetPar(int32_t i) const { return (mParam.GetPar(i)); }
  GPUd() float GetCov(int32_t i) const { return mParam.GetCov(i); }
 
  GPUhd() void SetPar(int32_t i, float v) { mParam.SetPar(i, v); }
  GPUhd() void SetCov(int32_t i, float v) { mParam.SetCov(i, v); }
 
  GPUd() void SetX(float v) { mParam.SetX(v); }
  GPUd() void SetY(float v) { mParam.SetY(v); }
  GPUd() void SetZ(float v) { mParam.SetZ(v); }
  GPUd() void SetSinPhi(float v) { mParam.SetSinPhi(v); }
  GPUd() void SetDzDs(float v) { mParam.SetDzDs(v); }
  GPUd() void SetQPt(float v) { mParam.SetQPt(v); }
  GPUd() void SetZOffset(float v) { mParam.SetZOffset(v); }
  GPUd() void SetSignCosPhi(float v) { mSignCosPhi = v >= 0 ? 1 : -1; }
  GPUd() void SetChi2(float v) { mChi2 = v; }
  GPUd() void SetNDF(int32_t v) { mNDF = v; }
 
  GPUd() float GetDist2(const GPUTPCTrackParam& t) const;
  GPUd() float GetDistXZ2(const GPUTPCTrackParam& t) const;
 
  GPUd() float GetS(float x, float y, float Bz) const;
 
  GPUd() void GetDCAPoint(float x, float y, float z, float& px, float& py, float& pz, float Bz) const;
 
  GPUd() bool TransportToX(float x, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
  GPUd() bool TransportToXWithMaterial(float x, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
  GPUd() bool TransportToX(float x, GPUTPCTrackLinearisation& t0, float Bz, float maxSinPhi = constants::MAX_SIN_PHI, float* DL = nullptr);
 
  GPUd() bool TransportToX(float x, float sinPhi0, float cosPhi0, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
  GPUd() bool TransportToXWithMaterial(float x, GPUTPCTrackLinearisation& t0, GPUTPCTrackFitParam& par, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
  GPUd() bool TransportToXWithMaterial(float x, GPUTPCTrackFitParam& par, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
  GPUd() static float ApproximateBetheBloch(float beta2);
  GPUd() static float BetheBlochGeant(float bg, float kp0 = 2.33f, float kp1 = 0.20f, float kp2 = 3.00f, float kp3 = 173e-9f, float kp4 = 0.49848f);
  GPUd() static float BetheBlochSolid(float bg);
  GPUd() static float BetheBlochGas(float bg);
 
  GPUd() void CalculateFitParameters(GPUTPCTrackFitParam& par, float mass = 0.13957f);
  GPUd() bool CorrectForMeanMaterial(float xOverX0, float xTimesRho, const GPUTPCTrackFitParam& par);
 
  GPUd() bool Rotate(float alpha, float maxSinPhi = constants::MAX_SIN_PHI);
  GPUd() bool Rotate(float alpha, GPUTPCTrackLinearisation& t0, float maxSinPhi = constants::MAX_SIN_PHI);
  GPUd() bool Filter(float y, float z, float err2Y, float err2Z, float maxSinPhi = constants::MAX_SIN_PHI, bool paramOnly = false);
 
  GPUd() bool CheckNumericalQuality() const;
 
  GPUd() void ShiftZ(float z1, float z2, float x1, float x2, float bz, float defaultZOffsetOverR);
  GPUd() void ConstrainZ(float& z, uint32_t sector, float& z0, float& lastZ);
  GPUd() int32_t GetPropagatedYZ(float bz, float x, float& projY, float& projZ) const;
 
  GPUdi() void ConstrainSinPhi(float limit = constants::MAX_SIN_PHI)
  {
    if (GetSinPhi() > limit) {
      SetSinPhi(limit);
    } else if (GetSinPhi() < -limit) {
      SetSinPhi(-limit);
    }
  }
 
  GPUd() void Print() const;
 
#ifndef GPUCA_GPUCODE
 private:
#endif                         
  GPUTPCBaseTrackParam mParam; // Track Parameters
 
 private:
  // WARNING, Track Param Data is copied in the GPU Tracklet Constructor element by element instead of using copy constructor!!!
  // This is neccessary for performance reasons!!!
  // Changes to Elements of this class therefore must also be applied to TrackletConstructor!!!
  float mSignCosPhi; // sign of cosPhi
  float mChi2;       // the chi^2 value
  int32_t mNDF;      // the Number of Degrees of Freedom
};
 
GPUdi() void GPUTPCTrackParam::InitParam()
{
  // Initialize Tracklet Parameters using default values
  SetSinPhi(0);
  SetDzDs(0);
  SetQPt(0);
  SetSignCosPhi(1);
  SetChi2(0);
  SetNDF(-3);
  SetCov(0, 1);
  SetCov(1, 0);
  SetCov(2, 1);
  SetCov(3, 0);
  SetCov(4, 0);
  SetCov(5, 1);
  SetCov(6, 0);
  SetCov(7, 0);
  SetCov(8, 0);
  SetCov(9, 1);
  SetCov(10, 0);
  SetCov(11, 0);
  SetCov(12, 0);
  SetCov(13, 0);
  SetCov(14, 1000.f);
  SetZOffset(0);
}
} // namespace o2::gpu
 
#endif // GPUTPCTRACKPARAM_H