refactor: brace-enclosed initializers for pair/tuple returns

Core/include/Acts/EventData/MultiComponentTrackParameters.hpp

@@ -129,11 +129,11 @@ class MultiComponentBoundTrackParameters {
 
   /// Get the weight and a GenericBoundTrackParameters object for one component
   std::pair<double, Parameters> operator[](std::size_t i) const {
-    return std::make_pair(
+    return {
         std::get<double>(m_components[i]),
         Parameters(m_surface, std::get<BoundVector>(m_components[i]),
                    std::get<std::optional<BoundSquareMatrix>>(m_components[i]),
-                   m_particleHypothesis));
+                   m_particleHypothesis)};
   }
 
   /// Parameters vector.

Core/include/Acts/Seeding/BinnedGroupIterator.ipp

@@ -64,7 +64,7 @@ Acts::BinnedGroupIterator<grid_t>::operator*() const {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wstringop-overread"
 #endif
-  return std::make_tuple(std::move(bottoms), global_index, std::move(tops));
+  return {std::move(bottoms), global_index, std::move(tops)};
 #if defined(__GNUC__) && __GNUC__ >= 12 && !defined(__clang__)
 #pragma GCC diagnostic pop
 #endif

Core/include/Acts/Seeding/SeedFinder.ipp

@@ -839,7 +839,7 @@ std::pair<float, float> SeedFinder<external_spacepoint_t, grid_t, platform_t>::
         const external_spacepoint_t& spM,
         const Acts::Range1D<float>& rMiddleSPRange) const {
   if (m_config.useVariableMiddleSPRange) {
-    return std::make_pair(rMiddleSPRange.min(), rMiddleSPRange.max());
+    return {rMiddleSPRange.min(), rMiddleSPRange.max()};
   }
   if (!m_config.rRangeMiddleSP.empty()) {
     /// get zBin position of the middle SP
@@ -848,10 +848,9 @@ std::pair<float, float> SeedFinder<external_spacepoint_t, grid_t, platform_t>::
     int zBin = std::distance(m_config.zBinEdges.begin(), pVal);
     /// protects against zM at the limit of zBinEdges
     zBin == 0 ? zBin : --zBin;
-    return std::make_pair(m_config.rRangeMiddleSP[zBin][0],
-                          m_config.rRangeMiddleSP[zBin][1]);
+    return {m_config.rRangeMiddleSP[zBin][0], m_config.rRangeMiddleSP[zBin][1]};
   }
-  return std::make_pair(m_config.rMinMiddle, m_config.rMaxMiddle);
+  return {m_config.rMinMiddle, m_config.rMaxMiddle};
 }
 
 }  // namespace Acts

Core/include/Acts/TrackFitting/detail/KalmanGlobalCovariance.hpp

@@ -95,7 +95,7 @@ globalTrackParametersCovariance(const traj_t& multiTraj,
     prev_ts = ts;
   });
 
-  return std::make_pair(fullGlobalTrackParamsCov, stateRowIndices);
+  return {fullGlobalTrackParamsCov, stateRowIndices};
 }
 
 }  // namespace Acts::detail

Core/include/Acts/Utilities/GridBinFinder.ipp

