Core/Seeding/CandidatesForMiddleSpTests.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/Seeding/CandidatesForMiddleSp.hpp"
0012
0013 #include <algorithm>
0014 #include <limits>
0015 #include <vector>
0016
0017 #include "SpacePoint.hpp"
0018
0019 using namespace Acts;
0020
0021 namespace ActsTests {
0022
0023 BOOST_AUTO_TEST_SUITE(SeedingSuite)
0024
0025 BOOST_AUTO_TEST_CASE(TripletCandidateObject) {
0026   using UnitTestSpacePoint = ::SpacePoint;
0027   std::vector<UnitTestSpacePoint> spacePoints(3);
0028
0029   // Default Constructor
0030   TripletCandidate<UnitTestSpacePoint> defaultCandidate;
0031   BOOST_CHECK_EQUAL(defaultCandidate.bottom, nullptr);
0032   BOOST_CHECK_EQUAL(defaultCandidate.middle, nullptr);
0033   BOOST_CHECK_EQUAL(defaultCandidate.top, nullptr);
0034   BOOST_CHECK_EQUAL(defaultCandidate.weight, 0.);
0035   BOOST_CHECK_EQUAL(defaultCandidate.zOrigin, 0.);
0036   BOOST_CHECK_EQUAL(defaultCandidate.isQuality, false);
0037
0038   // Constructor
0039   TripletCandidate<UnitTestSpacePoint> constructedCandidate(
0040       spacePoints[0], spacePoints[1], spacePoints[2], 2.4f, 1.1f, true);
0041   BOOST_CHECK_EQUAL(constructedCandidate.bottom, &spacePoints[0]);
0042   BOOST_CHECK_EQUAL(constructedCandidate.middle, &spacePoints[1]);
0043   BOOST_CHECK_EQUAL(constructedCandidate.top, &spacePoints[2]);
0044   BOOST_CHECK_EQUAL(constructedCandidate.weight, 2.4f);
0045   BOOST_CHECK_EQUAL(constructedCandidate.zOrigin, 1.1f);
0046   BOOST_CHECK_EQUAL(constructedCandidate.isQuality, true);
0047
0048   // Copy Constructor
0049   TripletCandidate<UnitTestSpacePoint> copiedConstructedCandidate(
0050       constructedCandidate);
0051   BOOST_CHECK_EQUAL(copiedConstructedCandidate.bottom, &spacePoints[0]);
0052   BOOST_CHECK_EQUAL(copiedConstructedCandidate.middle, &spacePoints[1]);
0053   BOOST_CHECK_EQUAL(copiedConstructedCandidate.top, &spacePoints[2]);
0054   BOOST_CHECK_EQUAL(copiedConstructedCandidate.weight, 2.4f);
0055   BOOST_CHECK_EQUAL(copiedConstructedCandidate.zOrigin, 1.1f);
0056   BOOST_CHECK_EQUAL(copiedConstructedCandidate.isQuality, true);
0057
0058   // Copy Assign
0059   TripletCandidate<UnitTestSpacePoint> copiedAssignCandidate =
0060       constructedCandidate;
0061   BOOST_CHECK_EQUAL(copiedAssignCandidate.bottom, &spacePoints[0]);
0062   BOOST_CHECK_EQUAL(copiedAssignCandidate.middle, &spacePoints[1]);
0063   BOOST_CHECK_EQUAL(copiedAssignCandidate.top, &spacePoints[2]);
0064   BOOST_CHECK_EQUAL(copiedAssignCandidate.weight, 2.4f);
0065   BOOST_CHECK_EQUAL(copiedAssignCandidate.zOrigin, 1.1f);
0066   BOOST_CHECK_EQUAL(copiedAssignCandidate.isQuality, true);
0067 }
0068
0069 BOOST_AUTO_TEST_CASE(CandidatesForMiddleSpObject) {
0070   using UnitTestSpacePoint = ::SpacePoint;
0071   using value_t =
0072       typename CandidatesForMiddleSp<UnitTestSpacePoint>::value_type;
0073   UnitTestSpacePoint spacePoint;
0074
0075   CandidatesForMiddleSp<UnitTestSpacePoint> container;
0076   container.setMaxElements(std::numeric_limits<std::size_t>::max(),
0077                            std::numeric_limits<std::size_t>::max());
0078   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 0);
0079   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0080   for (int i(0); i < 20; ++i) {
0081     container.push(spacePoint, spacePoint, spacePoint, 1, 2.1, false);
0082   }
0083   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 20);
0084   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0085   container.clear();
0086
0087   container.setMaxElements(5, 3);
0088   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 0);
0089   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0090
0091   std::vector<value_t> emptyStorage = container.storage();
0092   BOOST_CHECK_EQUAL(emptyStorage.size(), 0);
0093   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 0);
0094   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0095
0096   // push low quality
0097   for (int i(0); i < 2; ++i) {
0098     container.push(spacePoint, spacePoint, spacePoint, i, 2.1, false);
0099   }
0100   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 2);
0101   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0102
0103   for (int i(0); i < 7; ++i) {
0104     container.push(spacePoint, spacePoint, spacePoint, 2.01, 2.15, false);
0105   }
0106   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 5);
0107   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0108
0109   // push high quality
0110   for (int i(0); i < 5; ++i) {
0111     container.push(spacePoint, spacePoint, spacePoint, 0.5f + i, 2.1, true);
0112   }
0113   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 5);
0114   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 3);
0115
0116   std::vector<value_t> storagedValues = container.storage();
0117   // check size array
0118   BOOST_CHECK_EQUAL(storagedValues.size(), 5 + 3);
0119   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 0);
0120   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0121
0122   // check elements are sorted
0123   for (std::size_t i(0); i < storagedValues.size() - 1; ++i) {
0124     BOOST_CHECK(storagedValues[i].weight >= storagedValues[i + 1].weight);
0125   }
0126
0127   std::ranges::sort(
0128       storagedValues,
0129       CandidatesForMiddleSp<UnitTestSpacePoint>::ascendingByQuality);
0130   // check values are sorted properly
0131   for (std::size_t i(0); i < storagedValues.size() - 1; ++i) {
0132     BOOST_CHECK(storagedValues[i].weight <= storagedValues[i + 1].weight);
0133   }
0134
0135   std::ranges::sort(
0136       storagedValues,
0137       CandidatesForMiddleSp<UnitTestSpacePoint>::descendingByQuality);
0138   // check values are sorted properly
0139   for (std::size_t i(0); i < storagedValues.size() - 1; ++i) {
0140     BOOST_CHECK(storagedValues[i].weight >= storagedValues[i + 1].weight);
0141   }
0142   // push again and check size
0143   for (int i(0); i < 7; ++i) {
0144     container.push(spacePoint, spacePoint, spacePoint, i, 2.15, false);
0145   }
0146   for (int i(0); i < 7; ++i) {
0147     container.push(spacePoint, spacePoint, spacePoint, i, 2.15, true);
0148   }
0149   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 5);
0150   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 3);
0151   container.clear();
0152   BOOST_CHECK_EQUAL(container.nLowQualityCandidates(), 0);
0153   BOOST_CHECK_EQUAL(container.nHighQualityCandidates(), 0);
0154 }
0155
0156 BOOST_AUTO_TEST_SUITE_END()
0157
0158 }  // namespace ActsTests