Core/EventData/SpacePointContainerTests.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/EventData/SourceLink.hpp"
0012 #include "Acts/EventData/SpacePointColumnProxy.hpp"
0013 #include "Acts/EventData/SpacePointContainer.hpp"
0014 #include "Acts/EventData/Types.hpp"
0015
0016 #include <stdexcept>
0017
0018 #include <boost/core/no_exceptions_support.hpp>
0019
0020 using namespace Acts;
0021
0022 namespace ActsTests {
0023
0024 BOOST_AUTO_TEST_SUITE(EventDataSuite)
0025
0026 BOOST_AUTO_TEST_CASE(Empty) {
0027   SpacePointContainer container;
0028
0029   BOOST_CHECK(container.empty());
0030   BOOST_CHECK_EQUAL(container.size(), 0u);
0031
0032   for ([[maybe_unused]] auto _ : container) {
0033     BOOST_FAIL("Container should be empty, no space points should be iterated");
0034   }
0035 }
0036
0037 BOOST_AUTO_TEST_CASE(Create) {
0038   SpacePointContainer container(SpacePointColumns::SourceLinks |
0039                                 SpacePointColumns::X | SpacePointColumns::Y |
0040                                 SpacePointColumns::Z);
0041   container.reserve(1);
0042
0043   {
0044     MutableSpacePointProxy sp = container.createSpacePoint();
0045     sp.assignSourceLinks(std::array<SourceLink, 1>{SourceLink(42)});
0046     sp.x() = 1;
0047     sp.y() = 2;
0048     sp.z() = 3;
0049   }
0050
0051   BOOST_CHECK(!container.empty());
0052   BOOST_CHECK_EQUAL(container.size(), 1u);
0053
0054   {
0055     MutableSpacePointProxy sp = container.at(0);
0056     BOOST_CHECK_EQUAL(sp.x(), 1);
0057     BOOST_CHECK_EQUAL(sp.y(), 2);
0058     BOOST_CHECK_EQUAL(sp.z(), 3);
0059     BOOST_CHECK_EQUAL(sp.sourceLinks().size(), 1u);
0060     BOOST_CHECK_EQUAL(sp.sourceLinks()[0].get<int>(), 42);
0061   }
0062 }
0063
0064 BOOST_AUTO_TEST_CASE(Iterate) {
0065   SpacePointContainer container(SpacePointColumns::SourceLinks |
0066                                 SpacePointColumns::X | SpacePointColumns::Y |
0067                                 SpacePointColumns::Z);
0068   container.reserve(1);
0069
0070   MutableSpacePointProxy sp = container.createSpacePoint();
0071   sp.assignSourceLinks(std::array<SourceLink, 1>{SourceLink(42)});
0072   sp.x() = 1;
0073   sp.y() = 2;
0074   sp.z() = 3;
0075
0076   auto it = container.begin();
0077   BOOST_CHECK(it != container.end());
0078   BOOST_CHECK_EQUAL((*it).x(), 1);
0079   ++it;
0080   BOOST_CHECK(it == container.end());
0081 }
0082
0083 BOOST_AUTO_TEST_CASE(CopyAndMove) {
0084   SpacePointContainer container;
0085   container.reserve(1);
0086
0087   container.createSpacePoint();
0088
0089   SpacePointContainer containerCopy = container;
0090   BOOST_CHECK(!containerCopy.empty());
0091   BOOST_CHECK_EQUAL(containerCopy.size(), 1u);
0092
0093   SpacePointContainer containerMove = std::move(container);
0094   BOOST_CHECK(!containerMove.empty());
0095   BOOST_CHECK_EQUAL(containerMove.size(), 1u);
0096   // original should be empty after move
0097   BOOST_CHECK(container.empty());
0098   BOOST_CHECK_EQUAL(container.size(), 0u);
0099   // copy should be unchanged
0100   BOOST_CHECK(!containerCopy.empty());
0101   BOOST_CHECK_EQUAL(containerCopy.size(), 1u);
0102 }
0103
0104 BOOST_AUTO_TEST_CASE(Clear) {
0105   SpacePointContainer container;
0106   container.reserve(1);
0107
0108   container.createSpacePoint();
0109
0110   container.clear();
0111
0112   BOOST_CHECK(container.empty());
0113   BOOST_CHECK_EQUAL(container.size(), 0u);
0114   for ([[maybe_unused]] auto _ : container) {
0115     BOOST_FAIL("Container should be empty, no space points should be iterated");
0116   }
0117 }
0118
0119 BOOST_AUTO_TEST_CASE(KnownExtraColumns) {
0120   SpacePointContainer container;
0121
0122   BOOST_CHECK(
0123       !container.hasColumns(SpacePointColumns::R | SpacePointColumns::Phi));
0124
0125   container.createColumns(SpacePointColumns::R | SpacePointColumns::Phi);
0126
0127   BOOST_CHECK(
0128       container.hasColumns(SpacePointColumns::R | SpacePointColumns::Phi));
0129
0130   MutableSpacePointProxy sp = container.createSpacePoint();
0131   sp.r() = 100;
0132
0133   BOOST_CHECK_EQUAL(sp.r(), 100);
0134   BOOST_CHECK_EQUAL(sp.phi(), 0);
0135 }
0136
0137 BOOST_AUTO_TEST_CASE(NamedExtraColumns) {
0138   SpacePointContainer container;
0139   const SpacePointContainer &constContainer = container;
0140
0141   BOOST_CHECK(!container.hasColumn("extra1"));
0142   BOOST_CHECK(!container.hasColumn("extra2"));
0143
0144   MutableSpacePointColumnProxy<int> extra1Mutable1 =
0145       container.createColumn<int>("extra1");
0146   MutableSpacePointColumnProxy<int> extra1Mutable2 =
0147       container.column<int>("extra1");
0148   ConstSpacePointColumnProxy<int> extra1Const1 = extra1Mutable1.asConst();
0149   ConstSpacePointColumnProxy<int> extra1Const2 =
0150       constContainer.column<int>("extra1");
0151
0152   BOOST_CHECK(container.hasColumn("extra1"));
0153   BOOST_CHECK(!container.hasColumn("extra2"));
0154
0155   MutableSpacePointProxy sp = container.createSpacePoint();
0156   sp.extra(extra1Mutable1) = 100;
0157
0158   BOOST_CHECK_EQUAL(sp.extra(extra1Mutable1), 100);
0159   BOOST_CHECK_EQUAL(sp.extra(extra1Mutable2), 100);
0160   BOOST_CHECK_EQUAL(sp.extra(extra1Const1), 100);
0161   BOOST_CHECK_EQUAL(sp.extra(extra1Const2), 100);
0162
0163   auto extra2 = container.createColumn<int>("extra2");
0164
0165   BOOST_CHECK(container.hasColumn("extra1"));
0166   BOOST_CHECK(container.hasColumn("extra2"));
0167
0168   BOOST_CHECK_EQUAL(sp.extra(extra2), 0);
0169 }
0170
0171 BOOST_AUTO_TEST_CASE(ThrowOnCreateReservedColumn) {
0172   BOOST_CHECK_THROW(SpacePointContainer().createColumn<int>("x"),
0173                     std::runtime_error);
0174   BOOST_CHECK_THROW(SpacePointContainer().createColumn<int>("r"),
0175                     std::runtime_error);
0176 }
0177
0178 BOOST_AUTO_TEST_CASE(ThrowOnDropReservedColumn) {
0179   BOOST_CHECK_THROW(SpacePointContainer().dropColumn("x"), std::runtime_error);
0180 }
0181
0182 BOOST_AUTO_TEST_CASE(ThrowOnDropNonExistingColumn) {
0183   BOOST_CHECK_THROW(SpacePointContainer().dropColumn("foo"),
0184                     std::runtime_error);
0185 }
0186
0187 BOOST_AUTO_TEST_CASE(ZipIterate) {
0188   SpacePointContainer container(SpacePointColumns::X | SpacePointColumns::Y |
0189                                 SpacePointColumns::Z);
0190   container.reserve(3);
0191
0192   MutableSpacePointProxy sp1 = container.createSpacePoint();
0193   sp1.x() = 1;
0194   sp1.y() = 2;
0195   sp1.z() = 3;
0196
0197   MutableSpacePointProxy sp2 = container.createSpacePoint();
0198   sp2.x() = 4;
0199   sp2.y() = 5;
0200   sp2.z() = 6;
0201
0202   MutableSpacePointProxy sp3 = container.createSpacePoint();
0203   sp3.x() = 7;
0204   sp3.y() = 8;
0205   sp3.z() = 9;
0206
0207   BOOST_CHECK_EQUAL(container.size(), 3u);
0208
0209   SpacePointIndex checkIndex = 0;
0210   for (auto [i, x, y, z] : container.zip(
0211            container.xColumn(), container.yColumn(), container.zColumn())) {
0212     BOOST_CHECK_EQUAL(i, checkIndex);
0213     BOOST_CHECK_NE(x, 0);
0214     BOOST_CHECK_NE(y, 0);
0215     BOOST_CHECK_NE(z, 0);
0216
0217     ++checkIndex;
0218   }
0219 }
0220
0221 BOOST_AUTO_TEST_CASE(CopyFrom) {
0222   SpacePointContainer container(SpacePointColumns::SourceLinks |
0223                                 SpacePointColumns::X | SpacePointColumns::Y |
0224                                 SpacePointColumns::Z);
0225   container.reserve(1);
0226
0227   {
0228     MutableSpacePointProxy sp = container.createSpacePoint();
0229     sp.assignSourceLinks(std::array<SourceLink, 1>{SourceLink(42)});
0230     sp.x() = 1;
0231     sp.y() = 2;
0232     sp.z() = 3;
0233   }
0234
0235   {
0236     SpacePointContainer copyTo(SpacePointColumns::SourceLinks |
0237                                SpacePointColumns::X | SpacePointColumns::Y |
0238                                SpacePointColumns::Z);
0239     MutableSpacePointProxy sp = copyTo.createSpacePoint();
0240     sp.copyFrom(container.at(0),
0241                 SpacePointColumns::SourceLinks | SpacePointColumns::X |
0242                     SpacePointColumns::Y | SpacePointColumns::Z);
0243
0244     BOOST_CHECK_EQUAL(sp.x(), 1);
0245     BOOST_CHECK_EQUAL(sp.y(), 2);
0246     BOOST_CHECK_EQUAL(sp.z(), 3);
0247     BOOST_CHECK_EQUAL(sp.sourceLinks().size(), 1u);
0248     BOOST_CHECK_EQUAL(sp.sourceLinks()[0].get<int>(), 42);
0249   }
0250
0251   {
0252     SpacePointContainer copyTo(SpacePointColumns::X | SpacePointColumns::Y);
0253     MutableSpacePointProxy sp = copyTo.createSpacePoint();
0254     sp.copyFrom(container.at(0), SpacePointColumns::X | SpacePointColumns::Y);
0255
0256     BOOST_CHECK_EQUAL(sp.x(), 1);
0257     BOOST_CHECK_EQUAL(sp.y(), 2);
0258   }
0259
0260   {
0261     SpacePointContainer copyTo(SpacePointColumns::PackedXY);
0262     MutableSpacePointProxy sp = copyTo.createSpacePoint();
0263     BOOST_CHECK_THROW(sp.copyFrom(container.at(0), SpacePointColumns::PackedXY),
0264                       std::logic_error);
0265   }
0266
0267   {
0268     SpacePointContainer copyTo(SpacePointColumns::X | SpacePointColumns::Y);
0269     MutableSpacePointProxy sp = copyTo.createSpacePoint();
0270     BOOST_CHECK_THROW(
0271         sp.copyFrom(container.at(0), SpacePointColumns::SourceLinks),
0272         std::logic_error);
0273   }
0274
0275   {
0276     SpacePointContainer copyTo(SpacePointColumns::X | SpacePointColumns::Y);
0277     MutableSpacePointProxy sp = copyTo.createSpacePoint();
0278     BOOST_CHECK_THROW(sp.copyFrom(container.at(0), SpacePointColumns::All),
0279                       std::logic_error);
0280   }
0281 }
0282
0283 BOOST_AUTO_TEST_SUITE_END()
0284
0285 }  // namespace ActsTests