Core/EventData/SpacePointContainerEdmTests.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/EventData/SpacePointContainer.hpp"
0013 #include "Acts/Utilities/HashedString.hpp"
0014 #include "Acts/Utilities/Holders.hpp"
0015
0016 #include <any>
0017 #include <cmath>
0018 #include <iterator>
0019 #include <ranges>
0020 #include <vector>
0021
0022 namespace Acts::Test {
0023
0024 struct SpacePoint {
0025   SpacePoint() = default;
0026   SpacePoint(float ix, float iy, float iz, float ivarR, float ivarZ)
0027       : x(ix), y(iy), z(iz), varR(ivarR), varZ(ivarZ) {}
0028   float x{};
0029   float y{};
0030   float z{};
0031   float varR{};
0032   float varZ{};
0033 };
0034 using SpacePointCollection = std::vector<SpacePoint>;
0035
0036 class Adapter {
0037  public:
0038   friend Acts::SpacePointContainer<Adapter, Acts::detail::RefHolder>;
0039   friend Acts::SpacePointContainer<Adapter, Acts::detail::ValueHolder>;
0040   using value_type = SpacePoint;
0041   using ValueType = value_type;
0042
0043   Adapter(SpacePointCollection&&) = delete;
0044   explicit Adapter(const SpacePointCollection& externalCollection)
0045       : m_storage(&externalCollection) {}
0046
0047  private:
0048   std::size_t size_impl() const { return storage().size(); }
0049
0050   float x_impl(std::size_t idx) const { return storage()[idx].x; };
0051   float y_impl(std::size_t idx) const { return storage()[idx].y; };
0052   float z_impl(std::size_t idx) const { return storage()[idx].z; };
0053   float varianceR_impl(std::size_t idx) const { return storage()[idx].varR; }
0054   float varianceZ_impl(std::size_t idx) const { return storage()[idx].varZ; }
0055
0056   const SpacePoint& get_impl(std::size_t idx) const { return storage()[idx]; }
0057
0058   std::any component_impl(Acts::HashedString key, std::size_t /*n*/) const {
0059     using namespace Acts::HashedStringLiteral;
0060     switch (key) {
0061       case "TopStripVector"_hash:
0062       case "BottomStripVector"_hash:
0063       case "StripCenterDistance"_hash:
0064       case "TopStripCenterPosition"_hash:
0065         return Acts::Vector3(0., 0., 0.);
0066       default:
0067         throw std::runtime_error("no such component " + std::to_string(key));
0068     }
0069   }
0070
0071   const SpacePointCollection& storage() const { return *m_storage; }
0072
0073  private:
0074   const SpacePointCollection* m_storage{};
0075 };
0076
0077 BOOST_AUTO_TEST_CASE(spacepoint_container_edm_traits) {
0078   using adapter_t = Acts::Test::Adapter;
0079   using container_t =
0080       Acts::SpacePointContainer<adapter_t, Acts::detail::RefHolder>;
0081   using proxy_t = Acts::SpacePointProxy<container_t>;
0082   using iterator_t =
0083       Acts::ContainerIterator<container_t, proxy_t&, std::size_t, false>;
0084
0085   static_assert(std::ranges::range<container_t>);
0086   static_assert(std::same_as<typename iterator_t::iterator_category,
0087                              std::random_access_iterator_tag>);
0088   static_assert(
0089       std::same_as<typename std::iterator_traits<iterator_t>::iterator_category,
0090                    std::random_access_iterator_tag>);
0091 }
0092
0093 BOOST_AUTO_TEST_CASE(spacepoint_container_edm_constructors) {
0094   std::size_t nExternalPoints = 10;
0095   SpacePointCollection externalCollection(nExternalPoints);
0096
0097   Acts::SpacePointContainerConfig spConfig;
0098   Acts::SpacePointContainerOptions spOptions;
0099
0100   Acts::Test::Adapter adapterForRef(externalCollection);
0101   Acts::SpacePointContainer<Acts::Test::Adapter, Acts::detail::RefHolder>
0102       spContainerRef(spConfig, spOptions, adapterForRef);
0103
0104   Acts::SpacePointContainer<Acts::Test::Adapter, Acts::detail::ValueHolder>
0105       spContainerVal(spConfig, spOptions,
0106                      Acts::Test::Adapter(externalCollection));
0107
0108   BOOST_CHECK_EQUAL(spContainerRef.size(), nExternalPoints);
0109   BOOST_CHECK_EQUAL(spContainerVal.size(), nExternalPoints);
0110 }
0111
0112 BOOST_AUTO_TEST_CASE(spacepoint_container_edm_functionalities) {
0113   std::size_t nExternalPoints = 100;
0114   SpacePointCollection externalCollection;
0115   externalCollection.reserve(nExternalPoints);
0116   for (std::size_t i = 0; i < nExternalPoints; ++i) {
0117     externalCollection.emplace_back(1.f * i, 1.5f * i, 2.f * i, 2.5f * i,
0118                                     3.f * i);
0119   }
0120
0121   Acts::SpacePointContainerConfig spConfig;
0122   spConfig.useDetailedDoubleMeasurementInfo = true;
0123   Acts::SpacePointContainerOptions spOptions;
0124
0125   Acts::Test::Adapter adapter(externalCollection);
0126   Acts::SpacePointContainer<Acts::Test::Adapter, Acts::detail::RefHolder>
0127       spContainer(spConfig, spOptions, adapter);
0128
0129   BOOST_CHECK_EQUAL(spContainer.size(), nExternalPoints);
0130   BOOST_CHECK_EQUAL(spContainer.size(), externalCollection.size());
0131   BOOST_CHECK_EQUAL(spContainer.end() - spContainer.begin(), nExternalPoints);
0132   BOOST_CHECK_EQUAL(std::distance(spContainer.begin(), spContainer.end()),
0133                     nExternalPoints);
0134   BOOST_CHECK_EQUAL(std::distance(std::ranges::begin(spContainer),
0135                                   std::ranges::end(spContainer)),
0136                     nExternalPoints);
0137
0138   using proxy_t = Acts::SpacePointProxy<
0139       Acts::SpacePointContainer<Acts::Test::Adapter, Acts::detail::RefHolder>>;
0140   static_assert(std::same_as<typename decltype(spContainer)::ValueType,
0141                              Acts::Test::SpacePoint>);
0142   static_assert(
0143       std::same_as<typename decltype(spContainer)::ProxyType, proxy_t>);
0144   static_assert(
0145       std::same_as<typename decltype(spContainer)::value_type, proxy_t>);
0146   static_assert(
0147       std::same_as<typename proxy_t::ContainerType, decltype(spContainer)>);
0148   static_assert(
0149       std::same_as<typename proxy_t::ValueType, Acts::Test::SpacePoint>);
0150
0151   using iterator_t = Acts::ContainerIterator<decltype(spContainer), proxy_t&,
0152                                              std::size_t, false>;
0153   using const_iterator_t =
0154       Acts::ContainerIterator<decltype(spContainer), const proxy_t&,
0155                               std::size_t, true>;
0156   static_assert(
0157       std::same_as<iterator_t, typename decltype(spContainer)::iterator>);
0158   static_assert(std::same_as<const_iterator_t,
0159                              typename decltype(spContainer)::const_iterator>);
0160   static_assert(
0161       std::same_as<iterator_t, decltype(std::ranges::begin(spContainer))>);
0162   static_assert(
0163       std::same_as<const_iterator_t, decltype(std::cbegin(spContainer))>);
0164
0165   std::size_t n = 0ul;
0166   for (const proxy_t& proxy : spContainer) {
0167     float refX = 1.f * n;
0168     float refY = 1.5f * n;
0169     float refZ = 2.f * n;
0170     float refCovR = 2.5f * n;
0171     float refCovZ = 3.f * n;
0172     float refRadius = std::hypot(refX, refY);
0173     float refPhi = std::atan2(refY, refX);
0174
0175     BOOST_CHECK_EQUAL(proxy.index(), n);
0176     BOOST_CHECK_EQUAL(proxy.x(), refX);
0177     BOOST_CHECK_EQUAL(proxy.y(), refY);
0178     BOOST_CHECK_EQUAL(proxy.z(), refZ);
0179     BOOST_CHECK_EQUAL(proxy.radius(), refRadius);
0180     BOOST_CHECK_EQUAL(proxy.phi(), refPhi);
0181     BOOST_CHECK_EQUAL(proxy.varianceR(), refCovR);
0182     BOOST_CHECK_EQUAL(proxy.varianceZ(), refCovZ);
0183
0184     const Acts::Vector3& topStripVector = proxy.topStripVector();
0185     const Acts::Vector3& bottomStripVector = proxy.bottomStripVector();
0186     const Acts::Vector3& stripCenterDistance = proxy.stripCenterDistance();
0187     const Acts::Vector3& topStripCenterPosition =
0188         proxy.topStripCenterPosition();
0189
0190     for (std::size_t i = 0; i < 3; ++i) {
0191       BOOST_CHECK_EQUAL(topStripVector[i], 0.);
0192       BOOST_CHECK_EQUAL(bottomStripVector[i], 0.);
0193       BOOST_CHECK_EQUAL(stripCenterDistance[i], 0.);
0194       BOOST_CHECK_EQUAL(topStripCenterPosition[i], 0.);
0195     }
0196
0197     const Acts::Test::SpacePoint& sp = proxy.externalSpacePoint();
0198     BOOST_CHECK_EQUAL(&sp, &externalCollection[n]);
0199
0200     ++n;
0201   }
0202   BOOST_CHECK_EQUAL(n, nExternalPoints);
0203 }
0204
0205 }  // namespace Acts::Test