Core/AmbiguityResolution/ScoreBasedAmbiguityResolutionTest.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/AmbiguityResolution/ScoreBasedAmbiguityResolution.hpp"
0012 #include "Acts/EventData/TrackContainer.hpp"
0013 #include "Acts/EventData/VectorMultiTrajectory.hpp"
0014 #include "Acts/EventData/VectorTrackContainer.hpp"
0015 #include "Acts/Utilities/TrackHelpers.hpp"
0016
0017 #include <map>
0018
0019 using namespace Acts;
0020 using IndexType = TrackIndexType;
0021 using enum TrackStateFlag;
0022
0023 namespace ActsTests {
0024
0025 BOOST_AUTO_TEST_SUITE(AmbiguitesResolutionSuite)
0026
0027 // Test fixture for ScoreBasedAmbiguityResolution
0028 struct Fixture {
0029   ScoreBasedAmbiguityResolution::Config config;
0030
0031   using TrackFeatures = ScoreBasedAmbiguityResolution::TrackFeatures;
0032   using DetectorConfig = ScoreBasedAmbiguityResolution::DetectorConfig;
0033
0034   Fixture() {
0035     // Set up any resources used by the tests
0036     config.volumeMap = {{8, 0},  {9, 0},  {10, 0}, {13, 0}, {14, 0},
0037                         {15, 0}, {16, 0}, {17, 0}, {18, 0}, {19, 0},
0038                         {20, 0}, {22, 1}, {23, 1}, {24, 1}};
0039
0040     auto tempDetector = DetectorConfig();
0041     std::vector<DetectorConfig> detectorConfigs = {tempDetector, tempDetector};
0042     config.detectorConfigs = detectorConfigs;
0043
0044     config.minScore = 0;
0045     config.minScoreSharedTracks = 100;
0046     config.maxShared = 5;
0047     config.minUnshared = 3;
0048     config.maxSharedTracksPerMeasurement = 10;
0049     config.useAmbiguityScoring = false;
0050   }
0051
0052   ~Fixture() = default;
0053 };
0054
0055 template <typename TrackContainer, typename FlagsPerState>
0056 auto createTestTrack(TrackContainer& tc, const FlagsPerState& flagsPerState) {
0057   auto t = tc.makeTrack();
0058   for (const auto& flags : flagsPerState) {
0059     auto ts = t.appendTrackState();
0060     for (auto f : flags) {
0061       ts.typeFlags().setUnchecked(f);
0062     }
0063   }
0064
0065   calculateTrackQuantities(t);
0066
0067   return t;
0068 }
0069
0070 BOOST_FIXTURE_TEST_CASE(ComputeInitialStateTest, Fixture) {
0071   Fixture fixture;
0072   // Create an instance of ScoreBasedAmbiguityResolution
0073   ScoreBasedAmbiguityResolution tester(fixture.config);
0074
0075   VectorTrackContainer mutVtc;
0076   VectorMultiTrajectory mutMtj;
0077
0078   TrackContainer mutTc{mutVtc, mutMtj};
0079   static_assert(!mutTc.ReadOnly, "Unexpectedly read only");
0080
0081   auto t = createTestTrack(mutTc, std::vector<std::vector<TrackStateFlag>>{
0082                                       {HasMeasurement},
0083                                       {HasMeasurement, IsOutlier},
0084                                       {HasMeasurement, IsSharedHit},
0085                                       {IsHole},
0086                                       {HasMeasurement, IsOutlier},
0087                                       {IsHole},
0088                                       {HasMeasurement, IsSharedHit},
0089                                       {HasMeasurement, IsOutlier},
0090                                   });
0091
0092   BOOST_CHECK_EQUAL(t.nHoles(), 2);
0093   BOOST_CHECK_EQUAL(t.nMeasurements(), 3);
0094   BOOST_CHECK_EQUAL(t.nOutliers(), 3);
0095   BOOST_CHECK_EQUAL(t.nSharedHits(), 2);
0096
0097   ConstVectorTrackContainer vtc{std::move(mutVtc)};
0098   ConstVectorMultiTrajectory mtj{std::move(mutMtj)};
0099
0100   TrackContainer ctc{vtc, mtj};
0101
0102   std::vector<std::vector<TrackFeatures>> trackFeaturesVectors;
0103   trackFeaturesVectors = tester.computeInitialState(ctc);
0104
0105   BOOST_CHECK_EQUAL(trackFeaturesVectors.size(), ctc.size());
0106
0107   std::vector<double> trackScores;
0108   trackScores = tester.simpleScore(ctc, trackFeaturesVectors);
0109
0110   BOOST_CHECK_EQUAL(trackScores.size(), ctc.size());
0111
0112   trackScores = tester.ambiguityScore(ctc, trackFeaturesVectors);
0113
0114   BOOST_CHECK_EQUAL(trackScores.size(), ctc.size());
0115
0116   // Assert the expected results
0117 }
0118
0119 BOOST_FIXTURE_TEST_CASE(GetCleanedOutTracksTest, Fixture) {
0120   Fixture fixture;
0121   // Create an instance of ScoreBasedAmbiguityResolution
0122   ScoreBasedAmbiguityResolution tester(fixture.config);
0123
0124   VectorTrackContainer mutVtc;
0125   VectorMultiTrajectory mutMtj;
0126
0127   TrackContainer mutTc{mutVtc, mutMtj};
0128   static_assert(!mutTc.ReadOnly, "Unexpectedly read only");
0129
0130   auto t = createTestTrack(mutTc, std::vector<std::vector<TrackStateFlag>>{
0131                                       {HasMeasurement},
0132                                       {HasMeasurement, IsOutlier},
0133                                       {HasMeasurement, IsSharedHit},
0134                                       {IsHole},
0135                                       {HasMeasurement, IsOutlier},
0136                                       {IsHole},
0137                                       {HasMeasurement, IsSharedHit},
0138                                       {HasMeasurement, IsOutlier},
0139                                   });
0140
0141   BOOST_CHECK_EQUAL(t.nHoles(), 2);
0142   BOOST_CHECK_EQUAL(t.nMeasurements(), 3);
0143   BOOST_CHECK_EQUAL(t.nOutliers(), 3);
0144   BOOST_CHECK_EQUAL(t.nSharedHits(), 2);
0145
0146   ConstVectorTrackContainer vtc{std::move(mutVtc)};
0147   ConstVectorMultiTrajectory mtj{std::move(mutMtj)};
0148
0149   TrackContainer ctc{vtc, mtj};
0150
0151   std::vector<std::vector<TrackFeatures>> trackFeaturesVectors;
0152   std::vector<std::vector<std::size_t>> measurementsPerTrackVector;
0153   std::map<std::size_t, std::size_t> nTracksPerMeasurement;
0154
0155   trackFeaturesVectors = tester.computeInitialState(ctc);
0156
0157   BOOST_CHECK_EQUAL(trackFeaturesVectors.size(), ctc.size());
0158
0159   for (std::size_t iMeasurement = 1; const auto& track : ctc) {
0160     std::vector<std::size_t> measurementsPerTrack;
0161     for (auto ts : track.trackStatesReversed()) {
0162       if (ts.typeFlags().isOutlier() || ts.typeFlags().isMeasurement()) {
0163         measurementsPerTrack.push_back(iMeasurement);
0164         if (nTracksPerMeasurement.find(iMeasurement) ==
0165             nTracksPerMeasurement.end()) {
0166           nTracksPerMeasurement[iMeasurement] = 0;
0167         }
0168         nTracksPerMeasurement[iMeasurement]++;
0169       }
0170
0171       iMeasurement++;
0172     }
0173     measurementsPerTrackVector.push_back(std::move(measurementsPerTrack));
0174   }
0175
0176   auto trackScore = tester.ambiguityScore(ctc, trackFeaturesVectors);
0177
0178   const auto& track = ctc.getTrack(0);
0179   std::size_t iTrack = track.index();
0180   bool accepted = tester.getCleanedOutTracks(track, trackScore[iTrack],
0181                                              measurementsPerTrackVector[iTrack],
0182                                              nTracksPerMeasurement);
0183
0184   BOOST_CHECK_EQUAL(accepted, false);
0185 }
0186
0187 BOOST_AUTO_TEST_SUITE_END()
0188
0189 }  // namespace ActsTests