Merge branch 'main' into ref-cleanup-geo-conversion

Author: andiwand

Core/include/Acts/EventData/StripSpacePointCalibrationDetails.hpp

@@ -0,0 +1,47 @@
+// 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/.
+
+#pragma once
+
+#include <array>
+
+namespace Acts {
+
+/// Collection of outer strip space point details, used for the calibration.
+struct OuterStripSpacePointCalibrationDetails final {
+  /// Center of the outer strip.
+  std::array<float, 3> outerCenter;
+  /// Separation vector from the inner strip center to the outer strip center.
+  std::array<float, 3> innerToOuterSeparation;
+  /// Half vector of the outer strip, pointing from the center to one end of the
+  /// strip.
+  std::array<float, 3> outerHalfVector;
+  /// Half vector of the inner strip, pointing from the center to one end of the
+  /// strip.
+  std::array<float, 3> innerHalfVector;
+};
+
+/// Derived collection of outer strip space point details, used for the
+/// calibration.
+struct OuterStripSpacePointCalibrationDetailsDerived final {
+  /// Cross product of the separation vector from the inner strip center to the
+  /// outer strip center with the inner half vector.
+  std::array<float, 3> innerToOuterSeparationCrossInnerHalfVector;
+  /// Cross product of the separation vector from the inner strip center to the
+  /// outer strip center with the outer half vector.
+  std::array<float, 3> innerToOuterSeparationCrossOuterHalfVector;
+  /// Cross product of the inner half vector with the outer half vector.
+  std::array<float, 3> innerCrossOuterHalfVector;
+  /// Center of the outer strip.
+  std::array<float, 3> outerCenter;
+  /// Half vector of the outer strip, pointing from the center to one end of
+  /// the strip.
+  std::array<float, 3> outerHalfVector;
+};
+
+}  // namespace Acts

Core/include/Acts/SpacePointFormation2/StripSpacePointCalibration.hpp

@@ -0,0 +1,34 @@
+// 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/.
+
+#pragma once
+
+#include "Acts/EventData/StripSpacePointCalibrationDetails.hpp"
+
+#include <Eigen/Core>
+
+namespace Acts {
+
+/// Derives the strip space point calibration details.
+/// @param sp The strip space point calibration details
+/// @return The derived strip space point calibration details
+OuterStripSpacePointCalibrationDetailsDerived
+deriveOuterStripSpacePointCalibrationDetails(
+    const OuterStripSpacePointCalibrationDetails& sp);
+
+/// Calibrates the strip space point using the assumed particle direction and
+/// the strip space point calibration details.
+/// @note This function does not check if the calibrated space point lies within the strip.
+/// @param sp The strip space point calibration details
+/// @param direction The assumed particle direction
+/// @return The calibrated outer strip space point
+Eigen::Vector3f calibrateOuterStripSpacePoint(
+    const Eigen::Vector3f& direction,
+    const OuterStripSpacePointCalibrationDetailsDerived& sp);
+
+}  // namespace Acts

Core/include/Acts/SpacePointFormation2/detail/StripSpacePointCalibrationImpl.hpp

