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