EIC code displayed by LXR master/​acts/​Core/​src/​Navigation/​NavigationStream.cpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-05 08:21:57

 // 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/.
 
 #include "Acts/Navigation/NavigationStream.hpp"
 
 #include "Acts/Propagator/NavigationTarget.hpp"
 #include "Acts/Surfaces/BoundaryTolerance.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
 
 #include <algorithm>
 
 namespace Acts {
 
 bool NavigationStream::initialize(const GeometryContext& gctx,
                                   const QueryPoint& queryPoint,
                                   const BoundaryTolerance& cTolerance,
                                   const double onSurfaceTolerance,
                                   const bool candidatesAreUnique) {
   // Position and direction from the query point
   const Vector3& position = queryPoint.position;
   const Vector3& direction = queryPoint.direction;
 
   // De-duplicate by surface pointer first, so each surface is intersected only
   // once in this pass, keeping the first occurrence (in insertion order). This
   // reproduces the previous std::stable_sort + std::unique result (first-wins),
   // but in place: it avoids the temporary buffer that std::stable_sort
   // allocates on every call, which matters on this per-navigation hot path. The
   // candidate count per volume is small, so the quadratic scan is cheap — but
   // it is skipped entirely when the caller guarantees uniqueness. (Should a
   // duplicate slip through regardless, the post-sort unique pass below still
   // removes it; only the first-wins tolerance selection is then not enforced.)
   if (!candidatesAreUnique) {
     std::size_t writeIdx = 0;
     for (std::size_t readIdx = 0; readIdx < m_candidates.size(); ++readIdx) {
       const Surface* surface = &m_candidates[readIdx].surface();
       bool alreadySeen = false;
       for (std::size_t k = 0; k < writeIdx; ++k) {
         if (&m_candidates[k].surface() == surface) {
           alreadySeen = true;
           break;
         }
       }
       if (!alreadySeen) {
         if (writeIdx != readIdx) {
           m_candidates[writeIdx] = m_candidates[readIdx];
         }
         ++writeIdx;
       }
     }
     m_candidates.erase(m_candidates.begin() + writeIdx, m_candidates.end());
   }
 
   // Collect additional candidates for the second valid intersection. Reuse the
   // member scratch buffer to avoid a heap allocation on every call.
   std::vector<NavigationTarget>& additionalCandidates = m_additionalCandidates;
   additionalCandidates.clear();
   for (auto& candidate : m_candidates) {
     // Get the surface from the object intersection
     const Surface& surface = candidate.surface();
     // Intersect the surface
     auto multiIntersection = surface.intersect(gctx, position, direction,
                                                cTolerance, onSurfaceTolerance);
 
     bool firstValid = multiIntersection.at(0).isValid();
     bool secondValid = multiIntersection.at(1).isValid();
     if (firstValid && !secondValid) {
       if (multiIntersection.at(0).pathLength() < -onSurfaceTolerance) {
         continue;
       }
       candidate.intersection() = multiIntersection.at(0);
       candidate.intersectionIndex() = 0;
     } else if (!firstValid && secondValid) {
       if (multiIntersection.at(1).pathLength() < -onSurfaceTolerance) {
         continue;
       }
       candidate.intersection() = multiIntersection.at(1);
       candidate.intersectionIndex() = 1;
     } else {
       // Split them into valid intersections, keep track of potentially
       // additional candidates
       bool originalCandidateUpdated = false;
       for (auto [intersectionIndex, intersection] :
            enumerate(multiIntersection)) {
         // Skip negative solutions, respecting the on surface tolerance
         if (intersection.pathLength() < -onSurfaceTolerance) {
           continue;
         }
         // Valid solution is either on surface or updates the distance
         if (intersection.isValid()) {
           if (!originalCandidateUpdated) {
             candidate.intersection() = intersection;
             candidate.intersectionIndex() = intersectionIndex;
             originalCandidateUpdated = true;
           } else {
             NavigationTarget additionalCandidate = candidate;
             additionalCandidate.intersection() = intersection;
             additionalCandidate.intersectionIndex() = intersectionIndex;
             additionalCandidates.emplace_back(additionalCandidate);
           }
         }
       }
     }
   }
 
   // Append the multi intersection candidates
   m_candidates.insert(m_candidates.end(), additionalCandidates.begin(),
                       additionalCandidates.end());
 
   // Sort the candidates by path length
   std::ranges::sort(m_candidates, NavigationTarget::pathLengthOrder);
 
   // If we have duplicates, we expect them to be close by in path length, so we
   // don't need to re-sort Remove duplicates on basis of the surface pointer
 
   /// But but but... What about the surfaces with multiple intersections?
   auto nonUniqueRange = std::ranges::unique(
       m_candidates.begin(), m_candidates.end(),
       [](const NavigationTarget& a, const NavigationTarget& b) {
         return &a.surface() == &b.surface();
       });
   m_candidates.erase(nonUniqueRange.begin(), nonUniqueRange.end());
 
   // The we find the first invalid candidate
   auto firstInvalid = std::ranges::find_if(
       m_candidates,
       [](const NavigationTarget& a) { return !a.intersection().isValid(); });
 
   // Set the range and initialize
   m_candidates.resize(std::distance(m_candidates.begin(), firstInvalid),
                       NavigationTarget::None());
 
   m_currentIndex = 0;
   if (m_candidates.empty()) {
     return false;
   }
   return true;
 }
 
 bool NavigationStream::update(const GeometryContext& gctx,
                               const QueryPoint& queryPoint,
                               double onSurfaceTolerance) {
   // Loop over the (currently valid) candidates and update
   for (; m_currentIndex < m_candidates.size(); ++m_currentIndex) {
     // Get the candidate, and resolve the tuple
     NavigationTarget& candidate = currentCandidate();
     // Get the surface from the object intersection
     const Surface& surface = candidate.surface();
     // (re-)Intersect the surface
     auto multiIntersection =
         surface.intersect(gctx, queryPoint.position, queryPoint.direction,
                           candidate.boundaryTolerance(), onSurfaceTolerance);
     // Split them into valid intersections
     for (auto [intersectionIndex, intersection] :
          enumerate(multiIntersection)) {
       // Skip wrong index solution
       if (intersectionIndex != candidate.intersectionIndex()) {
         continue;
       }
       // Valid solution is either on surface or updates the distance
       if (intersection.isValid()) {
         candidate.intersection() = intersection;
         return true;
       }
     }
   }
   // No candidate was reachable
   return false;
 }
 
 void NavigationStream::reset() {
   m_candidates.clear();
   m_currentIndex = 0;
 }
 
 void NavigationStream::addSurfaceCandidate(
     const Surface& surface, const BoundaryTolerance& bTolerance) {
   m_candidates.emplace_back(Intersection3D::Invalid(), 0, surface, bTolerance);
 }
 
 void NavigationStream::addSurfaceCandidates(
     std::span<const Surface*> surfaces, const BoundaryTolerance& bTolerance) {
   m_candidates.reserve(m_candidates.size() + surfaces.size());
   std::ranges::for_each(surfaces, [&](const Surface* surface) {
     m_candidates.emplace_back(Intersection3D::Invalid(), 0, *surface,
                               bTolerance);
   });
 }
 
 void NavigationStream::addPortalCandidate(const Portal& portal) {
   m_candidates.emplace_back(Intersection3D::Invalid(), 0, portal,
                             BoundaryTolerance::None());
 }
 
 AppendOnlyNavigationStream::AppendOnlyNavigationStream(NavigationStream& stream)
     : m_stream{&stream} {}
 
 void AppendOnlyNavigationStream::addPortalCandidate(const Portal& portal) {
   m_stream->addPortalCandidate(portal);
 }
 
 void AppendOnlyNavigationStream::addSurfaceCandidate(
     const Surface& surface, const BoundaryTolerance& bTolerance) {
   m_stream->addSurfaceCandidate(surface, bTolerance);
 }
 
 }  // namespace Acts

This page was automatically generated by the 2.3.7 LXR engine. The LXR team