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