From 2f4f148cb03b7354abd887d2098c9845a7e72275 Mon Sep 17 00:00:00 2001 From: Joana Niermann Date: Tue, 29 Oct 2024 18:13:08 +0100 Subject: [PATCH] Remove raw newton solver in favour of rtsafe --- .../helix_cylinder_intersector.hpp | 258 +++++------------- .../intersection/helix_line_intersector.hpp | 229 ++++------------ .../intersection/helix_plane_intersector.hpp | 134 +++------ .../cpu/propagator/covariance_transport.cpp | 1 - .../cpu/propagator/jacobian_validation.cpp | 3 - 5 files changed, 163 insertions(+), 462 deletions(-) diff --git a/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp b/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp index 2e26f851c..cf8499f26 100644 --- a/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp +++ b/core/include/detray/navigation/intersection/helix_cylinder_intersector.hpp @@ -71,202 +71,86 @@ struct helix_intersector_impl, algebra_t> std::array, 2> ret{}; - if (!run_rtsafe) { - // Get the surface placement - const auto &sm = trf.matrix(); - // Cylinder z axis - const vector3_type sz = getter::vector<3>(sm, 0u, 2u); - // Cylinder centre - const point3_type sc = getter::vector<3>(sm, 0u, 3u); - - // Starting point on the helix for the Newton iteration - // The mask is a cylinder -> it provides its radius as the first - // value - const scalar_type r{mask[cylinder2D::e_r]}; - - // Try to guess the best starting positions for the iteration - - // Direction of the track at the helix origin - const auto h_dir = h.dir(0.f); - // Default starting path length for the Newton iteration (assumes - // concentric cylinder) - const scalar_type default_s{r * getter::perp(h_dir)}; - - // Initial helix path length parameter - std::array paths{default_s, default_s}; - - // try to guess good starting path by calculating the intersection - // path of the helix tangential with the cylinder. This only has a - // chance of working for tracks with reasonably high p_T ! - detail::ray t{h.pos(), h.time(), h_dir, h.qop()}; - const auto qe = this->solve_intersection(t, mask, trf); - - // Obtain both possible solutions by looping over the (different) - // starting positions - auto n_runs{static_cast(qe.solutions())}; - - // Note: the default path length might be smaller than either - // solution - switch (qe.solutions()) { - case 2: - paths[1] = qe.larger(); - // If there are two solutions, reuse the case for a single - // solution to setup the intersection with the smaller path - // in ret[0] - [[fallthrough]]; - case 1: { - paths[0] = qe.smaller(); - break; - } - // Even if the ray is parallel to the cylinder, the helix - // might still hit it - default: { - n_runs = 2u; - paths[0] = r; - paths[1] = -r; - } + // Cylinder z axis + const vector3_type sz = trf.z(); + // Cylinder centre + const point3_type sc = trf.translation(); + + // Starting point on the helix for the Newton iteration + // The mask is a cylinder -> it provides its radius as the first + // value + const scalar_type r{mask[cylinder2D::e_r]}; + + // Try to guess the best starting positions for the iteration + + // Direction of the track at the helix origin + const auto h_dir = h.dir(0.5f * r); + // Default starting path length for the Newton iteration (assumes + // concentric cylinder) + const scalar_type default_s{r * getter::perp(h_dir)}; + + // Initial helix path length parameter + std::array paths{default_s, default_s}; + + // try to guess good starting path by calculating the intersection + // path of the helix tangential with the cylinder. This only has a + // chance of working for tracks with reasonably high p_T ! + detail::ray t{h.pos(), h.time(), h_dir, h.qop()}; + const auto qe = this->solve_intersection(t, mask, trf); + + // Obtain both possible solutions by looping over the (different) + // starting positions + auto n_runs{static_cast(qe.solutions())}; + + // Note: the default path length might be smaller than either + // solution + switch (qe.solutions()) { + case 2: + paths[1] = qe.larger(); + // If there are two solutions, reuse the case for a single + // solution to setup the intersection with the smaller path + // in ret[0] + [[fallthrough]]; + case 1: { + paths[0] = qe.smaller(); + break; } - - for (unsigned int i = 0u; i < n_runs; ++i) { - - scalar_type &s = paths[i]; - intersection_type &sfi = ret[i]; - - // Path length in the previous iteration step - scalar_type s_prev{0.f}; - - // f(s) = ((h.pos(s) - sc) x sz)^2 - r^2 == 0 - // Run the iteration on s - std::size_t n_tries{0u}; - while (math::fabs(s - s_prev) > convergence_tolerance && - n_tries < max_n_tries) { - - // f'(s) = 2 * ( (h.pos(s) - sc) x sz) * (h.dir(s) x sz) ) - const vector3_type crp = vector::cross(h.pos(s) - sc, sz); - const scalar_type denom{ - 2.f * vector::dot(crp, vector::cross(h.dir(s), sz))}; - - // No intersection can be found if dividing by zero - if (denom == 0.f) { - return ret; - } - - // x_n+1 = x_n - f(s) / f'(s) - s_prev = s; - s -= (vector::dot(crp, crp) - r * r) / denom; - - ++n_tries; - } - // No intersection found within max number of trials - if (n_tries == max_n_tries) { - return ret; - } - - // Build intersection struct from helix parameters - sfi.path = s; - const auto p3 = h.pos(s); - sfi.local = mask_t::to_local_frame(trf, p3); - const scalar_type cos_incidence_angle = vector::dot( - mask_t::get_local_frame().normal(trf, sfi.local), h.dir(s)); - - scalar_type tol{mask_tolerance[1]}; - if (detail::is_invalid_value(tol)) { - // Due to floating point errors this can be negative if - // cos ~ 1 - const scalar_type sin_inc2{math::fabs( - 1.f - cos_incidence_angle * cos_incidence_angle)}; - - tol = math::fabs((s - s_prev) * math::sqrt(sin_inc2)); - } - sfi.status = mask.is_inside(sfi.local, tol); - sfi.sf_desc = sf_desc; - sfi.direction = !math::signbit(s); - sfi.volume_link = mask.volume_link(); + default: { + n_runs = 2u; + paths[0] = r; + paths[1] = -r; } + } - return ret; - } else { - // Cylinder z axis - const vector3_type sz = trf.z(); - // Cylinder centre - const point3_type sc = trf.translation(); - - // Starting point on the helix for the Newton iteration - // The mask is a cylinder -> it provides its radius as the first - // value - const scalar_type r{mask[cylinder2D::e_r]}; - - // Try to guess the best starting positions for the iteration - - // Direction of the track at the helix origin - const auto h_dir = h.dir(0.5f * r); - // Default starting path length for the Newton iteration (assumes - // concentric cylinder) - const scalar_type default_s{r * getter::perp(h_dir)}; - - // Initial helix path length parameter - std::array paths{default_s, default_s}; - - // try to guess good starting path by calculating the intersection - // path of the helix tangential with the cylinder. This only has a - // chance of working for tracks with reasonably high p_T ! - detail::ray t{h.pos(), h.time(), h_dir, h.qop()}; - const auto qe = this->solve_intersection(t, mask, trf); - - // Obtain both possible solutions by looping over the (different) - // starting positions - auto n_runs{static_cast(qe.solutions())}; - - // Note: the default path length might be smaller than either - // solution - switch (qe.solutions()) { - case 2: - paths[1] = qe.larger(); - // If there are two solutions, reuse the case for a single - // solution to setup the intersection with the smaller path - // in ret[0] - [[fallthrough]]; - case 1: { - paths[0] = qe.smaller(); - break; - } - default: { - n_runs = 2u; - paths[0] = r; - paths[1] = -r; - } - } - - /// Evaluate the function and its derivative at the point @param x - auto cyl_inters_func = [&h, &r, &sz, &sc](const scalar_type x) { - const vector3_type crp = vector::cross(h.pos(x) - sc, sz); - - // f(s) = ((h.pos(s) - sc) x sz)^2 - r^2 == 0 - const scalar_type f_s{(vector::dot(crp, crp) - r * r)}; - // f'(s) = 2 * ( (h.pos(s) - sc) x sz) * (h.dir(s) x sz) ) - const scalar_type df_s{ - 2.f * vector::dot(crp, vector::cross(h.dir(x), sz))}; + /// Evaluate the function and its derivative at the point @param x + auto cyl_inters_func = [&h, &r, &sz, &sc](const scalar_type x) { + const vector3_type crp = vector::cross(h.pos(x) - sc, sz); - return std::make_tuple(f_s, df_s); - }; + // f(s) = ((h.pos(s) - sc) x sz)^2 - r^2 == 0 + const scalar_type f_s{(vector::dot(crp, crp) - r * r)}; + // f'(s) = 2 * ( (h.pos(s) - sc) x sz) * (h.dir(s) x sz) ) + const scalar_type df_s{ + 2.f * vector::dot(crp, vector::cross(h.dir(x), sz))}; - for (unsigned int i = 0u; i < n_runs; ++i) { + return std::make_tuple(f_s, df_s); + }; - const scalar_type &s_ini = paths[i]; - intersection_type &sfi = ret[i]; + for (unsigned int i = 0u; i < n_runs; ++i) { - // Run the root finding algorithm - const auto [s, ds] = newton_raphson_safe(cyl_inters_func, s_ini, - convergence_tolerance, - max_n_tries, max_path); + const scalar_type &s_ini = paths[i]; + intersection_type &sfi = ret[i]; - // Build intersection struct from the root - build_intersection(h, sfi, s, ds, sf_desc, mask, trf, - mask_tolerance); - } + // Run the root finding algorithm + const auto [s, ds] = newton_raphson_safe(cyl_inters_func, s_ini, + convergence_tolerance, + max_n_tries, max_path); - return ret; + // Build intersection struct from the root + build_intersection(h, sfi, s, ds, sf_desc, mask, trf, + mask_tolerance); } + + return ret; } /// Interface to use fixed mask tolerance @@ -286,8 +170,6 @@ struct helix_intersector_impl, algebra_t> std::size_t max_n_tries{1000u}; // Early exit, if the intersection is too far away scalar_type max_path{5.f * unit::m}; - // Complement the Newton algorithm with Bisection steps - bool run_rtsafe{true}; }; template diff --git a/core/include/detray/navigation/intersection/helix_line_intersector.hpp b/core/include/detray/navigation/intersection/helix_line_intersector.hpp index c6091888f..5f092554d 100644 --- a/core/include/detray/navigation/intersection/helix_line_intersector.hpp +++ b/core/include/detray/navigation/intersection/helix_line_intersector.hpp @@ -66,196 +66,89 @@ struct helix_intersector_impl, algebra_t> { intersection_type sfi{}; - if (!run_rtsafe) { - // line axis direction - const vector3_type l = getter::vector<3>(trf.matrix(), 0u, 2u); - - // line center - const point3_type c = trf.translation(); - - // initial track direction - const vector3_type t0 = h.dir(0.f); - - // initial track position - const point3_type r0 = h.pos(0.f); - - // Projection of line to track direction - const scalar_type lt0{vector::dot(l, t0)}; - - const scalar_type denom{1.f - (lt0 * lt0)}; - - // Case for wire is parallel to track - // @NOTE We might not have to call this which is meant to be for ray - // intersection... - if (denom < 1e-5f) { - sfi.status = false; - return sfi; - } - - // vector from track position to line center - const vector3_type D = c - r0; - - // D projection on line direction - const scalar_type P{vector::dot(D, l)}; - - // D projection on track direction - const scalar_type Q{vector::dot(D, t0)}; - - // Path length to the point of closest approach on the track - // @NOTE Ray intersection algorithm is used for the initial guess on - // the path length - scalar_type s{1.f / denom * (Q - P * lt0)}; - scalar_type s_prev{0.f}; - - // Run the iteration on s - std::size_t n_tries{0u}; - while (math::fabs(s - s_prev) > convergence_tolerance && - n_tries < max_n_tries) { - - // track direction - const vector3_type t = h.dir(s); - - // track position - const point3_type r = h.pos(s); - - // Projection of (track position - center) to the line - const scalar_type A = vector::dot(r - c, l); - - // Vector orthogonal to the line and passing the track position - // w = r - (c + ((r - c) * l)l) - const vector3_type w = r - (c + A * l); - - // f(s) = t * w = 0 - const scalar_type f = vector::dot(t, w); - - // dtds = d^2r/ds^2 = qop * (t X b_field) - const vector3_type dtds = - h.qop() * vector::cross(t, *h._mag_field); - // dwds = t - (t * l)l - const vector3_type dwds = t - vector::dot(t, l) * l; - - // f'(s) = dtds * w + t * dwds - const scalar_type dfds = - vector::dot(dtds, w) + vector::dot(t, dwds); - - // x_n+1 = x_n - f(s) / f'(s) - s_prev = s; - s -= f / dfds; - - ++n_tries; - } - - // No intersection found within max number of trials - if (n_tries == max_n_tries) { - return sfi; - } - - // Build intersection struct from helix parameters - sfi.path = s; - sfi.local = mask_t::to_local_frame(trf, h.pos(s), h.dir(s)); - const scalar_type cos_incidence_angle = vector::dot( - mask_t::get_local_frame().normal(trf, sfi.local), h.dir(s)); - scalar_type tol{mask_tolerance[1]}; - if (detail::is_invalid_value(tol)) { - // Due to floating point errors this can be negative if cos ~ 1 - const scalar_type sin_inc2{math::fabs( - 1.f - cos_incidence_angle * cos_incidence_angle)}; - - tol = math::fabs((s - s_prev) * math::sqrt(sin_inc2)); - } - sfi.status = mask.is_inside(sfi.local, tol); - sfi.sf_desc = sf_desc; - sfi.direction = !math::signbit(s); - sfi.volume_link = mask.volume_link(); + // line axis direction + const vector3_type l = getter::vector<3>(trf.matrix(), 0u, 2u); - return sfi; - } else { - // line axis direction - const vector3_type l = getter::vector<3>(trf.matrix(), 0u, 2u); - - // line center - const point3_type c = trf.translation(); + // line center + const point3_type c = trf.translation(); - // initial track direction - const vector3_type t0 = h.dir(0.f); + // initial track direction + const vector3_type t0 = h.dir(0.f); - // initial track position - const point3_type r0 = h.pos(0.f); + // initial track position + const point3_type r0 = h.pos(0.f); - // Projection of line to track direction - const scalar_type lt0{vector::dot(l, t0)}; + // Projection of line to track direction + const scalar_type lt0{vector::dot(l, t0)}; - const scalar_type denom{1.f - (lt0 * lt0)}; + const scalar_type denom{1.f - (lt0 * lt0)}; - // Case for wire is parallel to track - // @NOTE We might not have to call this which is meant to be for ray - // intersection... - if (denom < 1e-5f) { + // Case for wire is parallel to track + // @NOTE We might not have to call this which is meant to be for ray + // intersection... + if (denom < 1e-5f) { #ifndef NDEBUG - std::cout << "ERROR: Helix line intersector encountered " - "invalid value!" - << std::endl; + std::cout << "ERROR: Helix line intersector encountered " + "invalid value!" + << std::endl; #endif - sfi.status = false; - return sfi; - } + sfi.status = false; + return sfi; + } - // vector from track position to line center - const vector3_type D = c - r0; + // vector from track position to line center + const vector3_type D = c - r0; - // D projection on line direction - const scalar_type P{vector::dot(D, l)}; + // D projection on line direction + const scalar_type P{vector::dot(D, l)}; - // D projection on track direction - const scalar_type Q{vector::dot(D, t0)}; + // D projection on track direction + const scalar_type Q{vector::dot(D, t0)}; - // Path length to the point of closest approach on the track - // @NOTE Ray intersection algorithm is used for the initial guess on - // the path length - scalar_type s_ini{1.f / denom * (Q - P * lt0)}; + // Path length to the point of closest approach on the track + // @NOTE Ray intersection algorithm is used for the initial guess on + // the path length + scalar_type s_ini{1.f / denom * (Q - P * lt0)}; - /// Evaluate the function and its derivative at the point @param x - auto line_inters_func = [&h, &c, &l](const scalar_type x) { - // track direction - const vector3_type t = h.dir(x); + /// Evaluate the function and its derivative at the point @param x + auto line_inters_func = [&h, &c, &l](const scalar_type x) { + // track direction + const vector3_type t = h.dir(x); - // track position - const point3_type r = h.pos(x); + // track position + const point3_type r = h.pos(x); - // Projection of (track position - center) to the line - const scalar_type A = vector::dot(r - c, l); + // Projection of (track position - center) to the line + const scalar_type A = vector::dot(r - c, l); - // Vector orthogonal to the line and passing the track position - // w = r - (c + ((r - c) * l)l) - const vector3_type w = r - (c + A * l); + // Vector orthogonal to the line and passing the track position + // w = r - (c + ((r - c) * l)l) + const vector3_type w = r - (c + A * l); - // f(s) = t * w = 0 - const scalar_type f = vector::dot(t, w); + // f(s) = t * w = 0 + const scalar_type f = vector::dot(t, w); - // dtds = d^2r/ds^2 = qop * (t X b_field) - const vector3_type dtds = - h.qop() * vector::cross(t, *h._mag_field); - // dwds = t - (t * l)l - const vector3_type dwds = t - vector::dot(t, l) * l; + // dtds = d^2r/ds^2 = qop * (t X b_field) + const vector3_type dtds = h.qop() * vector::cross(t, *h._mag_field); + // dwds = t - (t * l)l + const vector3_type dwds = t - vector::dot(t, l) * l; - // f'(s) = dtds * w + t * dwds - const scalar_type dfds = - vector::dot(dtds, w) + vector::dot(t, dwds); + // f'(s) = dtds * w + t * dwds + const scalar_type dfds = + vector::dot(dtds, w) + vector::dot(t, dwds); - return std::make_tuple(f, dfds); - }; + return std::make_tuple(f, dfds); + }; - // Run the root finding algorithm - const auto [s, ds] = newton_raphson_safe(line_inters_func, s_ini, - convergence_tolerance, - max_n_tries, max_path); + // Run the root finding algorithm + const auto [s, ds] = + newton_raphson_safe(line_inters_func, s_ini, convergence_tolerance, + max_n_tries, max_path); - // Build intersection struct from the root - build_intersection(h, sfi, s, ds, sf_desc, mask, trf, - mask_tolerance); + // Build intersection struct from the root + build_intersection(h, sfi, s, ds, sf_desc, mask, trf, mask_tolerance); - return sfi; - } + return sfi; } /// Interface to use fixed mask tolerance @@ -274,8 +167,6 @@ struct helix_intersector_impl, algebra_t> { std::size_t max_n_tries{1000u}; // Early exit, if the intersection is too far away scalar_type max_path{5.f * unit::m}; - // Complement the Newton algorithm with Bisection steps - bool run_rtsafe{true}; }; } // namespace detray diff --git a/core/include/detray/navigation/intersection/helix_plane_intersector.hpp b/core/include/detray/navigation/intersection/helix_plane_intersector.hpp index e18ff3a98..eed7e6b2a 100644 --- a/core/include/detray/navigation/intersection/helix_plane_intersector.hpp +++ b/core/include/detray/navigation/intersection/helix_plane_intersector.hpp @@ -68,107 +68,41 @@ struct helix_intersector_impl, algebra_t> { intersection_type sfi{}; - if (!run_rtsafe) { - // Get the surface info - const auto &sm = trf.matrix(); - // Surface normal - const vector3_type sn = getter::vector<3>(sm, 0u, 2u); - // Surface translation - const point3_type st = getter::vector<3>(sm, 0u, 3u); - - // Starting point on the helix for the Newton iteration - const vector3_type dist{trf.point_to_global(mask.centroid()) - - h.pos(0.f)}; - scalar_type denom{vector::dot(sn, h.dir(0.f))}; - - scalar_type s; - if (denom == 0.f) { - s = getter::norm(dist); - } - s = math::fabs(vector::dot(sn, dist) / denom); - - scalar_type s_prev{0.f}; - - // f(s) = sn * (h.pos(s) - st) == 0 - // Run the iteration on s - std::size_t n_tries{0u}; - while (math::fabs(s - s_prev) > convergence_tolerance && - n_tries < max_n_tries) { - // f'(s) = sn * h.dir(s) - denom = vector::dot(sn, h.dir(s)); - // No intersection can be found if dividing by zero - if (denom == 0.f) { - return sfi; - } - // x_n+1 = x_n - f(s) / f'(s) - s_prev = s; - s -= vector::dot(sn, h.pos(s) - st) / denom; - ++n_tries; - } - // No intersection found within max number of trials - if (n_tries == max_n_tries) { - return sfi; - } - - // Build intersection struct from helix parameters - sfi.path = s; - sfi.local = mask_t::to_local_frame(trf, h.pos(s), h.dir(s)); - const scalar_type cos_incidence_angle = vector::dot( - mask_t::get_local_frame().normal(trf, sfi.local), h.dir(s)); - - scalar_type tol{mask_tolerance[1]}; - if (detail::is_invalid_value(tol)) { - // Due to floating point errors this can be negative if cos ~ 1 - const scalar_type sin_inc2{math::fabs( - 1.f - cos_incidence_angle * cos_incidence_angle)}; - - tol = math::fabs((s - s_prev) * math::sqrt(sin_inc2)); - } - sfi.status = mask.is_inside(sfi.local, tol); - sfi.sf_desc = sf_desc; - sfi.direction = !math::signbit(s); - sfi.volume_link = mask.volume_link(); - - return sfi; + // Surface normal + const vector3_type sn = trf.z(); + // Surface translation + const point3_type st = trf.translation(); + + // Starting point on the helix for the Newton iteration + const vector3_type dist{trf.point_to_global(mask.centroid()) - + h.pos(0.f)}; + scalar_type denom{vector::dot(sn, h.dir(0.5f * getter::norm(dist)))}; + scalar_type s_ini; + if (denom == 0.f) { + s_ini = getter::norm(dist); } else { - // Surface normal - const vector3_type sn = trf.z(); - // Surface translation - const point3_type st = trf.translation(); - - // Starting point on the helix for the Newton iteration - const vector3_type dist{trf.point_to_global(mask.centroid()) - - h.pos(0.f)}; - scalar_type denom{ - vector::dot(sn, h.dir(0.5f * getter::norm(dist)))}; - scalar_type s_ini; - if (denom == 0.f) { - s_ini = getter::norm(dist); - } else { - s_ini = vector::dot(sn, dist) / denom; - } - - /// Evaluate the function and its derivative at the point @param x - auto plane_inters_func = [&h, &st, &sn](const scalar_type x) { - // f(s) = sn * (h.pos(s) - st) == 0 - const scalar_type f_s{vector::dot(sn, (h.pos(x) - st))}; - // f'(s) = sn * h.dir(s) - const scalar_type df_s{vector::dot(sn, h.dir(x))}; - - return std::make_tuple(f_s, df_s); - }; - - // Run the root finding algorithm - const auto [s, ds] = newton_raphson_safe(plane_inters_func, s_ini, - convergence_tolerance, - max_n_tries, max_path); - - // Build intersection struct from the root - build_intersection(h, sfi, s, ds, sf_desc, mask, trf, - mask_tolerance); - - return sfi; + s_ini = vector::dot(sn, dist) / denom; } + + /// Evaluate the function and its derivative at the point @param x + auto plane_inters_func = [&h, &st, &sn](const scalar_type x) { + // f(s) = sn * (h.pos(s) - st) == 0 + const scalar_type f_s{vector::dot(sn, (h.pos(x) - st))}; + // f'(s) = sn * h.dir(s) + const scalar_type df_s{vector::dot(sn, h.dir(x))}; + + return std::make_tuple(f_s, df_s); + }; + + // Run the root finding algorithm + const auto [s, ds] = + newton_raphson_safe(plane_inters_func, s_ini, convergence_tolerance, + max_n_tries, max_path); + + // Build intersection struct from the root + build_intersection(h, sfi, s, ds, sf_desc, mask, trf, mask_tolerance); + + return sfi; } /// Interface to use fixed mask tolerance @@ -187,8 +121,6 @@ struct helix_intersector_impl, algebra_t> { std::size_t max_n_tries{1000u}; // Early exit, if the intersection is too far away scalar_type max_path{5.f * unit::m}; - // Complement the Newton algorithm with Bisection steps - bool run_rtsafe{true}; }; template diff --git a/tests/integration_tests/cpu/propagator/covariance_transport.cpp b/tests/integration_tests/cpu/propagator/covariance_transport.cpp index 6badeb32c..fe56e890f 100644 --- a/tests/integration_tests/cpu/propagator/covariance_transport.cpp +++ b/tests/integration_tests/cpu/propagator/covariance_transport.cpp @@ -184,7 +184,6 @@ class detray_propagation_HelixCovarianceTransportValidation // Get the intersection on the next surface helix_intersector helix_inters{}; - helix_inters.run_rtsafe = false; const intersection_t is = get_intersection(helix_inters( hlx, surface_descriptor<>{}, mask_1, trf_1, this->mask_tolerance)); // Check for successfull intersection diff --git a/tests/integration_tests/cpu/propagator/jacobian_validation.cpp b/tests/integration_tests/cpu/propagator/jacobian_validation.cpp index 28f6c75e0..b6b57520d 100644 --- a/tests/integration_tests/cpu/propagator/jacobian_validation.cpp +++ b/tests/integration_tests/cpu/propagator/jacobian_validation.cpp @@ -629,7 +629,6 @@ bound_track_parameters get_initial_parameter( using mask_t = typename detector_t::mask_container::template get_type; helix_intersector hlx_is{}; - hlx_is.run_rtsafe = false; hlx_is.convergence_tolerance = helix_tolerance; auto sfi = hlx_is(hlx, departure_sf, departure_mask, departure_trf, 0.f); EXPECT_TRUE(sfi.status) @@ -1000,7 +999,6 @@ bound_param_vector_type get_displaced_bound_vector_helix( using mask_t = typename detector_t::mask_container::template get_type; helix_intersector hlx_is{}; - hlx_is.run_rtsafe = false; hlx_is.convergence_tolerance = helix_tolerance; auto sfi = hlx_is(hlx, destination_sf, destination_mask, destination_trf, 0.f); @@ -1056,7 +1054,6 @@ void evaluate_jacobian_difference_helix( using mask_t = typename detector_t::mask_container::template get_type; helix_intersector hlx_is{}; - hlx_is.run_rtsafe = false; hlx_is.convergence_tolerance = helix_tolerance; auto sfi =