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 "KfTrajectory.h"
 
#include <vector>
 
class CbmMvdHit;
class CbmStsHit;
class CbmStsTrack;
class CbmGlobalTrack;
class CbmKFVertex;
class CbmMuchPixelHit;
class CbmTrdHit;
class CbmTofHit;
 
class FairTrackParam;
class TClonesArray;
 

template<cbm::algo::kf::DoFitTime FlagFitTime = cbm::algo::kf::DoFitTime::Y>
class CbmKfTrackFitter {
 
 public:
  class Trajectory : public cbm::algo::kf::Trajectory<double> {
   public:
    using cbm::algo::kf::Trajectory<double>::Trajectory;
 
    static ECbmModuleId GetHitSystemId(const Node& node) { return static_cast<ECbmModuleId>(node.userReferences[0]); }
 
    static int GetHitAddress(const Node& node) { return node.userReferences[1]; }
 
    static int GetHitIndex(const Node& node) { return node.userReferences[2]; }
 
    static void SetHitSystemId(Node& node, ECbmModuleId sysId) { node.userReferences[0] = static_cast<int>(sysId); }
 
    static void SetHitAddress(Node& node, int address) { node.userReferences[1] = address; }
 
    static void SetHitIndex(Node& node, int index) { node.userReferences[2] = index; }
 
    void SetHitSystemId(size_t nodeIndex, ECbmModuleId sysId) { SetHitSystemId(fNodes[nodeIndex], sysId); }
 
    void SetHitAddress(size_t nodeIndex, int address) { SetHitAddress(fNodes[nodeIndex], address); }
 
    void SetHitIndex(size_t nodeIndex, int index) { SetHitIndex(fNodes[nodeIndex], index); }
  };
 
 public:
  CbmKfTrackFitter();
  ~CbmKfTrackFitter();

  void Init();

  void SetParticleHypothesis(int pid);

  void SetMassHypothesis(double mass);

  void SetElectronFlag(bool isElectron);

  void SetIgnorePoorCoordinates(bool ignore = true) { fIgnorePoorCoordinates = ignore; }

  void SetDefaultMomentumForMs(double p) { fDefaultQpForMs = fabs(1. / p); }

  void SetDefaultInverseMomentumForMs(double invP) { fDefaultQpForMs = fabs(invP); }

  void SetEnforceDefaultMomentumForMs(bool enforce = true) { fEnforceDefaultMomentumForMs = enforce; }

  void SetIgnoreMultipleScattering(bool ignore = true) { fIgnoreMultipleScattering = ignore; }

  void SetIgnoreEnergyLosses(bool ignore = true) { fIgnoreEnergyLosses = ignore; }

  bool CreateFromMvdStsTrack(Trajectory& trajectory, int stsTrackIndex, bool addMaterialNodesOutsideHitRange);

  bool CreateFromGlobalTrack(Trajectory& trajectory, int globalTrackIndex, bool addMaterialNodesOutsideHitRange);

  bool CreateFromGlobalTrack(Trajectory& trajectory, const CbmGlobalTrack& globalTrack,
                             bool addMaterialNodesOutsideHitRange);

  bool FitTrajectory(cbm::algo::kf::Trajectory<double>& t);

  bool FitTrajectoryUpstream(const cbm::algo::kf::Trajectory<double>& t, cbm::algo::kf::TrackParamD& parUp);

  bool FitTrajectoryDownstream(const cbm::algo::kf::Trajectory<double>& t, cbm::algo::kf::TrackParamD& parDn);

  bool PropagateToZ(cbm::algo::kf::TrackParamD& track, double z);

  void SetNofIterations(int nofIterations) { fNofIterations = nofIterations; }

  void SetVerbosityLevel(int level) { fVerbosityLevel = level; }

  void SetDebugPrefix(const std::string& pref) { fDebugPrefix = pref + ": "; }

  void SetMaxExtrapolationStep(double step) { fFit.SetMaxExtrapolationStep(step); }

  double GetMaxExtrapolationStep() const { return fFit.GetMaxExtrapolationStep(); }

  void SetFixMaterial(bool isFixed) { fIsMaterialFixed = isFixed; }
 
 private:
  struct LinearizationAtNode {
    cbm::algo::kf::LinearizationFull<double> linearizationUp{};  
    cbm::algo::kf::LinearizationFull<double> linearizationDn{};  
    double radThick{0.};  
  };
 
  void FilterFirstMeasurement(const cbm::algo::kf::Trajectory<double>::Node& n);
 
  void AddMaterialEffects(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
  const TClonesArray* fInputMvdHits{nullptr};
  const TClonesArray* fInputStsHits{nullptr};
  const TClonesArray* fInputMuchHits{nullptr};
  const TClonesArray* fInputTrdHits{nullptr};
  const TClonesArray* fInputTofHits{nullptr};
 
  const TClonesArray* fInputGlobalTracks{nullptr};
  const TClonesArray* fInputStsTracks{nullptr};
  const TClonesArray* fInputMuchTracks{nullptr};
  const TClonesArray* fInputTrdTracks{nullptr};
  const TClonesArray* fInputTofTracks{nullptr};
 
  //
 
  bool fIsInitialized = {false};  
 
  bool fIgnorePoorCoordinates{false};  
 
  cbm::algo::kf::TrackKalmanFilter<double, cbm::algo::kf::FilterSettings<cbm::algo::kf::LinearizationFull, FlagFitTime>>
    fFit;  // track fit object

  double fDefaultQpForMs{1. / 0.1};
 
  bool fEnforceDefaultMomentumForMs{false};  
 
  bool fIgnoreMultipleScattering{false};  
 
  bool fIgnoreEnergyLosses{false};  
 
  bool fIsMaterialFixed{
    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)
  int fNofIterations{2};                                // number of iterations for the fit
 
  int fVerbosityLevel{0};      // verbosity level
  std::string fDebugPrefix{};  // debug info
 
  //ClassDefNV(CbmKfTrackFitter, 0);
};