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