TrackParam.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 O2_MCH_TRACKPARAM_H_
#define O2_MCH_TRACKPARAM_H_
 
#include <memory> // for std::unique_ptr
#include <TMatrixD.h>
 
#include "MCHBase/TrackBlock.h"
 
namespace o2
{
namespace mch
{
 
struct Cluster;
 
class TrackParam
{
 public:
  TrackParam() = default;
  TrackParam(Double_t z, const Double_t param[5]);
  TrackParam(Double_t z, const Double_t param[5], const Double_t cov[15]);
  ~TrackParam() = default;
 
  TrackParam(const TrackParam& tp);
  TrackParam& operator=(const TrackParam& tp);
  TrackParam(TrackParam&&) = delete;
  TrackParam& operator=(TrackParam&&) = delete;
 
  Double_t getZ() const { return mZ; }
  void setZ(Double_t z) { mZ = z; }
  Double_t getNonBendingCoor() const { return mParameters(0, 0); }
  void setNonBendingCoor(Double_t nonBendingCoor) { mParameters(0, 0) = nonBendingCoor; }
  Double_t getNonBendingSlope() const { return mParameters(1, 0); }
  void setNonBendingSlope(Double_t nonBendingSlope) { mParameters(1, 0) = nonBendingSlope; }
  Double_t getBendingCoor() const { return mParameters(2, 0); }
  void setBendingCoor(Double_t bendingCoor) { mParameters(2, 0) = bendingCoor; }
  Double_t getBendingSlope() const { return mParameters(3, 0); }
  void setBendingSlope(Double_t bendingSlope) { mParameters(3, 0) = bendingSlope; }
  Double_t getInverseBendingMomentum() const { return mParameters(4, 0); }
  void setInverseBendingMomentum(Double_t inverseBendingMomentum) { mParameters(4, 0) = inverseBendingMomentum; }
  Double_t getCharge() const { return TMath::Sign(1., mParameters(4, 0)); }
  void setCharge(Double_t charge)
  {
    if (charge * mParameters(4, 0) < 0.) {
      mParameters(4, 0) *= -1.;
    }
  }
 
  const TMatrixD& getParameters() const { return mParameters; }
  void setParameters(const TMatrixD& parameters) { mParameters = parameters; }
  void setParameters(const Double_t parameters[5]) { mParameters.SetMatrixArray(parameters); }
  void addParameters(const TMatrixD& parameters) { mParameters += parameters; }
 
  Double_t px() const; // return px
  Double_t py() const; // return py
  Double_t pz() const; // return pz
  Double_t p() const;  // return total momentum
 
  Bool_t hasCovariances() const { return (mCovariances) ? kTRUE : kFALSE; }
 
  const TMatrixD& getCovariances() const;
  void setCovariances(const TMatrixD& covariances);
  void setCovariances(const Double_t covariances[15]);
  void setVariances(const Double_t covariances[15]);
  void deleteCovariances();
 
  const TMatrixD& getPropagator() const;
  void resetPropagator();
  void updatePropagator(const TMatrixD& propagator);
 
  const TMatrixD& getExtrapParameters() const;
  void setExtrapParameters(const TMatrixD& parameters);
 
  const TMatrixD& getExtrapCovariances() const;
  void setExtrapCovariances(const TMatrixD& covariances);
 
  const TMatrixD& getSmoothParameters() const;
  void setSmoothParameters(const TMatrixD& parameters);
 
  const TMatrixD& getSmoothCovariances() const;
  void setSmoothCovariances(const TMatrixD& covariances);
 
  const Cluster* getClusterPtr() const { return mClusterPtr; }
  void setClusterPtr(const Cluster* cluster) { mClusterPtr = cluster; }
 
  Bool_t isRemovable() const { return mRemovable; }
  void setRemovable(Bool_t removable) { mRemovable = removable; }
 
  Double_t getTrackChi2() const { return mTrackChi2; }
  void setTrackChi2(Double_t chi2) { mTrackChi2 = chi2; }
  Double_t getLocalChi2() const { return mLocalChi2; }
  void setLocalChi2(Double_t chi2) { mLocalChi2 = chi2; }
 
  TrackParamStruct getTrackParamStruct() const;
 
  Bool_t isCompatibleTrackParam(const TrackParam& trackParam, Double_t sigma2Cut, Double_t& normChi2) const;
 
  void print() const;
 
  void clear();
 
 private:
  Double_t mZ = 0.; 
 
  TMatrixD mParameters{5, 1}; 
 
  mutable std::unique_ptr<TMatrixD> mCovariances{}; 
 
  mutable std::unique_ptr<TMatrixD> mPropagator{};
  mutable std::unique_ptr<TMatrixD> mExtrapParameters{};
  mutable std::unique_ptr<TMatrixD> mExtrapCovariances{};
 
  mutable std::unique_ptr<TMatrixD> mSmoothParameters{};  
  mutable std::unique_ptr<TMatrixD> mSmoothCovariances{}; 
 
  const Cluster* mClusterPtr = nullptr; 
 
  Bool_t mRemovable = false; 
 
  Double_t mTrackChi2 = 0.; 
  Double_t mLocalChi2 = 0.; 
};
 
} // namespace mch
} // namespace o2
 
#endif // O2_MCH_TRACKPARAM_H_