KfTarget.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 "KfMaterialMap.h"
 
#include <boost/serialization/access.hpp>
 
#include <string>
 
namespace cbm::algo::kf
{
  template<typename T>
  class alignas(VcMemAlign) Target {
    template<typename I>
    friend class Target;
 
   public:
    Target() = default;
 
    Target(double x, double y, double z, double dz, double r);
 
    template<typename I>
    Target(const Target<I>& other)
      : fMaterial(other.fMaterial)
      , fX(utils::simd::Cast<I, T>(other.fX))
      , fY(utils::simd::Cast<I, T>(other.fY))
      , fZ(utils::simd::Cast<I, T>(other.fZ))
      , fDz(utils::simd::Cast<I, T>(other.fDz))
      , fR(utils::simd::Cast<I, T>(other.fR))
    {
    }
 
    ~Target() = default;
 
    Target& operator=(const Target& other) = default;
 
    const T& GetX() const { return fX; }
 
    const T& GetY() const { return fY; }
 
    const T& GetZ() const { return fZ; }
 
    const T& GetDz() const { return fDz; }
 
    const T& GetR() const { return fR; }
 
    const MaterialMap& GetMaterial() const { return fMaterial; }
 
    void SetMaterial(const MaterialMap& material);
 
    void SetMaterial(MaterialMap&& material);
 
    void SetX(const T& x) { fX = x; }
 
    void SetY(const T& y) { fY = y; }
 
    void SetZ(const T& z) { fZ = z; }
 
    void SetDz(const T& dz) { fDz = dz; }
 
    void SetR(const T& r) { fR = r; }
 
    std::string ToString(int indentLevel = 0, int vebose = 1) const;
 
   private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fMaterial;
      ar& fX;
      ar& fY;
      ar& fZ;
      ar& fDz;
      ar& fR;
    }
 
    MaterialMap fMaterial{};  
    T fX{defs::Undef<T>};     
    T fY{defs::Undef<T>};     
    T fZ{defs::Undef<T>};     
    T fDz{defs::Undef<T>};    
    T fR{defs::Undef<T>};     
  };
}  // namespace cbm::algo::kf