policies.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/detail/qualifiers.hpp"
#include "detray/definitions/math.hpp"
#include "detray/definitions/units.hpp"
#include "detray/propagator/base_actor.hpp"
 
// system includes
#include <climits>
#include <limits>
 
namespace detray {

struct always_init : public base_actor {
  struct state {};

  template <typename propagator_state_t>
  DETRAY_HOST_DEVICE inline void operator()(
      const state & /*pol_state*/, propagator_state_t &propagation) const {
    propagation.navigation().set_no_trust();
  }
};

struct guided_navigation : public base_actor {
  struct state {};

  template <typename propagator_state_t>
  DETRAY_HOST_DEVICE inline void operator()(
      const state & /*pol_state*/, propagator_state_t &propagation) const {
    propagation.navigation().set_high_trust();
  }
};

template <concepts::scalar scalar_t>
struct stepper_default_policy : public base_actor {
  struct state {
    scalar_t tol{std::numeric_limits<scalar_t>::epsilon()};
  };

  template <typename propagator_state_t>
  DETRAY_HOST_DEVICE inline void operator()(
      state &pol_state, propagator_state_t &propagation) const {
    const auto &stepping = propagation.stepping();
    auto &navigation = propagation.navigation();
 
    // Not a severe change to track state expected
    if (math::fabs(stepping.step_size()) <
        math::fabs(
            stepping.constraints().template size<>(stepping.direction())) -
            pol_state.tol) {
      // Re-evaluate only next candidate
      navigation.set_high_trust();
    }
    // Step size hit a constraint - the track state was probably changed a
    // lot
    else {
      // Re-evaluate all candidates
      navigation.set_fair_trust();
    }
  }
};

template <concepts::scalar scalar_t>
struct stepper_rk_policy : public base_actor {
  struct state {
    scalar_t m_threshold_fair_trust{0.05f};
    scalar_t m_threshold_no_trust{0.1f};
  };

  template <typename propagator_state_t>
  DETRAY_HOST_DEVICE inline void operator()(
      const state &pol_state, propagator_state_t &propagation) const {
    const auto &stepping = propagation.stepping();
    auto &navigation = propagation.navigation();
 
    // In case of an overlap, have navigator re-evaluate the next candidate
    if (math::fabs(navigation()) <= 1.f * unit<float>::um) {
      navigation.set_high_trust();
      return;
    }
 
    // How strongly did the RKN algorithm reduce the step size?
    const scalar_t rel_correction{(stepping.step_size() - navigation()) /
                                  navigation()};
 
    // Large correction to the stepsize - re-initialize the volume
    if (rel_correction > pol_state.m_threshold_no_trust) {
      navigation.set_no_trust();
    }
    // Medium correction - re-evaluate all current candidates
    else if (rel_correction > pol_state.m_threshold_fair_trust) {
      navigation.set_fair_trust();
    } else {
      // Small correction - re-evaluate only the next candidate
      navigation.set_high_trust();
    }
  }
};
 
}  // namespace detray