@@ -45,9 +45,9 @@ std::array<std::pair<int, int>, DIM> Acts::GridBinFinder<DIM>::getSizePerAxis(
           using value_t = typename std::decay_t<decltype(val)>;
           if constexpr (std::is_same_v<int, value_t>) {
             assert(val >= 0);
-            return std::make_pair(-val, val);
+            return {-val, val};
           } else if constexpr (std::is_same_v<std::pair<int, int>, value_t>) {
-            return std::make_pair(-val.first, val.second);
+            return {-val.first, val.second};
           } else {
             assert(locPosition.size() > i);
             assert(locPosition[i] > 0ul);

Core/include/Acts/Utilities/TrackHelpers.hpp

@@ -209,7 +209,7 @@ findTrackStateForExtrapolation(
       }
 
       ACTS_VERBOSE("found intersection at " << intersection.pathLength());
-      return std::make_pair(*first, intersection.pathLength());
+      return std::pair(*first, intersection.pathLength());
     }
 
     case TrackExtrapolationStrategy::last: {
@@ -229,7 +229,7 @@ findTrackStateForExtrapolation(
       }
 
       ACTS_VERBOSE("found intersection at " << intersection.pathLength());
-      return std::make_pair(*last, intersection.pathLength());
+      return std::pair(*last, intersection.pathLength());
     }
 
     case TrackExtrapolationStrategy::firstOrLast: {
@@ -256,13 +256,13 @@ findTrackStateForExtrapolation(
       if (intersectionFirst.isValid() && absDistanceFirst <= absDistanceLast) {
         ACTS_VERBOSE("using first track state with intersection at "
                      << intersectionFirst.pathLength());
-        return std::make_pair(*first, intersectionFirst.pathLength());
+        return std::pair(*first, intersectionFirst.pathLength());
       }
 
       if (intersectionLast.isValid() && absDistanceLast <= absDistanceFirst) {
         ACTS_VERBOSE("using last track state with intersection at "
                      << intersectionLast.pathLength());
-        return std::make_pair(*last, intersectionLast.pathLength());
+        return std::pair(*last, intersectionLast.pathLength());
       }
 
       ACTS_ERROR("no intersection found");
@@ -530,7 +530,7 @@ calculatePredictedResidual(track_state_proxy_t trackState) {
   MeasurementMatrix residualCovariance =
       measurementCovariance + predictedCovariance;
 
-  return std::pair(residual, residualCovariance);
+  return {residual, residualCovariance};
 }
 
 /// Helper function to calculate the filtered residual and its covariance
@@ -566,7 +566,7 @@ calculateFilteredResidual(track_state_proxy_t trackState) {
   MeasurementMatrix residualCovariance =
       measurementCovariance + filteredCovariance;
 
-  return std::pair(residual, residualCovariance);
+  return {residual, residualCovariance};
 }
 
 /// Helper function to calculate the smoothed residual and its covariance
@@ -602,7 +602,7 @@ calculateSmoothedResidual(track_state_proxy_t trackState) {
   MeasurementMatrix residualCovariance =
       measurementCovariance + smoothedCovariance;
 
-  return std::pair(residual, residualCovariance);
+  return {residual, residualCovariance};
 }
 
 /// Helper function to calculate the predicted chi2

Core/src/Propagator/detail/CovarianceEngine.cpp

@@ -97,8 +97,7 @@ CurvilinearState detail::curvilinearState(
       pos4, direction, freeParameters[eFreeQOverP], std::move(cov),
       particleHypothesis);
   // Create the curvilinear state
-  return std::make_tuple(std::move(curvilinearParams), fullTransportJacobian,
-                         accumulatedPath);
+  return {std::move(curvilinearParams), fullTransportJacobian, accumulatedPath};
 }
 
 void detail::transportCovarianceToBound(

Core/src/Propagator/detail/SympyCovarianceEngine.cpp

@@ -86,8 +86,7 @@ CurvilinearState sympy::curvilinearState(
       pos4, direction, freeParameters[eFreeQOverP], std::move(cov),
       particleHypothesis);
   // Create the curvilinear state
-  return std::make_tuple(std::move(curvilinearParams), fullTransportJacobian,
-                         accumulatedPath);
+  return {std::move(curvilinearParams), fullTransportJacobian, accumulatedPath};
 }
 
 void sympy::transportCovarianceToBound(

Core/src/Surfaces/detail/AlignmentHelper.cpp

@@ -87,6 +87,6 @@ Acts::detail::RotationToAxes Acts::detail::rotationToLocalAxesDerivative(
                     rotToCompositeLocalYAxis * relRotation(1, 2) +
                     rotToCompositeLocalZAxis * relRotation(2, 2);
 
-  return std::make_tuple(std::move(rotToLocalXAxis), std::move(rotToLocalYAxis),
-                         std::move(rotToLocalZAxis));
+  return {std::move(rotToLocalXAxis), std::move(rotToLocalYAxis),
+          std::move(rotToLocalZAxis)};
 }

Core/src/Surfaces/detail/AnnulusBoundsHelper.cpp

@@ -63,5 +63,5 @@ Acts::detail::AnnulusBoundsHelper::create(const Transform3& transform,
   auto annulusBounds = std::make_shared<AnnulusBounds>(
       rMin, rMax, phiMin, phiMax, originShift, phiShift);
 
-  return std::make_tuple(annulusBounds, boundsTransform);
+  return {annulusBounds, boundsTransform};
 }

Core/src/Utilities/SpacePointUtility.cpp

@@ -99,7 +99,7 @@ SpacePointUtility::globalCoords(
     tcov = std::nullopt;
   }
 
-  return std::make_tuple(globalPos, globalTime, gcov, tcov);
+  return {globalPos, globalTime, gcov, tcov};
 }
 
 Vector2 SpacePointUtility::calcRhoZVars(

Core/src/Vertexing/AdaptiveGridTrackDensity.cpp

@@ -156,7 +156,7 @@ AdaptiveGridTrackDensity::getMaxZTPosition(DensityMap& densityMap) const {
   double maxZ = getSpatialBinCenter(bin.first);
   double maxT = getTemporalBinCenter(bin.second);
 
-  return std::make_pair(maxZ, maxT);
+  return std::pair(maxZ, maxT);
 }
 
 Result<AdaptiveGridTrackDensity::ZTPositionAndWidth>

Core/src/Vertexing/ImpactPointEstimator.cpp

@@ -217,7 +217,7 @@ Result<std::pair<Vector4, Vector3>> getDistanceAndMomentumImpl(
     Vector4 deltaRStraightTrack{Vector4::Zero()};
     deltaRStraightTrack.head<nDim>() = pcaStraightTrack - vtxPos;
 
-    return std::make_pair(deltaRStraightTrack, momDirStraightTrack);
+    return std::pair(deltaRStraightTrack, momDirStraightTrack);
   }
 
   // Charged particles in a constant B field follow a helical trajectory. In
@@ -291,7 +291,7 @@ Result<std::pair<Vector4, Vector3>> getDistanceAndMomentumImpl(
   Vector4 deltaR{Vector4::Zero()};
   deltaR.head<nDim>() = pca - vtxPos;
 
-  return std::make_pair(deltaR, momDir);
+  return std::pair(deltaR, momDir);
 }
 
 }  // namespace

Core/src/Vertexing/Vertex.cpp

@@ -74,7 +74,7 @@ const std::vector<TrackAtVertex>& Vertex::tracks() const {
 }
 
 std::pair<double, double> Vertex::fitQuality() const {
-  return std::pair<double, double>(m_chiSquared, m_numberDoF);
+  return {m_chiSquared, m_numberDoF};
 }
 
 void Vertex::setPosition(const Vector3& position) {

Examples/Detectors/ContextualDetector/src/AlignedDetector.cpp

@@ -106,8 +106,7 @@ auto AlignedDetector::finalize(
   }
 
   // return the pair of geometry and the alignment decorator(s)
-  return std::make_pair<TrackingGeometryPtr, ContextDecorators>(
-      std::move(aTrackingGeometry), std::move(aContextDecorators));
+  return {std::move(aTrackingGeometry), std::move(aContextDecorators)};
 }
 
 }  // namespace ActsExamples

Examples/Detectors/DD4hepDetector/src/DD4hepDetector.cpp

@@ -42,8 +42,7 @@ auto DD4hepDetector::finalize(
   }
   ContextDecorators dd4ContextDecorators = {};
   // return the pair of geometry and empty decorators
-  return std::make_pair<TrackingGeometryPtr, ContextDecorators>(
-      std::move(dd4tGeometry), std::move(dd4ContextDecorators));
+  return {std::move(dd4tGeometry), std::move(dd4ContextDecorators)};
 }
 
 auto DD4hepDetector::finalize(

Examples/Detectors/GenericDetector/src/GenericDetector.cpp

@@ -27,8 +27,7 @@ auto GenericDetector::finalize(
           cfg.volumeLogLevel);
   ContextDecorators gContextDecorators = {};
   // return the pair of geometry and empty decorators
-  return std::make_pair<TrackingGeometryPtr, ContextDecorators>(
-      std::move(gGeometry), std::move(gContextDecorators));
+  return {std::move(gGeometry), std::move(gContextDecorators)};
 }
 
 }  // namespace ActsExamples

