KfDefs.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] */

 
#ifndef KF_CORE_KfDefs_h
#define KF_CORE_KfDefs_h 1
 
#include "KfSimd.h"
 
#include <array>
#include <functional>
#include <limits>
#include <tuple>
 
namespace cbm::algo::kf
{
  // ---- Tag dispatching ------------------------------------------------------------------------------------------------

  template<auto...>
  struct Tag {
  };
 
  static constexpr Tag<0, 0> Tag00 = {};  
  static constexpr Tag<0, 1> Tag01 = {};  
  static constexpr Tag<0, 2> Tag02 = {};  
  static constexpr Tag<0, 3> Tag03 = {};  
  static constexpr Tag<0, 4> Tag04 = {};  
  static constexpr Tag<0, 5> Tag05 = {};  
  static constexpr Tag<0, 6> Tag06 = {};  
  static constexpr Tag<0, 7> Tag07 = {};  
 
  static constexpr Tag<1, 0> Tag10 = {};  
  static constexpr Tag<1, 1> Tag11 = {};  
  static constexpr Tag<1, 2> Tag12 = {};  
  static constexpr Tag<1, 3> Tag13 = {};  
  static constexpr Tag<1, 4> Tag14 = {};  
  static constexpr Tag<1, 5> Tag15 = {};  
  static constexpr Tag<1, 6> Tag16 = {};  
  static constexpr Tag<1, 7> Tag17 = {};  
 
  static constexpr Tag<2, 0> Tag20 = {};  
  static constexpr Tag<2, 1> Tag21 = {};  
  static constexpr Tag<2, 2> Tag22 = {};  
  static constexpr Tag<2, 3> Tag23 = {};  
  static constexpr Tag<2, 4> Tag24 = {};  
  static constexpr Tag<2, 5> Tag25 = {};  
  static constexpr Tag<2, 6> Tag26 = {};  
  static constexpr Tag<2, 7> Tag27 = {};  
 
  static constexpr Tag<3, 0> Tag30 = {};  
  static constexpr Tag<3, 1> Tag31 = {};  
  static constexpr Tag<3, 2> Tag32 = {};  
  static constexpr Tag<3, 3> Tag33 = {};  
  static constexpr Tag<3, 4> Tag34 = {};  
  static constexpr Tag<3, 5> Tag35 = {};  
  static constexpr Tag<3, 6> Tag36 = {};  
  static constexpr Tag<3, 7> Tag37 = {};  
 
  static constexpr Tag<4, 0> Tag40 = {};  
  static constexpr Tag<4, 1> Tag41 = {};  
  static constexpr Tag<4, 2> Tag42 = {};  
  static constexpr Tag<4, 3> Tag43 = {};  
  static constexpr Tag<4, 4> Tag44 = {};  
  static constexpr Tag<4, 5> Tag45 = {};  
  static constexpr Tag<4, 6> Tag46 = {};  
  static constexpr Tag<4, 7> Tag47 = {};  
 
  static constexpr Tag<5, 0> Tag50 = {};  
  static constexpr Tag<5, 1> Tag51 = {};  
  static constexpr Tag<5, 2> Tag52 = {};  
  static constexpr Tag<5, 3> Tag53 = {};  
  static constexpr Tag<5, 4> Tag54 = {};  
  static constexpr Tag<5, 5> Tag55 = {};  
  static constexpr Tag<5, 6> Tag56 = {};  
  static constexpr Tag<5, 7> Tag57 = {};  
 
  static constexpr Tag<6, 0> Tag60 = {};  
  static constexpr Tag<6, 1> Tag61 = {};  
  static constexpr Tag<6, 2> Tag62 = {};  
  static constexpr Tag<6, 3> Tag63 = {};  
  static constexpr Tag<6, 4> Tag64 = {};  
  static constexpr Tag<6, 5> Tag65 = {};  
  static constexpr Tag<6, 6> Tag66 = {};  
  static constexpr Tag<6, 7> Tag67 = {};  
 
  static constexpr Tag<7, 0> Tag70 = {};  
  static constexpr Tag<7, 1> Tag71 = {};  
  static constexpr Tag<7, 2> Tag72 = {};  
  static constexpr Tag<7, 3> Tag73 = {};  
  static constexpr Tag<7, 4> Tag74 = {};  
  static constexpr Tag<7, 5> Tag75 = {};  
  static constexpr Tag<7, 6> Tag76 = {};  
  static constexpr Tag<7, 7> Tag77 = {};  
 
