KfFieldValue.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 "KfMath.h"
#include "KfUtils.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/array.hpp>
 
#include <array>
#include <functional>
#include <string>
#include <tuple>
 
namespace cbm::algo::kf
{

  template<typename T>
  class alignas(VcMemAlign) FieldValue {
    template<typename>
    friend class FieldValue;
 
   public:
    FieldValue() = default;

    template<typename I>
    FieldValue(const I& bx, const I& by, const I& bz, const I& z)
      : fB({utils::simd::Cast<I, T>(bx), utils::simd::Cast<I, T>(by), utils::simd::Cast<I, T>(bz)})
      , fZ(utils::simd::Cast<I, T>(z))
    {
    }

    template<typename I>
    FieldValue(const FieldValue<I>& other)
      : fB(utils::simd::Cast<I, T, 3>(other.fB))
      , fZ(utils::simd::Cast<I, T>(other.fZ))
    {
    }

    ~FieldValue() = default;

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

    template<typename I>
    void Set(const I& bx, const I& by, const I& bz, const I& z)
    {
      fB[0] = utils::simd::Cast<I, T>(bx);
      fB[1] = utils::simd::Cast<I, T>(by);
      fB[2] = utils::simd::Cast<I, T>(bz);
      fZ    = utils::simd::Cast<I, T>(z);
    }

    void SetSimdEntries(const FieldValue& other, const kf::utils::masktype<T>& mask)
    {
      for (size_t iD = 0; iD < fB.size(); ++iD) {
        this->fB[iD] = kf::utils::iif(mask, other.fB[iD], this->fB[iD]);
      }
      this->fZ = kf::utils::iif(mask, other.fZ, this->fZ);
    }

    [[gnu::always_inline]] std::tuple<T, T, T> Get() const { return std::make_tuple(fB[0], fB[1], fB[2]); }

    [[gnu::always_inline]] T GetAbsSq() const { return fB[0] * fB[0] + fB[1] * fB[1] + fB[2] * fB[2]; }

    [[gnu::always_inline]] T GetAbs() const { return std::sqrt(this->GetAbsSq()); }

    [[gnu::always_inline]] T GetComponent(int iD) const { return fB[iD]; }

    [[gnu::always_inline]] T GetBx() const { return fB[0]; }

    [[gnu::always_inline]] T GetBy() const { return fB[1]; }

    [[gnu::always_inline]] T GetBz() const { return fB[2]; }

    [[gnu::always_inline]] T GetZ() const { return fZ; }

    [[gnu::always_inline]] bool IsZero() const
    {
      auto bZero = this->GetAbsSq() <= defs::MinField<T> * defs::MinField<T>;
      if constexpr (std::is_same_v<T, fvec>) {
        return bZero.isFull();
      }
      else {
        return bZero;
      }
    }

    void CheckConsistency() const;
 
    // TODO (?): Provide setters/accessors

    [[gnu::always_inline]] void SetSimdEntry(double bx, double by, double bz, double z, size_t i)
    {
      utils::simd::SetEntry(fB[0], bx, i);  //B.x[i] = bx;
      utils::simd::SetEntry(fB[1], by, i);  //B.y[i] = by;
      utils::simd::SetEntry(fB[2], bz, i);  //B.z[i] = bz;
      utils::simd::SetEntry(fZ, z, i);
    }

    std::string ToString(int indentLevel = 0) const;
 
   private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& fB;
      ar& fZ;
    }

    GeoVector_t<T> fB{
      {utils::simd::Cast<float, T>(0.F), utils::simd::Cast<float, T>(0.F), utils::simd::Cast<float, T>(0.F)}};
    T fZ{};  
  };
 
}  // namespace cbm::algo::kf