Examples/Detectors/TGeoDetector/src/TGeoDetector.cpp

@@ -375,8 +375,7 @@ auto TGeoDetector::finalize(
 
   ContextDecorators tgeoContextDecorators = {};
   // Return the pair of geometry and empty decorators
-  return std::make_pair<TrackingGeometryPtr, ContextDecorators>(
-      std::move(tgeoTrackingGeometry), std::move(tgeoContextDecorators));
+  return {std::move(tgeoTrackingGeometry), std::move(tgeoContextDecorators)};
 }
 
 void TGeoDetector::Config::readJson(const std::string& jsonFile) {

Examples/Detectors/TelescopeDetector/src/TelescopeDetector.cpp

@@ -61,8 +61,7 @@ auto TelescopeDetector::finalize(
                              static_cast<Acts::BinningValue>(cfg.binValue));
   ContextDecorators gContextDecorators = {};
   // return the pair of geometry and empty decorators
-  return std::make_pair<TrackingGeometryPtr, ContextDecorators>(
-      std::move(gGeometry), std::move(gContextDecorators));
+  return {std::move(gGeometry), std::move(gContextDecorators)};
 }
 
 }  // namespace ActsExamples

Examples/Framework/src/EventData/ScalingCalibrator.cpp

@@ -52,22 +52,22 @@ std::pair<Acts::GeometryIdentifier, std::string> parseMapKey(
   std::regex reg("^map_([0-9]+)-([0-9]+)-([0-9]+)_([xy]_.*)$");
   std::smatch matches;
 
-  if (std::regex_search(mapkey, matches, reg) && matches.size() == 5) {
-    std::size_t vol = std::stoull(matches[1].str());
-    std::size_t lyr = std::stoull(matches[2].str());
-    std::size_t mod = std::stoull(matches[3].str());
+  if (!std::regex_search(mapkey, matches, reg) || matches.size() != 5) {
+    throw std::runtime_error("Invalid map key: " + mapkey);
+  }
 
-    Acts::GeometryIdentifier geoId;
-    geoId.setVolume(vol);
-    geoId.setLayer(lyr);
-    geoId.setSensitive(mod);
+  std::size_t vol = std::stoull(matches[1].str());
+  std::size_t lyr = std::stoull(matches[2].str());
+  std::size_t mod = std::stoull(matches[3].str());
 
-    std::string var(matches[4].str());
+  Acts::GeometryIdentifier geoId;
+  geoId.setVolume(vol);
+  geoId.setLayer(lyr);
+  geoId.setSensitive(mod);
 
-    return std::make_pair(geoId, var);
-  } else {
-    throw std::runtime_error("Invalid map key: " + mapkey);
-  }
+  std::string var(matches[4].str());
+
+  return {geoId, var};
 }
 
 std::map<Acts::GeometryIdentifier, ActsExamples::ScalingCalibrator::MapTuple>

