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 using namespace Acts;
0023
0024 namespace ActsTests {
0025
0026 struct SpacePoint {
0027   SpacePoint() = default;
0028   SpacePoint(float ix, float iy, float iz, float ivarR, float ivarZ)
0029       : x(ix), y(iy), z(iz), varR(ivarR), varZ(ivarZ) {}
0030   float x{};
0031   float y{};
0032   float z{};
0033   float varR{};
0034   float varZ{};
0035 };
0036 using SpacePointCollection = std::vector<SpacePoint>;
0037
0038 class Adapter {
0039  public:
0040   friend SpacePointContainer<Adapter, detail::RefHolder>;
0041   friend SpacePointContainer<Adapter, detail::ValueHolder>;
0042   using value_type = SpacePoint;
0043   using ValueType = value_type;
0044
0045   Adapter(SpacePointCollection&&) = delete;
0046   explicit Adapter(const SpacePointCollection& externalCollection)
0047       : m_storage(&externalCollection) {}
0048
0049  private:
0050   std::size_t size_impl() const { return storage().size(); }
0051
0052   float x_impl(std::size_t idx) const { return storage()[idx].x; };
0053   float y_impl(std::size_t idx) const { return storage()[idx].y; };
0054   float z_impl(std::size_t idx) const { return storage()[idx].z; };
0055   float varianceR_impl(std::size_t idx) const { return storage()[idx].varR; }
0056   float varianceZ_impl(std::size_t idx) const { return storage()[idx].varZ; }
0057
0058   const SpacePoint& get_impl(std::size_t idx) const { return storage()[idx]; }
0059
0060   std::any component_impl(HashedString key, std::size_t /*n*/) const {
0061     using namespace HashedStringLiteral;
0062     switch (key) {
0063       case "TopStripVector"_hash:
0064       case "BottomStripVector"_hash:
0065       case "StripCenterDistance"_hash:
0066       case "TopStripCenterPosition"_hash:
0067         return Vector3(0., 0., 0.);
0068       default:
0069         throw std::runtime_error("no such component " + std::to_string(key));
0070     }
0071   }
0072
0073   const SpacePointCollection& storage() const { return *m_storage; }
0074
0075  private:
0076   const SpacePointCollection* m_storage{};
0077 };
0078
0079 BOOST_AUTO_TEST_SUITE(EventDataSuite)
0080
0081 BOOST_AUTO_TEST_CASE(spacepoint_container_edm_traits) {
0082   using adapter_t = Adapter;
0083   using container_t = SpacePointContainer<adapter_t, detail::RefHolder>;
0084   using proxy_t = SpacePointProxy<container_t>;
0085   using iterator_t =
0086       detail::ContainerIterator<container_t, proxy_t&, std::size_t, false>;
0087
0088   static_assert(std::ranges::range<container_t>);
0089   static_assert(std::same_as<typename iterator_t::iterator_category,
0090                              std::random_access_iterator_tag>);
0091   static_assert(
0092       std::same_as<typename std::iterator_traits<iterator_t>::iterator_category,
0093                    std::random_access_iterator_tag>);
0094 }
0095
0096 BOOST_AUTO_TEST_CASE(spacepoint_container_edm_constructors) {
0097   std::size_t nExternalPoints = 10;
0098   SpacePointCollection externalCollection(nExternalPoints);
0099
0100   SpacePointContainerConfig spConfig;
0101   SpacePointContainerOptions spOptions;
0102
0103   Adapter adapterForRef(externalCollection);
0104   SpacePointContainer<Adapter, detail::RefHolder> spContainerRef(
0105       spConfig, spOptions, adapterForRef);
0106
0107   SpacePointContainer<Adapter, detail::ValueHolder> spContainerVal(
0108       spConfig, spOptions, Adapter(externalCollection));
0109
0110   BOOST_CHECK_EQUAL(spContainerRef.size(), nExternalPoints);
0111   BOOST_CHECK_EQUAL(spContainerVal.size(), nExternalPoints);
0112 }
0113
0114 BOOST_AUTO_TEST_CASE(spacepoint_container_edm_functionalities) {
0115   std::size_t nExternalPoints = 100;
0116   SpacePointCollection externalCollection;
0117   externalCollection.reserve(nExternalPoints);
0118   for (std::size_t i = 0; i < nExternalPoints; ++i) {
0119     externalCollection.emplace_back(1.f * i, 1.5f * i, 2.f * i, 2.5f * i,
0120                                     3.f * i);
0121   }
0122
0123   SpacePointContainerConfig spConfig;
0124   spConfig.useDetailedDoubleMeasurementInfo = true;
0125   SpacePointContainerOptions spOptions;
0126
0127   Adapter adapter(externalCollection);
0128   SpacePointContainer<Adapter, detail::RefHolder> spContainer(
0129       spConfig, spOptions, adapter);
0130
0131   BOOST_CHECK_EQUAL(spContainer.size(), nExternalPoints);
0132   BOOST_CHECK_EQUAL(spContainer.size(), externalCollection.size());
0133   BOOST_CHECK_EQUAL(spContainer.end() - spContainer.begin(), nExternalPoints);
0134   BOOST_CHECK_EQUAL(std::distance(spContainer.begin(), spContainer.end()),
0135                     nExternalPoints);
0136   BOOST_CHECK_EQUAL(std::distance(std::ranges::begin(spContainer),
0137                                   std::ranges::end(spContainer)),
0138                     nExternalPoints);
0139
0140   using proxy_t =
0141       SpacePointProxy<SpacePointContainer<Adapter, detail::RefHolder>>;
0142   static_assert(
0143       std::same_as<typename decltype(spContainer)::ValueType, SpacePoint>);
0144   static_assert(
0145       std::same_as<typename decltype(spContainer)::ProxyType, proxy_t>);
0146   static_assert(
0147       std::same_as<typename decltype(spContainer)::value_type, proxy_t>);
0148   static_assert(
0149       std::same_as<typename proxy_t::ContainerType, decltype(spContainer)>);
0150   static_assert(std::same_as<typename proxy_t::ValueType, SpacePoint>);
0151
0152   using iterator_t = detail::ContainerIterator<decltype(spContainer), proxy_t&,
0153                                                std::size_t, false>;
0154   using const_iterator_t =
0155       detail::ContainerIterator<decltype(spContainer), const proxy_t&,
0156                                 std::size_t, true>;
0157   static_assert(
0158       std::same_as<iterator_t, typename decltype(spContainer)::iterator>);
0159   static_assert(std::same_as<const_iterator_t,
0160                              typename decltype(spContainer)::const_iterator>);
0161   static_assert(
0162       std::same_as<iterator_t, decltype(std::ranges::begin(spContainer))>);
0163   static_assert(
0164       std::same_as<const_iterator_t, decltype(std::cbegin(spContainer))>);
0165
0166   std::size_t n = 0ul;
0167   for (const proxy_t& proxy : spContainer) {
0168     float refX = 1.f * n;
0169     float refY = 1.5f * n;
0170     float refZ = 2.f * n;
0171     float refCovR = 2.5f * n;
0172     float refCovZ = 3.f * n;
0173     float refRadius = std::hypot(refX, refY);
0174     float refPhi = std::atan2(refY, refX);
0175
0176     BOOST_CHECK_EQUAL(proxy.index(), n);
0177     BOOST_CHECK_EQUAL(proxy.x(), refX);
0178     BOOST_CHECK_EQUAL(proxy.y(), refY);
0179     BOOST_CHECK_EQUAL(proxy.z(), refZ);
0180     BOOST_CHECK_EQUAL(proxy.radius(), refRadius);
0181     BOOST_CHECK_EQUAL(proxy.phi(), refPhi);
0182     BOOST_CHECK_EQUAL(proxy.varianceR(), refCovR);
0183     BOOST_CHECK_EQUAL(proxy.varianceZ(), refCovZ);
0184
0185     const Vector3& topStripVector = proxy.topStripVector();
0186     const Vector3& bottomStripVector = proxy.bottomStripVector();
0187     const Vector3& stripCenterDistance = proxy.stripCenterDistance();
0188     const Vector3& topStripCenterPosition = 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 SpacePoint& sp = proxy.externalSpacePoint();
0198     BOOST_CHECK_EQUAL(&sp, &externalCollection[n]);
0199
0200     ++n;
0201   }
0202   BOOST_CHECK_EQUAL(n, nExternalPoints);
0203 }
0204
0205 BOOST_AUTO_TEST_SUITE_END()
0206
0207 }  // namespace ActsTests