constrained_step.hpp

// This file is part of the ACTS project.
//
// Copyright (C) 2016 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 https://mozilla.org/MPL/2.0/.
 
#pragma once
 
// detray definitions
#include "detray/definitions/algebra.hpp"
#include "detray/definitions/containers.hpp"
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/definitions/math.hpp"
 
// System include(s).
#include <limits>
#include <type_traits>
 
namespace detray {
 
// Add constraints for steppers
namespace step {

enum class direction : int {
  e_forward = 1,
  e_unknown = std::numeric_limits<int>::max(),
  e_backward = -1,
};

enum constraint : std::size_t {
  e_accuracy = 0u,
  e_actor = 1u,
  e_aborter = 2u,
  e_user = 3u,
  e_all = 4u
};
 
}  // namespace step

template <concepts::scalar scalar_t>
struct unconstrained_step {
  template <step::constraint type>
  DETRAY_HOST_DEVICE constexpr void set(const scalar_t /*step_size*/) const {
    /*Do nothing*/
  }

  template <step::constraint type = step::constraint::e_all>
  DETRAY_HOST_DEVICE constexpr scalar_t size(
      const step::direction /*dir*/ = step::direction::e_forward) const {
    return std::numeric_limits<scalar_t>::max();
  }

  template <step::constraint type = step::constraint::e_actor>
  DETRAY_HOST_DEVICE constexpr void release() const {
    /*Do nothing*/
  }
};

template <concepts::scalar scalar_t>
struct constrained_step {
  template <step::constraint type>
    requires(type != step::constraint::e_all)
  DETRAY_HOST_DEVICE void set(const scalar_t step_size) {
    _constraints[type] = math::min(_constraints[type], math::fabs(step_size));
  }

  template <step::constraint type = step::constraint::e_all>
  DETRAY_HOST_DEVICE scalar_t
  size(const step::direction dir = step::direction::e_forward) const {
    if constexpr (type == step::constraint::e_all) {
      return static_cast<scalar_t>(dir) * min();
    } else {
      return static_cast<scalar_t>(dir) * _constraints[type];
    }
  }

  template <step::constraint type = step::constraint::e_actor>
  DETRAY_HOST_DEVICE void release() {
    if constexpr (type == step::constraint::e_all) {
      _constraints = {std::numeric_limits<scalar_t>::max(),
                      std::numeric_limits<scalar_t>::max(),
                      std::numeric_limits<scalar_t>::max(),
                      std::numeric_limits<scalar_t>::max()};
    } else {
      _constraints[type] = std::numeric_limits<scalar_t>::max();
    }
  }

  DETRAY_HOST_DEVICE scalar_t min() const {
    scalar_t min_constr = std::numeric_limits<scalar_t>::max();
    min_constr =
        math::min(min_constr, _constraints[step::constraint::e_accuracy]);
    min_constr = math::min(min_constr, _constraints[step::constraint::e_actor]);
    min_constr =
        math::min(min_constr, _constraints[step::constraint::e_aborter]);
    return math::min(min_constr, _constraints[step::constraint::e_user]);
  }

  darray<scalar_t, 4> _constraints = {std::numeric_limits<scalar_t>::max(),
                                      std::numeric_limits<scalar_t>::max(),
                                      std::numeric_limits<scalar_t>::max(),
                                      std::numeric_limits<scalar_t>::max()};
};
 
}  // namespace detray