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