refactor: use std::ranges::sort and reverse

Core/include/Acts/Clusterization/Clusterization.ipp

@@ -1,11 +1,12 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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 http://mozilla.org/MPL/2.0/.
 
+#include <algorithm>
 #include <array>
 #include <vector>
 
@@ -273,7 +274,7 @@ void labelClusters(CellCollection& cells, Connect connect) {
   internal::DisjointSets ds{};
 
   // Sort cells by position to enable in-order scan
-  std::sort(cells.begin(), cells.end(), internal::Compare<Cell, GridDim>());
+  std::ranges::sort(cells, internal::Compare<Cell, GridDim>());
 
   // First pass: Allocate labels and record equivalences
   for (auto it = cells.begin(); it != cells.end(); ++it) {
@@ -308,9 +309,7 @@ ClusterCollection mergeClusters(CellCollection& cells) {
   if constexpr (GridDim > 1) {
     // Sort the cells by their cluster label, only needed if more than
     // one spatial dimension
-    std::sort(cells.begin(), cells.end(), [](Cell& lhs, Cell& rhs) {
-      return getCellLabel(lhs) < getCellLabel(rhs);
-    });
+    std::ranges::sort(cells, {}, [](Cell& c) { return getCellLabel(c); });
   }
 
   return internal::mergeClustersImpl<CellCollection, ClusterCollection>(cells);

Core/include/Acts/Material/MaterialComposition.hpp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2018-2024 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
@@ -100,10 +100,10 @@ class MaterialComposition {
   /// Rescales the fractions so they all add up to unity within the accuracy.
   MaterialComposition(std::vector<ElementFraction> elements)
       : m_elements(std::move(elements)) {
-    std::sort(m_elements.begin(), m_elements.end());
+    std::ranges::sort(m_elements, std::less<ElementFraction>{});
     // compute the total weight first
     unsigned total = 0u;
-    for (auto element : m_elements) {
+    for (const auto& element : m_elements) {
       total += element.m_fraction;
     }
     // compute scale factor into the [0, 256) range

Core/include/Acts/Navigation/DetectorNavigator.hpp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -22,6 +22,7 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/Logger.hpp"
 
+#include <algorithm>
 #include <iomanip>
 #include <iterator>
 #include <sstream>
@@ -405,13 +406,9 @@ class DetectorNavigator {
 
     // Sort properly the surface candidates
     auto& nCandidates = nState.surfaceCandidates;
-    std::sort(nCandidates.begin(), nCandidates.end(),
-              [&](const auto& a, const auto& b) {
-                // The two path lengths
-                ActsScalar pathToA = a.objectIntersection.pathLength();
-                ActsScalar pathToB = b.objectIntersection.pathLength();
-                return pathToA < pathToB;
-              });
+    std::ranges::sort(nCandidates, {}, [](const auto& c) {
+      return c.objectIntersection.pathLength();
+    });
     // Set the surface candidate
     nState.surfaceCandidateIndex = 0;
   }

Core/include/Acts/Navigation/MultiLayerNavigation.hpp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -14,8 +14,10 @@
 #include "Acts/Navigation/NavigationStateUpdaters.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
 
+#include <algorithm>
 #include <array>
 #include <memory>
+#include <tuple>
 
 namespace Acts::Experimental {
 
@@ -105,16 +107,11 @@ class MultiLayerNavigation : public IInternalNavigation {
   void resolveDuplicates(const GeometryContext& gctx,
                          std::vector<const Acts::Surface*>& surfaces) const {
     // sorting the surfaces according to their radial distance
-    std::sort(surfaces.begin(), surfaces.end(),
-              [&gctx](const auto& surf1, const auto& surf2) {
-                if (surf1->center(gctx).x() != surf2->center(gctx).x()) {
-                  return surf1->center(gctx).x() < surf2->center(gctx).x();
-                }
-                if (surf1->center(gctx).y() != surf2->center(gctx).y()) {
-                  return surf1->center(gctx).y() < surf2->center(gctx).y();
-                }
-                return surf1->center(gctx).z() < surf2->center(gctx).z();
-              });
+    std::ranges::sort(surfaces, {}, [&gctx](const auto& s) {
+      assert(s != nullptr && "Uninitialized surface");
+      const auto& center = s->center(gctx);
+      return std::make_tuple(center.x(), center.y(), center.z());
+    });
 
     // Remove the duplicates
     surfaces.erase(std::unique(surfaces.begin(), surfaces.end()),

Core/include/Acts/Navigation/NavigationStateUpdaters.hpp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -20,6 +20,7 @@
 #include "Acts/Utilities/IAxis.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
 
+#include <algorithm>
 #include <array>
 #include <memory>
 
@@ -65,11 +66,9 @@ inline void intitializeCandidates(const GeometryContext& gctx,
     }
   }
 
-  std::sort(confirmedCandidates.begin(), confirmedCandidates.end(),
-            [&](const auto& a, const auto& b) {
-              return a.objectIntersection.pathLength() <
-                     b.objectIntersection.pathLength();
-            });
+  std::ranges::sort(confirmedCandidates, {}, [](const auto& c) {
+    return c.objectIntersection.pathLength();
+  });
 
   nState.surfaceCandidates = std::move(confirmedCandidates);
   nState.surfaceCandidateIndex = 0;

Core/include/Acts/Propagator/Navigator.hpp

@@ -20,6 +20,7 @@
 #include "Acts/Utilities/Logger.hpp"
 #include "Acts/Utilities/StringHelpers.hpp"
 
+#include <algorithm>
 #include <sstream>
 #include <string>
 
@@ -889,11 +890,10 @@ class Navigator {
               state.geoContext, stepper.position(state.stepping),
               state.options.direction * stepper.direction(state.stepping),
               navOpts, logger());
-      std::sort(state.navigation.navBoundaries.begin(),
-                state.navigation.navBoundaries.end(),
-                [](const auto& a, const auto& b) {
-                  return SurfaceIntersection::pathLengthOrder(a.first, b.first);
-                });
+      std::ranges::sort(
+          state.navigation.navBoundaries, [](const auto& a, const auto& b) {
+            return SurfaceIntersection::pathLengthOrder(a.first, b.first);
+          });
 
       // Print boundary information
       if (logger().doPrint(Logging::VERBOSE)) {
@@ -1011,9 +1011,8 @@ class Navigator {
     state.navigation.navSurfaces = currentLayer->compatibleSurfaces(
         state.geoContext, stepper.position(state.stepping),
         state.options.direction * stepper.direction(state.stepping), navOpts);
-    std::sort(state.navigation.navSurfaces.begin(),
-              state.navigation.navSurfaces.end(),
-              SurfaceIntersection::pathLengthOrder);
+    std::ranges::sort(state.navigation.navSurfaces,
+                      SurfaceIntersection::pathLengthOrder);
 
     // Print surface information
     if (logger().doPrint(Logging::VERBOSE)) {
@@ -1079,11 +1078,10 @@ class Navigator {
             state.geoContext, stepper.position(state.stepping),
             state.options.direction * stepper.direction(state.stepping),
             navOpts);
-    std::sort(state.navigation.navLayers.begin(),
-              state.navigation.navLayers.end(),
-              [](const auto& a, const auto& b) {
-                return SurfaceIntersection::pathLengthOrder(a.first, b.first);
-              });
+    std::ranges::sort(
+        state.navigation.navLayers, [](const auto& a, const auto& b) {
+          return SurfaceIntersection::pathLengthOrder(a.first, b.first);
+        });
 
     // Print layer information
     if (logger().doPrint(Logging::VERBOSE)) {

Core/include/Acts/Propagator/TryAllNavigator.hpp

@@ -354,8 +354,8 @@ class TryAllNavigator : public TryAllNavigatorBase {
       }
     }
 
-    std::sort(intersectionCandidates.begin(), intersectionCandidates.end(),
-              detail::IntersectionCandidate::forwardOrder);
+    std::ranges::sort(intersectionCandidates,
+                      detail::IntersectionCandidate::forwardOrder);
 
     ACTS_VERBOSE(volInfo(state) << "found " << intersectionCandidates.size()
                                 << " intersections");
@@ -766,9 +766,8 @@ class TryAllOverstepNavigator : public TryAllNavigatorBase {
         }
       }
 
-      std::sort(state.navigation.activeCandidates.begin(),
-                state.navigation.activeCandidates.end(),
-                detail::IntersectionCandidate::forwardOrder);
+      std::ranges::sort(state.navigation.activeCandidates,
+                        detail::IntersectionCandidate::forwardOrder);
 
       state.navigation.activeCandidateIndex = 0;
 

Core/include/Acts/Seeding/GbtsDataStorage.hpp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -105,8 +105,8 @@ class GbtsEtaBin {
   }
 
   void sortByPhi() {
-    std::sort(m_vn.begin(), m_vn.end(),
-              typename Acts::GbtsNode<space_point_t>::CompareByPhi());
+    std::ranges::sort(m_vn,
+                      typename Acts::GbtsNode<space_point_t>::CompareByPhi());
   }
 
   bool empty() const { return m_vn.empty(); }

Core/include/Acts/Seeding/GbtsTrackingFilter.hpp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -138,8 +138,8 @@ class GbtsTrackingFilter {
     if (m_stateVec.empty()) {
       return;
     }
-    std::sort(m_stateVec.begin(), m_stateVec.end(),
-              typename GbtsEdgeState<external_spacepoint_t>::Compare());
+    std::ranges::sort(m_stateVec,
+                      typename GbtsEdgeState<external_spacepoint_t>::Compare());
 
     GbtsEdgeState<external_spacepoint_t>* best = (*m_stateVec.begin());
 

Core/include/Acts/Seeding/HoughTransformUtils.ipp

@@ -1,12 +1,13 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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 http://mozilla.org/MPL/2.0/.
 
 #include <algorithm>
+#include <tuple>
 
 template <class identifier_t>
 template <class PointType>
@@ -263,16 +264,9 @@ Acts::HoughTransformUtils::PeakFinders::IslandsAroundMax<
     }
   }
   // sort the candidate cells descending in content
-  std::sort(candidates.begin(), candidates.end(),
-            [&yieldMap](const std::size_t bin1, const std::size_t bin2) {
-              YieldType h1 = yieldMap[bin1];
-              YieldType h2 = yieldMap[bin2];
-
-              if (h1 != h2) {
-                return h1 > h2;
-              }
-              return bin1 > bin2;
-            });
+  std::ranges::sort(candidates, std::greater{}, [&yieldMap](std::size_t c) {
+    return std::make_tuple(yieldMap[c], c);
+  });
 
   // now we build islands from the candidate cells, starting with the most
   // populated one

Core/include/Acts/Seeding/SeedFilter.ipp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 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
@@ -69,11 +69,10 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
 
   if (topSpVec.size() > 2) {
     // sort indexes based on comparing values in invHelixDiameterVec
-    std::sort(
-        topSPIndexVec.begin(), topSPIndexVec.end(),
-        [&invHelixDiameterVec](const std::size_t i1, const std::size_t i2) {
-          return invHelixDiameterVec[i1] < invHelixDiameterVec[i2];
-        });
+    std::ranges::sort(topSPIndexVec, {},
+                      [&invHelixDiameterVec](const std::size_t t) {
+                        return invHelixDiameterVec[t];
+                      });
   }
 
   // vector containing the radius of all compatible seeds

Core/include/Acts/Seeding/SeedFinder.ipp

@@ -496,17 +496,13 @@ SeedFinder<external_spacepoint_t, grid_t, platform_t>::filterCandidates(
 
   if constexpr (detailedMeasurement ==
                 Acts::DetectorMeasurementInfo::eDefault) {
-    std::sort(sorted_bottoms.begin(), sorted_bottoms.end(),
-              [&state](const std::size_t a, const std::size_t b) -> bool {
-                return state.linCircleBottom[a].cotTheta <
-                       state.linCircleBottom[b].cotTheta;
-              });
-
-    std::sort(sorted_tops.begin(), sorted_tops.end(),
-              [&state](const std::size_t a, const std::size_t b) -> bool {
-                return state.linCircleTop[a].cotTheta <
-                       state.linCircleTop[b].cotTheta;
-              });
+    std::ranges::sort(sorted_bottoms, {}, [&state](const std::size_t s) {
+      return state.linCircleBottom[s].cotTheta;
+    });
+
+    std::ranges::sort(sorted_tops, {}, [&state](const std::size_t s) {
+      return state.linCircleTop[s].cotTheta;
+    });
   }
 
   // Reserve enough space, in case current capacity is too little

Core/include/Acts/Seeding/SeedFinderGbts.ipp

@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -17,6 +17,7 @@
 #include "Acts/Seeding/SeedFinderUtils.hpp"
 #include "Acts/Utilities/BinningType.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <fstream>
 #include <functional>
@@ -352,8 +353,8 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
       out_sort[outIdx].first = pS->m_p[0];
     }
 
-    std::sort(in_sort.begin(), in_sort.end());
-    std::sort(out_sort.begin(), out_sort.end());
+    std::ranges::sort(in_sort);
+    std::ranges::sort(out_sort);
 
     unsigned int last_out = 0;
 
@@ -495,8 +496,8 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
   m_triplets.clear();
 
-  std::sort(vSeeds.begin(), vSeeds.end(),
-            typename Acts::GbtsEdge<external_spacepoint_t>::CompareLevel());
+  std::ranges::sort(
+      vSeeds, typename Acts::GbtsEdge<external_spacepoint_t>::CompareLevel());
 
   if (vSeeds.empty()) {
     return;