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), fZref);
    }

    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