KfActiveLayer.h

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
 
#pragma once
 
#include "KfUtils.h"
 
#include <boost/serialization/access.hpp>
 
#include <string>
 
namespace cbm::algo::kf
{
  template<typename F>
  class alignas(VcMemAlign) ActiveLayer {
    template<typename>
    friend class ActiveLayer;
    friend class boost::serialization::access;
 
   public:
    ActiveLayer(F zRef, F xMin, F xMax, F yMin, F yMax, EFieldType fieldType, bool isTimeMeasured);

    template<typename FSrc>
    ActiveLayer(const ActiveLayer<FSrc>& other)
      : fZref(utils::simd::Cast<FSrc, F>(other.fZref))
      , fXmin(utils::simd::Cast<FSrc, F>(other.fXmin))
      , fXmax(utils::simd::Cast<FSrc, F>(other.fXmax))
      , fYmin(utils::simd::Cast<FSrc, F>(other.fYmin))
      , fYmax(utils::simd::Cast<FSrc, F>(other.fYmax))
      , fFieldType(other.fFieldType)
      , fTimeInfo(other.fTimeInfo)
    {
    }

    ActiveLayer(const ActiveLayer&) = default;

    ActiveLayer(ActiveLayer&&) = default;

    ActiveLayer& operator=(const ActiveLayer&) = default;

    ActiveLayer& operator=(ActiveLayer&&) = default;

    F GetZref() const { return fZref; }

    F GetXmin() const { return fXmin; }

    F GetXmax() const { return fXmax; }

    F GetYmin() const { return fYmin; }

    F GetYmax() const { return fYmax; }

    EFieldType GetFieldType() const { return fFieldType; }

    bool IsInField() const { return fFieldType != EFieldType::Null; }

    bool IsTimeMeasured() const { return fTimeInfo; }

    std::string ToString(int indentLevel = 0) const;
 
   private:
    F fZref{defs::Undef<F>};                  
    F fXmin{defs::Undef<F>};                  
    F fXmax{defs::Undef<F>};                  
    F fYmin{defs::Undef<F>};                  
    F fYmax{defs::Undef<F>};                  
    EFieldType fFieldType{EFieldType::Null};  
    bool fTimeInfo{false};                    

    ActiveLayer() = default;

    template<class Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& fZref;
      ar& fXmin;
      ar& fXmax;
      ar& fYmin;
      ar& fYmax;
      ar& fFieldType;
      ar& fTimeInfo;
    }
  };
}  // namespace cbm::algo::kf