KfTrajectory.h

Go to the documentation of this file.

/* Copyright (C) 2007-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov [committer] */
 

 
#ifndef KF_CORE_KfTrajectory_h
#define KF_CORE_KfTrajectory_h 1
 
#include "KfDefs.h"
#include "KfMeasurementTime.h"
#include "KfMeasurementXy.h"
#include "KfSetup.h"
#include "KfSimd.h"
#include "KfTrackParam.h"
 
template<cbm::algo::kf::DoFitTime>
class CbmKfTrackFitter;
 
class CbmBbaAlignTask;
class CbmBbaAlignmentMcbmTask;
 
namespace cbm::algo::kf
{
  template<typename T = double>
  class alignas(VcMemAlign) Trajectory {
 
   public:
    template<cbm::algo::kf::DoFitTime>
    friend class ::CbmKfTrackFitter;
 
    friend class ::CbmBbaAlignTask;
    friend class ::CbmBbaAlignmentMcbmTask;
 

    struct alignas(VcMemAlign) Node {
 
 
      T z{0.};  
 
      TrackParam<T> paramUp{};  
      TrackParam<T> paramDn{};  

 
      int materialLayer{-1};  

      T radThick{0.};

 
      MeasurementXy<T> measurementXY{};      
      MeasurementTime<T> measurementTime{};  

 
      bool isXySet{false};    
      bool isTimeSet{false};  
      bool isFitted{false};   

      std::array<int, 10> userReferences{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}};
 
     public:
      bool operator<(const Node& other) const
      {
        if (materialLayer >= 0 && other.materialLayer >= 0 && materialLayer != other.materialLayer) {
          return materialLayer < other.materialLayer;
        }
        return z < other.z;
      }
 
    };  // struct Node
 

    Trajectory() = default;

    Trajectory(std::shared_ptr<const Setup<T>> kfSetup) : fKfSetup(kfSetup) {}

    ~Trajectory() = default;

    Trajectory(const Trajectory& other) = default;

    Trajectory& operator=(const Trajectory& other) = default;

    Trajectory(Trajectory&& other) noexcept = default;

    Trajectory& operator=(Trajectory&& other) noexcept = default;

    void SetKfSetup(std::shared_ptr<const Setup<T>> kfSetup) { fKfSetup = kfSetup; }

    size_t GetNofNodes() const { return fNodes.size(); }

    const Node& GetNode(const size_t index) const { return fNodes[index]; }

    const std::vector<Node>& GetNodes() const { return fNodes; }

    const std::array<int, 10>& GetNodeUserReferences(const size_t index) const { return fNodes[index].userReferences; }

    std::array<int, 10>& GetNodeUserReferences(const size_t index) { return fNodes[index].userReferences; }

    int GetFirstMeasurementNodeId() const { return fFirstMeasurementNodeId; }

    int GetLastMeasurementNodeId() const { return fLastMeasurementNodeId; }

    const Node& GetFirstMeasurementNode() const
    {
      assert(fFirstMeasurementNodeId >= 0 && fFirstMeasurementNodeId < static_cast<int>(fNodes.size()));
      return fNodes[fFirstMeasurementNodeId];
    }

    const Node& GetLastMeasurementNode() const
    {
      assert(fLastMeasurementNodeId >= 0 && fLastMeasurementNodeId < static_cast<int>(fNodes.size()));
      return fNodes[fLastMeasurementNodeId];
    }

    int GetNofMeasurements() const { return fNmeasurements; }

    bool IsFitted() const { return fIsFitted; }

    bool IsFullyExtrapolated() const { return fIsFullyExtrapolated; }

    double GetQaChi2Downstream() const { return fQaChi2Downstream; }

    void Clear()
    {
      fNodes.clear();
      fIsFitted               = false;
      fIsFullyExtrapolated    = false;
      fFirstMeasurementNodeId = -1;
      fLastMeasurementNodeId  = -1;
      fNmeasurements          = -1;
      fQaChi2Downstream       = -1.;
    }

    void AddNode(const Node& node)
    {
      fNodes.push_back(node);
      MakeConsistent();
    }

    void AddNodes(const std::vector<Node>& nodes)
    {
      fNodes.reserve(fNodes.size() + nodes.size());
      for (const auto& n : nodes) {
        fNodes.push_back(n);
      }
      MakeConsistent();
    }

    void DisableMeasurementAtNode(const size_t index)
    {
      if (index >= fNodes.size()) {
        LOG(fatal) << "KfTrajectory::DisableMeasurementAtNode: index " << index << " is out of range!";
      }
      fNodes[index].isXySet   = false;
      fNodes[index].isTimeSet = false;
      fNmeasurements--;
      if (index == static_cast<size_t>(fFirstMeasurementNodeId)) {
        fFirstMeasurementNodeId = -1;
        for (size_t i = index + 1; i < fNodes.size(); ++i) {
          if (fNodes[i].isXySet) {
            fFirstMeasurementNodeId = i;
            break;
          }
        }
      }
      if (index == static_cast<size_t>(fLastMeasurementNodeId)) {
        fLastMeasurementNodeId = -1;
        for (int i = static_cast<int>(index) - 1; i >= 0; --i) {
          if (fNodes[i].isXySet) {
            fLastMeasurementNodeId = i;
            break;
          }
        }
      }
    }

    void ModifyNode(const size_t index, const Node& node)
    {
      fNodes[index] = node;
      MakeConsistent();
    }
 
   protected:
    void MakeConsistent();

    Node& GetNodeReference(const size_t index) { return fNodes[index]; }
 
   protected:
    std::shared_ptr<const Setup<T>> fKfSetup{};  
 
    std::vector<Node> fNodes{};  
 
    int fFirstMeasurementNodeId{-1};  
    int fLastMeasurementNodeId{-1};   
    int fNmeasurements{-1};           
 
    bool fIsFitted{
      false};  
 
    bool fIsFullyExtrapolated{
      false};  
 
    T fQaChi2Downstream{-1.};  
  };
 
}  // namespace cbm::algo::kf
 
#endif  // KF_CORE_KfTrajectory_h