Core/TrackFitting/GsfTests.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/Definitions/Algebra.hpp"
0012 #include "Acts/Definitions/TrackParametrization.hpp"
0013 #include "Acts/Definitions/Units.hpp"
0014 #include "Acts/EventData/GenericBoundTrackParameters.hpp"
0015 #include "Acts/EventData/MultiComponentTrackParameters.hpp"
0016 #include "Acts/EventData/MultiTrajectory.hpp"
0017 #include "Acts/EventData/TrackContainer.hpp"
0018 #include "Acts/EventData/TrackParameters.hpp"
0019 #include "Acts/EventData/TrackProxy.hpp"
0020 #include "Acts/EventData/VectorMultiTrajectory.hpp"
0021 #include "Acts/EventData/VectorTrackContainer.hpp"
0022 #include "Acts/EventData/detail/TestSourceLink.hpp"
0023 #include "Acts/Geometry/GeometryIdentifier.hpp"
0024 #include "Acts/Propagator/MultiEigenStepperLoop.hpp"
0025 #include "Acts/Propagator/Navigator.hpp"
0026 #include "Acts/Propagator/Propagator.hpp"
0027 #include "Acts/Surfaces/CurvilinearSurface.hpp"
0028 #include "Acts/Surfaces/Surface.hpp"
0029 #include "Acts/TrackFitting/BetheHeitlerApprox.hpp"
0030 #include "Acts/TrackFitting/GainMatrixUpdater.hpp"
0031 #include "Acts/TrackFitting/GaussianSumFitter.hpp"
0032 #include "Acts/TrackFitting/GsfMixtureReduction.hpp"
0033 #include "Acts/TrackFitting/GsfOptions.hpp"
0034 #include "Acts/Utilities/Holders.hpp"
0035 #include "Acts/Utilities/Result.hpp"
0036 #include "ActsTests/CommonHelpers/MeasurementsCreator.hpp"
0037
0038 #include <memory>
0039 #include <optional>
0040 #include <random>
0041 #include <string>
0042 #include <string_view>
0043 #include <tuple>
0044 #include <vector>
0045
0046 #include "FitterTestsCommon.hpp"
0047
0048 using namespace Acts;
0049 using namespace Acts::detail::Test;
0050 using namespace Acts::UnitLiterals;
0051
0052 namespace ActsTests {
0053
0054 static const auto electron = ParticleHypothesis::electron();
0055
0056 Acts::GainMatrixUpdater kfUpdater;
0057
0058 FitterTester tester;
0059
0060 GsfExtensions<VectorMultiTrajectory> getExtensions() {
0061   GsfExtensions<VectorMultiTrajectory> extensions;
0062   extensions.calibrator
0063       .connect<&testSourceLinkCalibrator<VectorMultiTrajectory>>();
0064   extensions.updater
0065       .connect<&Acts::GainMatrixUpdater::operator()<VectorMultiTrajectory>>(
0066           &kfUpdater);
0067   extensions.surfaceAccessor
0068       .connect<&TestSourceLink::SurfaceAccessor::operator()>(
0069           &tester.surfaceAccessor);
0070   extensions.mixtureReducer.connect<&Acts::reduceMixtureWithKLDistance>();
0071   return extensions;
0072 }
0073
0074 using Stepper = Acts::MultiEigenStepperLoop<>;
0075 using Propagator = Acts::Propagator<Stepper, Acts::Navigator>;
0076 using BetheHeitlerApprox = AtlasBetheHeitlerApprox<6, 5>;
0077 using GSF =
0078     GaussianSumFitter<Propagator, BetheHeitlerApprox, VectorMultiTrajectory>;
0079
0080 const GSF gsfZero(makeConstantFieldPropagator<Stepper>(tester.geometry, 0_T),
0081                   makeDefaultBetheHeitlerApprox());
0082
0083 std::default_random_engine rng(42);
0084
0085 auto makeDefaultGsfOptions() {
0086   GsfOptions<VectorMultiTrajectory> opts{tester.geoCtx, tester.magCtx,
0087                                          tester.calCtx};
0088   opts.extensions = getExtensions();
0089   opts.propagatorPlainOptions =
0090       PropagatorPlainOptions(tester.geoCtx, tester.magCtx);
0091   return opts;
0092 }
0093
0094 // A Helper type to allow us to put the MultiComponentBoundTrackParameters into
0095 // the function so that it can also be used as GenericBoundTrackParameters for
0096 // the MeasurementsCreator
0097 struct MultiCmpsParsInterface : public BoundTrackParameters {
0098   MultiComponentBoundTrackParameters multi_pars;
0099
0100   explicit MultiCmpsParsInterface(const MultiComponentBoundTrackParameters &p)
0101       : BoundTrackParameters(p.referenceSurface().getSharedPtr(),
0102                              p.parameters(), p.covariance(), electron),
0103         multi_pars(p) {}
0104
0105   explicit operator MultiComponentBoundTrackParameters() const {
0106     return multi_pars;
0107   }
0108 };
0109
0110 auto makeParameters() {
0111   // create covariance matrix from reasonable standard deviations
0112   Acts::BoundVector stddev;
0113   stddev[Acts::eBoundLoc0] = 100_um;
0114   stddev[Acts::eBoundLoc1] = 100_um;
0115   stddev[Acts::eBoundTime] = 25_ns;
0116   stddev[Acts::eBoundPhi] = 2_degree;
0117   stddev[Acts::eBoundTheta] = 2_degree;
0118   stddev[Acts::eBoundQOverP] = 1 / 100_GeV;
0119   Acts::BoundSquareMatrix cov = stddev.cwiseProduct(stddev).asDiagonal();
0120
0121   // define a track in the transverse plane along x
0122   Acts::Vector4 mPos4(-3_m, 0., 0., 42_ns);
0123   Acts::BoundTrackParameters cp = Acts::BoundTrackParameters::createCurvilinear(
0124       mPos4, 0_degree, 90_degree, 1_e / 1_GeV, cov, electron);
0125
0126   // Construct bound multi component parameters from curvilinear ones
0127   Acts::BoundVector deltaLOC0 = Acts::BoundVector::Zero();
0128   deltaLOC0[eBoundLoc0] = 0.5_mm;
0129
0130   Acts::BoundVector deltaLOC1 = Acts::BoundVector::Zero();
0131   deltaLOC1[eBoundLoc1] = 0.5_mm;
0132
0133   Acts::BoundVector deltaQOP = Acts::BoundVector::Zero();
0134   deltaQOP[eBoundQOverP] = 0.01_GeV;
0135
0136   std::vector<std::tuple<double, BoundVector, BoundSquareMatrix>> cmps = {
0137       {0.2, cp.parameters(), cov},
0138       {0.2, cp.parameters() + deltaLOC0 + deltaLOC1 + deltaQOP, cov},
0139       {0.2, cp.parameters() + deltaLOC0 - deltaLOC1 - deltaQOP, cov},
0140       {0.2, cp.parameters() - deltaLOC0 + deltaLOC1 + deltaQOP, cov},
0141       {0.2, cp.parameters() - deltaLOC0 - deltaLOC1 - deltaQOP, cov}};
0142
0143   return MultiCmpsParsInterface(MultiComponentBoundTrackParameters(
0144       cp.referenceSurface().getSharedPtr(), cmps, electron));
0145 }
0146
0147 BOOST_AUTO_TEST_SUITE(TrackFittingSuite)
0148
0149 BOOST_AUTO_TEST_CASE(ZeroFieldNoSurfaceForward) {
0150   auto multi_pars = makeParameters();
0151   auto options = makeDefaultGsfOptions();
0152
0153   tester.test_ZeroFieldNoSurfaceForward(gsfZero, options, multi_pars, rng, true,
0154                                         false, false);
0155 }
0156
0157 BOOST_AUTO_TEST_CASE(ZeroFieldWithSurfaceForward) {
0158   auto multi_pars = makeParameters();
0159   auto options = makeDefaultGsfOptions();
0160
0161   tester.test_ZeroFieldWithSurfaceForward(gsfZero, options, multi_pars, rng,
0162                                           true, false, false);
0163 }
0164
0165 BOOST_AUTO_TEST_CASE(ZeroFieldWithSurfaceBackward) {
0166   auto multi_pars = makeParameters();
0167   auto options = makeDefaultGsfOptions();
0168
0169   tester.test_ZeroFieldWithSurfaceBackward(gsfZero, options, multi_pars, rng,
0170                                            true, false, false);
0171 }
0172
0173 BOOST_AUTO_TEST_CASE(ZeroFieldWithSurfaceAtExit) {
0174   auto multi_pars = makeParameters();
0175   auto options = makeDefaultGsfOptions();
0176
0177   tester.test_ZeroFieldWithSurfaceBackward(gsfZero, options, multi_pars, rng,
0178                                            true, false, false);
0179 }
0180
0181 BOOST_AUTO_TEST_CASE(ZeroFieldShuffled) {
0182   auto multi_pars = makeParameters();
0183   auto options = makeDefaultGsfOptions();
0184
0185   tester.test_ZeroFieldShuffled(gsfZero, options, multi_pars, rng, true, false,
0186                                 false);
0187 }
0188
0189 BOOST_AUTO_TEST_CASE(ZeroFieldWithHole) {
0190   auto options = makeDefaultGsfOptions();
0191   auto multi_pars = makeParameters();
0192
0193   tester.test_ZeroFieldWithHole(gsfZero, options, multi_pars, rng, true, false,
0194                                 false);
0195 }
0196
0197 BOOST_AUTO_TEST_CASE(ZeroFieldWithOutliers) {
0198   // fitter options w/o target surface. outlier distance is set to be below the
0199   // default outlier distance in the `MeasurementsCreator`
0200   TestOutlierFinder tof{5_mm};
0201   auto options = makeDefaultGsfOptions();
0202   options.extensions.outlierFinder
0203       .connect<&TestOutlierFinder::operator()<VectorMultiTrajectory>>(&tof);
0204
0205   auto multi_pars = makeParameters();
0206
0207   tester.test_ZeroFieldWithOutliers(gsfZero, options, multi_pars, rng, true,
0208                                     false, false);
0209 }
0210
0211 BOOST_AUTO_TEST_CASE(WithFinalMultiComponentState) {
0212   Acts::TrackContainer tracks{Acts::VectorTrackContainer{},
0213                               Acts::VectorMultiTrajectory{}};
0214   using namespace Acts::GsfConstants;
0215   std::string key(kFinalMultiComponentStateColumn);
0216   tracks.template addColumn<FinalMultiComponentState>(key);
0217
0218   auto multi_pars = makeParameters();
0219   auto measurements =
0220       createMeasurements(tester.simPropagator, tester.geoCtx, tester.magCtx,
0221                          multi_pars, tester.resolutions, rng);
0222   auto sourceLinks = tester.prepareSourceLinks(measurements.sourceLinks);
0223   auto options = makeDefaultGsfOptions();
0224
0225   // create a boundless target surface near the tracker exit
0226   Acts::Vector3 center(-3._m, 0., 0.);
0227   Acts::Vector3 normal(1., 0., 0.);
0228   std::shared_ptr<PlaneSurface> targetSurface =
0229       Acts::CurvilinearSurface(center, normal).planeSurface();
0230
0231   options.referenceSurface = targetSurface.get();
0232
0233   auto res = gsfZero.fit(sourceLinks.begin(), sourceLinks.end(), multi_pars,
0234                          options, tracks);
0235
0236   BOOST_REQUIRE(res.ok());
0237   BOOST_CHECK(res->template component<FinalMultiComponentState>(
0238                      kFinalMultiComponentStateColumn)
0239                   .has_value());
0240 }
0241
0242 BOOST_AUTO_TEST_SUITE_END()
0243
0244 }  // namespace ActsTests