CbmKfTrackFitter.h

Go to the documentation of this file.

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov [committer] */
 
#pragma once  // include this header only once per compilation unit
 
 
#include "CbmDefs.h"
#include "KfDefs.h"
#include "KfMeasurementTime.h"
#include "KfMeasurementXy.h"
#include "KfSetup.h"
#include "KfTrackKalmanFilter.h"
#include "KfTrackParam.h"
 
#include <vector>
 
class CbmMvdHit;
class CbmStsHit;
class CbmStsTrack;
class CbmGlobalTrack;
class CbmKFVertex;
class CbmMuchPixelHit;
class CbmTrdHit;
class CbmTofHit;
 
class FairTrackParam;
class TClonesArray;
 
 
class CbmKfTrackFitter {
 
 public:
  struct TrajectoryNode {
 
    double fZ{0.};  
 
    cbm::algo::kf::TrackParamD fParamUp{};  
    cbm::algo::kf::TrackParamD fParamDn{};  
 
 
    // TODO: change to the material layer index when the material layer is implemented
    int fMaterialLayer{-1};  
 
    double fRadThick{0.};
 
 
    cbm::algo::kf::MeasurementXy<double> fMxy{};  
 
    cbm::algo::kf::MeasurementTime<double> fMt{};  
 
    bool fIsXySet{false};          
    bool fIsTimeSet{false};        
    bool fIsRadThickFixed{false};  
    bool fIsFitted{false};         
 
    ECbmModuleId fHitSystemId{ECbmModuleId::kNotExist};  
    int fHitAddress{-1};                                 
    int fHitIndex{-1};                                   
 
    int fReference1{-1};  
    int fReference2{-1};  
  };
 
  // TODO: proper interface
  struct Trajectory {
    std::vector<TrajectoryNode> fNodes;  
    bool fIsFitted{false};               
    void OrderNodesInZ();                // sort the nodes in Z and set fFirstHitNode and fLastHitNode
  };
 
  CbmKfTrackFitter();
  ~CbmKfTrackFitter();
 
  void Init();
 
  void SetParticleHypothesis(int pid);
 
  void SetMassHypothesis(double mass);
 
  void SetElectronFlag(bool isElectron);
 
  void SetSkipUnmeasuredCoordinates(bool skip = true) { fSkipUnmeasuredCoordinates = skip; }
 
  void SetDefaultMomentumForMs(double p) { fDefaultQpForMs = fabs(1. / p); }
 
  void SetDefaultInverseMomentumForMs(double invP) { fDefaultQpForMs = fabs(invP); }
 
  void SetNoMultipleScattering() { fDefaultQpForMs = 0.; }
 
  void FixMomentumForMs(bool fix = true) { fIsQpForMsFixed = fix; }
 
  bool CreateMvdStsTrack(Trajectory& kfTrack, int stsTrackIndex);
  bool CreateGlobalTrack(Trajectory& kfTrack, int globalTrackIndex);
  bool CreateGlobalTrack(Trajectory& kfTrack, const CbmGlobalTrack& globalTrack);
 
  bool FitTrajectory(CbmKfTrackFitter::Trajectory& t);
 
  void SetDoSmooth(bool doSmooth) { fDoSmooth = doSmooth; }
 
  void SetVerbosityLevel(int level) { fVerbosityLevel = level; }
 
  void SetDebugInfo(const std::string& info) { fDebugInfo = info; }
 
 private:
  struct LinearizationAtNode {
    cbm::algo::kf::TrackParamD fParamUp{};  
    cbm::algo::kf::TrackParamD fParamDn{};  
  };
 
  void FilterFirstMeasurement(const TrajectoryNode& n);
 
  void AddMaterialEffects(TrajectoryNode& n, const LinearizationAtNode& l, cbm::algo::kf::FitDirection direction);
 
  // combine two tracks
  bool Smooth(cbm::algo::kf::TrackParamD& t1, const cbm::algo::kf::TrackParamD& t2);
 
 private:
  std::shared_ptr<const cbm::algo::kf::Setup<double>> fKfSetup;
 
  // input data arrays
  TClonesArray* fInputMvdHits{nullptr};
  TClonesArray* fInputStsHits{nullptr};
  TClonesArray* fInputMuchHits{nullptr};
  TClonesArray* fInputTrdHits{nullptr};
  TClonesArray* fInputTofHits{nullptr};
 
  TClonesArray* fInputGlobalTracks{nullptr};
  TClonesArray* fInputStsTracks{nullptr};
  TClonesArray* fInputMuchTracks{nullptr};
  TClonesArray* fInputTrdTracks{nullptr};
  TClonesArray* fInputTofTracks{nullptr};
 
  //
 
  bool fIsInitialized = {false};  // is the fitter initialized
  bool fSkipUnmeasuredCoordinates{false};
  cbm::algo::kf::TrackKalmanFilter<double> fFit;  // track fit object
 
  double fDefaultQpForMs{1. / 0.1};
  bool fIsQpForMsFixed{false};
 
  double fMass{cbm::algo::kf::defs::PionMass<double>};  // mass hypothesis for the fit
  bool fIsElectron{false};                              // fit track as an electron (with the bermsstrallung effect)
  bool fDoSmooth{true};                                 // do the KF-smoothing to define track pars at all the nodes
  int fVerbosityLevel{0};                               // verbosity level
  std::string fDebugInfo{};                             // debug info
};