@@ -0,0 +1,84 @@
+// 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/.
+
+#pragma once
+
+#include "Acts/EventData/StripSpacePointCalibrationDetails.hpp"
+#include "Acts/Utilities/detail/StdArrayLinalg.hpp"
+
+#include <cmath>
+
+namespace Acts::detail {
+
+// Intentionally not using Eigen here as there is a noticeable performance
+// (10-20%) penalty for small vector sizes.
+
+inline OuterStripSpacePointCalibrationDetailsDerived
+deriveOuterStripSpacePointCalibrationDetails(const std::array<float, 3>& ihv,
+                                             const std::array<float, 3>& ohv,
+                                             const std::array<float, 3>& iosv,
+                                             const std::array<float, 3>& oc) {
+  OuterStripSpacePointCalibrationDetailsDerived result{};
+  result.innerCrossOuterHalfVector = stdArrayCross(ihv, ohv);
+  result.innerToOuterSeparationCrossOuterHalfVector = stdArrayCross(iosv, ohv);
+  result.innerToOuterSeparationCrossInnerHalfVector = stdArrayCross(iosv, ihv);
+  result.outerCenter = oc;
+  result.outerHalfVector = ohv;
+  return result;
+}
+
+inline OuterStripSpacePointCalibrationDetailsDerived
+deriveOuterStripSpacePointCalibrationDetails(
+    const OuterStripSpacePointCalibrationDetails& sp) {
+  return deriveOuterStripSpacePointCalibrationDetails(
+      sp.innerHalfVector, sp.outerHalfVector, sp.innerToOuterSeparation,
+      sp.outerCenter);
+}
+
+inline bool calibrateOuterStripSpacePoint(
+    const std::array<float, 3>& direction,
+    const std::array<float, 3>& ihvCrossOhv,
+    const std::array<float, 3>& iosvCrossOhv,
+    const std::array<float, 3>& iosvCrossIhv, const std::array<float, 3>& oc,
+    const std::array<float, 3>& ohv, std::array<float, 3>& calibrated,
+    const float tolerance) {
+  // scale = innerStripHalfVector dot (outerStripHalfVector cross direction)
+  const float scale = stdArrayDot(direction, ihvCrossOhv);
+
+  // sInner = innerToOuterSeparationVector dot (outerStripHalfVector cross
+  // direction) Check if direction is inside the inner detector element
+  const float sInner = stdArrayDot(direction, iosvCrossOhv);
+  if (std::abs(sInner) > std::abs(scale) * tolerance) {
+    return false;
+  }
+
+  // sOuter = innerToOuterSeparationVector dot (innerStripHalfVector cross
+  // direction) Check if direction is inside the outer detector element
+  const float sOuter = stdArrayDot(direction, iosvCrossIhv);
+  if (std::abs(sOuter) > std::abs(scale) * tolerance) {
+    return false;
+  }
+
+  // Corrected position using the outer strip center and direction
+  const float sOuterNorm = sOuter / scale;
+  calibrated = stdArrayAddScaled(oc, ohv, sOuterNorm);
+  return true;
+}
+
+inline bool calibrateOuterStripSpacePoint(
+    const std::array<float, 3>& direction,
+    const OuterStripSpacePointCalibrationDetailsDerived& sp,
+    std::array<float, 3>& calibrated, const float tolerance) {
+  return detail::calibrateOuterStripSpacePoint(
+      direction, sp.innerCrossOuterHalfVector,
+      sp.innerToOuterSeparationCrossOuterHalfVector,
+      sp.innerToOuterSeparationCrossInnerHalfVector, sp.outerCenter,
+      sp.outerHalfVector, calibrated, tolerance);
+}
+
+}  // namespace Acts::detail

Core/include/Acts/Utilities/detail/StdArrayLinalg.hpp

@@ -0,0 +1,77 @@
+// 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/.
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <span>
+
+#include <Eigen/Core>
+
+namespace Acts::detail {
+
+template <typename T, std::size_t N>
+std::array<T, N> stdArrayCopy(const std::span<const T, N> arr) {
+  std::array<T, N> result{};
+  for (std::size_t i = 0; i < N; ++i) {
+    result[i] = arr[i];
+  }
+  return result;
+}
+
+template <typename T, int N>
+std::array<T, N> stdArrayCopy(const Eigen::Vector<T, N>& arr)
+  requires(N > 0)
+{
+  std::array<T, N> result{};
+  for (std::size_t i = 0; i < N; ++i) {
+    result[i] = arr[i];
+  }
+  return result;
+}
+
+template <typename T, std::size_t N>
+Eigen::Vector<T, N> stdArrayToEigen(const std::array<T, N>& arr) {
+  Eigen::Vector<T, N> result;
+  for (std::size_t i = 0; i < N; ++i) {
+    result[i] = arr[i];
+  }
+  return result;
+}
+
+template <typename T, std::size_t N>
+std::array<T, N> stdArrayAddScaled(const std::array<T, N>& a,
+                                   const std::array<T, N>& b, const T scale) {
+  std::array<T, N> result{};
+  for (std::size_t i = 0; i < N; ++i) {
+    result[i] = a[i] + b[i] * scale;
+  }
+  return result;
+}
+
+template <typename T, std::size_t N>
+T stdArrayDot(const std::array<T, N>& a, const std::array<T, N>& b) {
+  T result = 0;
+  for (std::size_t i = 0; i < N; ++i) {
+    result += a[i] * b[i];
+  }
+  return result;
+}
+
+template <typename T>
+std::array<T, 3> stdArrayCross(const std::array<T, 3>& a,
+                               const std::array<T, 3>& b) {
+  std::array<T, 3> result{};
+  result[0] = a[1] * b[2] - a[2] * b[1];
+  result[1] = a[2] * b[0] - a[0] * b[2];
+  result[2] = a[0] * b[1] - a[1] * b[0];
+  return result;
+}
+
+}  // namespace Acts::detail