Propagator/detail/SteppingHelper.hpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2019 CERN for the benefit of the Acts project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
0008
0009 #pragma once
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Definitions/Direction.hpp"
0013 #include "Acts/Definitions/Tolerance.hpp"
0014 #include "Acts/Propagator/ConstrainedStep.hpp"
0015 #include "Acts/Surfaces/BoundaryCheck.hpp"
0016 #include "Acts/Surfaces/Surface.hpp"
0017 #include "Acts/Utilities/Intersection.hpp"
0018 #include "Acts/Utilities/Logger.hpp"
0019
0020 #include <limits>
0021
0022 namespace Acts::detail {
0023
0024 /// Update surface status - Single component
0025 ///
0026 /// This method intersect the provided surface and update the navigation
0027 /// step estimation accordingly (hence it changes the state). It also
0028 /// returns the status of the intersection to trigger onSurface in case
0029 /// the surface is reached.
0030 ///
0031 /// @param state [in,out] The stepping state (thread-local cache)
0032 /// @param surface [in] The surface provided
0033 /// @param bcheck [in] The boundary check for this status update
0034 template <typename stepper_t>
0035 Acts::Intersection3D::Status updateSingleSurfaceStatus(
0036     const stepper_t& stepper, typename stepper_t::State& state,
0037     const Surface& surface, std::uint8_t index, Direction navDir,
0038     const BoundaryCheck& bcheck, ActsScalar surfaceTolerance,
0039     const Logger& logger) {
0040   ACTS_VERBOSE("Update single surface status for surface: "
0041                << surface.geometryId() << " index " << static_cast<int>(index));
0042
0043   auto sIntersection = surface.intersect(
0044       state.geoContext, stepper.position(state),
0045       navDir * stepper.direction(state), bcheck, surfaceTolerance)[index];
0046
0047   // The intersection is on surface already
0048   if (sIntersection.status() == Intersection3D::Status::onSurface) {
0049     // Release navigation step size
0050     state.stepSize.release(ConstrainedStep::actor);
0051     ACTS_VERBOSE("Intersection: state is ON SURFACE");
0052     return Intersection3D::Status::onSurface;
0053   }
0054
0055   const double nearLimit = std::numeric_limits<double>::lowest();
0056   const double farLimit = state.stepSize.value(ConstrainedStep::aborter);
0057
0058   if (sIntersection && detail::checkIntersection(sIntersection.intersection(),
0059                                                  nearLimit, farLimit, logger)) {
0060     ACTS_VERBOSE("Surface is reachable");
0061     stepper.updateStepSize(state, sIntersection.pathLength(),
0062                            ConstrainedStep::actor);
0063     return Intersection3D::Status::reachable;
0064   }
0065
0066   ACTS_VERBOSE("Surface is NOT reachable");
0067   return Intersection3D::Status::unreachable;
0068 }
0069
0070 /// Update the Step size - single component
0071 ///
0072 /// It takes a (valid) object intersection from the compatibleX(...)
0073 /// calls in the geometry and updates the step size
0074 ///
0075 /// @param state [in,out] The stepping state (thread-local cache)
0076 /// @param oIntersection [in] The object that yielded this step size
0077 /// @param release [in] A release flag
0078 template <typename stepper_t, typename object_intersection_t>
0079 void updateSingleStepSize(typename stepper_t::State& state,
0080                           const object_intersection_t& oIntersection,
0081                           bool release = true) {
0082   double stepSize = oIntersection.pathLength();
0083   state.stepSize.update(stepSize, ConstrainedStep::actor, release);
0084 }
0085
0086 }  // namespace Acts::detail