KfFieldSlice.h

Go to the documentation of this file.

/* Copyright (C) 2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */
 
 
#pragma once
 
#include "KfDefs.h"
#include "KfFieldValue.h"
#include "KfMath.h"
#include "KfTrackParam.h"
#include "KfUtils.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/array.hpp>
 
#include <array>
#include <functional>
#include <string>
 
namespace cbm::algo::kf
{
  template<typename T>
  class alignas(VcMemAlign) FieldSlice {
    template<typename>
    friend class FieldSlice;
 
    static constexpr int kPolDegree{5};                                         
    static constexpr int kNofCoeff{((kPolDegree + 1) * (kPolDegree + 2)) / 2};  
 
    using CoeffArray_t = std::array<T, kNofCoeff>;
 
   public:
    FieldSlice() = default;
 
    FieldSlice(const FieldFn_t& fieldFn, double xMax, double yMax, double zRef);
 
    template<typename I>
    FieldSlice(const FieldSlice<I>& other)
      : fBx(utils::simd::Cast<I, T, kNofCoeff>(other.fBx))
      , fBy(utils::simd::Cast<I, T, kNofCoeff>(other.fBy))
      , fBz(utils::simd::Cast<I, T, kNofCoeff>(other.fBz))
      , fZref(utils::simd::Cast<I, T>(other.fZref))
    {
    }
 
    ~FieldSlice() = default;
 
    FieldSlice& operator=(const FieldSlice& other) = default;
 
    constexpr FieldValue<T> GetFieldValue(const T& x, const T& y) const
    {
      using math::Horner;
      return FieldValue<T>(Horner<kPolDegree>(fBx.cbegin(), x, y),  //
                           Horner<kPolDegree>(fBy.cbegin(), x, y),  //
                           Horner<kPolDegree>(fBz.cbegin(), x, y));
    }
 
    constexpr FieldValue<T> GetFieldValueForLine(const TrackParam<T>& trkPar) const
    {
      T dz = fZref - trkPar.GetZ();
      return GetFieldValue(trkPar.GetX() + trkPar.GetTx() * dz, trkPar.GetY() + trkPar.GetTy() * dz);
    }
 
    const T& GetZref() const { return fZref; }
 
    std::string ToString(int indentLevel = 0, int verbose = 1) const;
 
    void CheckConsistency() const;
 
   private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& fBx;
      ar& fBy;
      ar& fBz;
      ar& fZref;
    }
 
    CoeffArray_t fBx{{T(0.)}};  
    CoeffArray_t fBy{{T(0.)}};  
    CoeffArray_t fBz{{T(0.)}};  
    T fZref{defs::Undef<T>};    
  };
}  // namespace cbm::algo::kf