ParameterTraits.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file ParameterTraits.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2020 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Utilities/ParameterDefinitions.hpp"

#include <algorithm>
#include <cmath>

namespace Acts {
namespace detail {

struct UnrestrictedParameterTraits {
  static constexpr bool may_modify_value = false;

  template <typename value_t>
  static constexpr const value_t& getValue(const value_t& value) {
    return value;
  }
  template <typename value_t>
  static constexpr value_t getDifference(const value_t& lhs,
                                         const value_t& rhs) {
    return lhs - rhs;
  }
};

template <typename limits_t>
struct RestrictedParameterTraits {
  static constexpr bool may_modify_value = true;
  static constexpr double min = limits_t::lowest();
  static constexpr double max = limits_t::max();

  template <typename value_t>
  static constexpr value_t getValue(const value_t& value) {
    return std::clamp(value, static_cast<value_t>(min),
                      static_cast<value_t>(max));
  }
  template <typename value_t>
  static constexpr value_t getDifference(const value_t& lhs,
                                         const value_t& rhs) {
    return getValue(lhs) - getValue(rhs);
  }
};

template <typename limits_t>
struct CyclicParameterTraits {
  static constexpr bool may_modify_value = true;
  static constexpr double min = limits_t::lowest();
  static constexpr double max = limits_t::max();

  template <typename value_t>
  static constexpr value_t getValue(const value_t& value) {
    if ((min <= value) and (value < max)) {
      return value;
    } else {
      return value - (max - min) * std::floor((value - min) / (max - min));
    }
  }
  template <typename value_t>
  static constexpr value_t getDifference(const value_t& lhs,
                                         const value_t& rhs) {
    constexpr value_t range = (max - min);
    value_t delta = getValue(lhs) - getValue(rhs);
    if ((2 * delta) < -range) {
      return delta + range;
    } else if (range < (2 * delta)) {
      return delta - range;
    } else {
      return delta;
    }
  }
};

// Limit types for parameter traits.
//
// The functions names are chosen to be consisten w/ std::numeric_limits
struct PhiBoundParameterLimits {
  static constexpr double lowest() { return -M_PI; }
  static constexpr double max() { return M_PI; }
};
struct ThetaBoundParameterLimits {
  static constexpr double lowest() { return 0; }
  static constexpr double max() { return M_PI; }
};

// Traits implementation structs for single parameters.
//
// Separate implementation structs are needed to generate a compile-time error
// in case of an unsupported enum type/ index combination.
template <typename index_t, index_t kIndex>
struct ParameterTraitsImpl;
template <>
struct ParameterTraitsImpl<BoundIndices, BoundIndices::eBoundPhi> {
  using Type = CyclicParameterTraits<PhiBoundParameterLimits>;
};
template <>
struct ParameterTraitsImpl<BoundIndices, BoundIndices::eBoundTheta> {
  using Type = RestrictedParameterTraits<ThetaBoundParameterLimits>;
};
template <BoundIndices kIndex>
struct ParameterTraitsImpl<BoundIndices, kIndex> {
  // other bound parameters not explicitely specified above are unrestricted
  using Type = UnrestrictedParameterTraits;
};
template <FreeIndices kIndex>
struct ParameterTraitsImpl<FreeIndices, kIndex> {
  // all free parameters components are unrestricted
  using Type = UnrestrictedParameterTraits;
};

template <typename index_t, index_t kIndex>
using ParameterTraits = typename ParameterTraitsImpl<index_t, kIndex>::Type;

// Traits implementation structs for all parameters in an indices enum.
//
// Separate implementation structs are needed to generate a compile-time error
// in case of an unsupported indices enum. Also required since template
// variables can not have an undefined default case.
template <typename indices_t>
struct ParametersTraitsImpl;
template <>
struct ParametersTraitsImpl<BoundIndices> {
  using Scalar = BoundScalar;
  static constexpr unsigned int kSize =
      static_cast<unsigned int>(BoundIndices::eBoundSize);
};
template <>
struct ParametersTraitsImpl<FreeIndices> {
  using Scalar = FreeScalar;
  static constexpr unsigned int kSize =
      static_cast<unsigned int>(FreeIndices::eFreeSize);
};

template <typename indices_t>
using ParametersScalar = typename ParametersTraitsImpl<indices_t>::Scalar;

template <typename indices_t>
constexpr unsigned int kParametersSize = ParametersTraitsImpl<indices_t>::kSize;

}  // namespace detail
}  // namespace Acts