Examples/Framework/src/Utilities/Paths.cpp

@@ -110,7 +110,7 @@ std::pair<std::size_t, std::size_t> ActsExamples::determineEventFilesRange(
 
   // should only occur if no files matched and the initial values persisted.
   if (eventMax < eventMin) {
-    return std::make_pair(0u, 0u);
+    return {0u, 0u};
   }
-  return std::make_pair(eventMin, eventMax + 1);
+  return {eventMin, eventMax + 1};
 }

Examples/Io/Root/include/ActsExamples/Io/Root/RootMaterialDecorator.hpp

@@ -128,7 +128,7 @@ class RootMaterialDecorator : public Acts::IMaterialDecorator {
 
   /// Return the maps
   const Acts::DetectorMaterialMaps materialMaps() const {
-    return std::make_pair(m_surfaceMaterialMap, m_volumeMaterialMap);
+    return {m_surfaceMaterialMap, m_volumeMaterialMap};
   }
 
   /// Get readonly access to the config parameters

Examples/Io/Root/src/RootNuclearInteractionParametersWriter.cpp

@@ -121,7 +121,7 @@ buildNotNormalisedMap(TH1F const* hist) {
   if (integral == 0.) {
     histoBorders.clear();
     temp_HistoContents.clear();
-    return std::make_tuple(histoBorders, temp_HistoContents, integral);
+    return {histoBorders, temp_HistoContents, integral};
   }
 
   // Set the bin borders
@@ -130,7 +130,7 @@ buildNotNormalisedMap(TH1F const* hist) {
   }
   histoBorders[nBins] = hist->GetXaxis()->GetXmax();
 
-  return std::make_tuple(histoBorders, temp_HistoContents, integral);
+  return {histoBorders, temp_HistoContents, integral};
 }
 
 /// @brief This function combines neighbouring bins with the same value
@@ -169,7 +169,7 @@ std::pair<std::vector<float>, std::vector<std::uint32_t>> buildMap(
 
   // Fast exit if the histogram is empty
   if (histoContents.empty()) {
-    return std::make_pair(std::get<0>(map), std::vector<std::uint32_t>());
+    return {std::get<0>(map), std::vector<std::uint32_t>()};
   }
 
   // Set the bin content
@@ -183,7 +183,7 @@ std::pair<std::vector<float>, std::vector<std::uint32_t>> buildMap(
 
   auto histoBorders = std::get<0>(map);
   reduceMap(histoBorders, normalisedHistoContents);
-  return std::make_pair(histoBorders, normalisedHistoContents);
+  return {histoBorders, normalisedHistoContents};
 }
 
 /// @brief This method transforms a probability distribution into components
@@ -208,7 +208,7 @@ std::pair<std::vector<float>, std::vector<std::uint32_t>> buildMap(
 
   // Fast exit if the histogram is empty
   if (histoContents.empty()) {
-    return std::make_pair(std::get<0>(map), std::vector<std::uint32_t>());
+    return {std::get<0>(map), std::vector<std::uint32_t>()};
   }
 
   // Set the bin content
@@ -223,7 +223,7 @@ std::pair<std::vector<float>, std::vector<std::uint32_t>> buildMap(
   std::vector<float> histoBorders = std::get<0>(map);
   reduceMap(histoBorders, normalisedHistoContents);
 
-  return std::make_pair(histoBorders, normalisedHistoContents);
+  return {histoBorders, normalisedHistoContents};
 }
 
 /// @brief This method builds decomposed cumulative probability distributions

Examples/Io/Root/src/RootTrackStatesWriter.cpp

@@ -471,13 +471,13 @@ ProcessCode RootTrackStatesWriter::writeT(const AlgorithmContext& ctx,
       auto getTrackParams = [&](unsigned int ipar)
           -> std::optional<std::pair<Acts::BoundVector, Acts::BoundMatrix>> {
         if (ipar == ePredicted && state.hasPredicted()) {
-          return std::make_pair(state.predicted(), state.predictedCovariance());
+          return std::pair(state.predicted(), state.predictedCovariance());
         }
         if (ipar == eFiltered && state.hasFiltered()) {
-          return std::make_pair(state.filtered(), state.filteredCovariance());
+          return std::pair(state.filtered(), state.filteredCovariance());
         }
         if (ipar == eSmoothed && state.hasSmoothed()) {
-          return std::make_pair(state.smoothed(), state.smoothedCovariance());
+          return std::pair(state.smoothed(), state.smoothedCovariance());
         }
         if (ipar == eUnbiased && state.hasSmoothed() && state.hasProjector() &&
             state.hasCalibrated()) {