  // ---- Enumerations -------------------------------------------------------------------------------------------------
  //
  enum class EFieldMode
  {
    Interpolated,  
    Original       
  };

  template<typename Float>
  struct FloatTag {
    using Float_t = Float;
  };

  // TODO: SZh 21.08.2024: Develop the concept of field types at different setup regions. At the moment the only
  //                       two global options are available.
  enum class EFieldType
  {
    Normal,  
    Null     
  };
 
  enum class DoFitTime
  {
    N = false,  
    Y = true    
  };
 
  enum class DoPrintDebug
  {
    N = false,  
    Y = true    
  };
 
  // ---- Type traits --------------------------------------------------------------------------------------------------

  template<typename T>
  struct Literal {
    using type = T;
  };
 
  template<>
  struct Literal<fvec> {
    using type = fscal;
  };
 
  template<typename T>
  using Literal_t = typename Literal<T>::type;
 
 
  // ---- Common data types --------------------------------------------------------------------------------------------
  //
  template<class T>
  using GeoVector_t = std::array<T, 3>;

  using FieldFn_t = std::function<std::tuple<double, double, double>(double, double, double)>;
}  // namespace cbm::algo::kf
 
namespace cbm::algo::kf::defs
{
  // ----- Array sizes -------------------------------------------------------------------------------------------------
  //constexpr int MaxNofFieldSlices    = 64;  ///< Max number of field slices
  //constexpr int MaxNofMaterialLayers = 32;  ///< Max number of the material layers
  // NOTE: max uint8_t is assumed in order to satisfy fles::Subsystem
  constexpr int MaxNofDetSubsystems = 256;  
  constexpr int MaxNofDetComponents = 128;  
 
  // ----- Control -----------------------------------------------------------------------------------------------------
  constexpr int DebugLvl     = 0;     
  constexpr bool GetterCheck = true;  
 
 
  // ----- Math --------------------------------------------------------------------------------------------------------
  template<class T = double>
  constexpr auto Pi = Literal_t<T>(3.14159265358979323846L);  
 
  // ----- Physics -----------------------------------------------------------------------------------------------------
  template<class T = double>
  constexpr auto MuonMass = Literal_t<T>(0.105658375523L);  
 
  template<class T = double>
  constexpr auto PionMass = Literal_t<T>(0.1395703918L);  
 
  template<class T = double>
  constexpr auto KaonMass = Literal_t<T>(0.493677L);  
 
  template<class T = double>
  constexpr auto ElectronMass = Literal_t<T>(0.0005109989500015L);  
 
  template<class T = double>
  constexpr auto ProtonMass = Literal_t<T>(0.93827208816L);  
 
  template<class T = double>
  constexpr auto SpeedOfLight = Literal_t<T>(29.9792458L);  
 
  template<class T = double>
  constexpr auto SpeedOfLightInv = Literal_t<T>(1.L) / SpeedOfLight<T>;  
 
  template<class T = double>
  constexpr auto MinField = Literal_t<T>(1.e-4L);  
 
  // ----- Undefined values --------------------------------------------------------------------------------------------
  template<typename T1, typename T2 = T1>
  constexpr T2 Undef;
 
  template<>
  inline constexpr int Undef<int> = std::numeric_limits<int>::min();
 
  template<>
  inline constexpr unsigned Undef<unsigned> = std::numeric_limits<unsigned>::max();
 
  template<>
  inline constexpr float Undef<float> = std::numeric_limits<float>::signaling_NaN();
 
  template<>
  inline constexpr double Undef<double> = std::numeric_limits<double>::signaling_NaN();
 
  template<>
  inline constexpr fscal Undef<fvec> = std::numeric_limits<fscal>::signaling_NaN();
 
  // ----- Other -------------------------------------------------------------------------------------------------------
  constexpr auto ZeroFieldFn = [](double, double, double) constexpr { return std::make_tuple(0., 0., 0.); };
 
  // ----- Debug flags (NOTE: to be modified only by the experts) ------------------------------------------------------
  //
  namespace dbg
  {
  }  // namespace dbg
}  // namespace cbm::algo::kf::defs
 
#endif  // KF_CORE_KfDefs_h