TrackFitting/src/KalmanReferenceTrajectoryFitterFunction.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 "Acts/EventData/MultiTrajectory.hpp"
0010 #include "Acts/EventData/TrackContainer.hpp"
0011 #include "Acts/EventData/VectorMultiTrajectory.hpp"
0012 #include "Acts/EventData/VectorTrackContainer.hpp"
0013 #include "Acts/EventData/detail/CorrectedTransformationFreeToBound.hpp"
0014 #include "Acts/Geometry/GeometryIdentifier.hpp"
0015 #include "Acts/Propagator/DirectNavigator.hpp"
0016 #include "Acts/Propagator/Navigator.hpp"
0017 #include "Acts/Propagator/Propagator.hpp"
0018 #include "Acts/Propagator/SympyStepper.hpp"
0019 #include "Acts/TrackFitting/GainMatrixUpdater.hpp"
0020 #include "Acts/TrackFitting/MbfSmoother.hpp"
0021 #include "Acts/TrackFitting/ReferenceTrajectoryBuilder.hpp"
0022 #include "Acts/Utilities/Logger.hpp"
0023 #include "Acts/Utilities/TrackHelpers.hpp"
0024 #include "ActsExamples/EventData/IndexSourceLink.hpp"
0025 #include "ActsExamples/EventData/MeasurementCalibration.hpp"
0026 #include "ActsExamples/EventData/Track.hpp"
0027 #include "ActsExamples/TrackFitting/RefittingCalibrator.hpp"
0028 #include "ActsExamples/TrackFitting/TrackFitterFunction.hpp"
0029
0030 #include <memory>
0031 #include <utility>
0032 #include <vector>
0033
0034 namespace {
0035
0036 using Stepper = Acts::SympyStepper;
0037 using Propagator = Acts::Propagator<Stepper, Acts::Navigator>;
0038 using ReferenceTrajectoryBuilder =
0039     Acts::Experimental::ReferenceTrajectoryBuilder<Propagator,
0040                                                    Acts::VectorMultiTrajectory>;
0041 using DirectPropagator = Acts::Propagator<Stepper, Acts::DirectNavigator>;
0042 using DirectReferenceTrajectoryBuilder =
0043     Acts::Experimental::ReferenceTrajectoryBuilder<DirectPropagator,
0044                                                    Acts::VectorMultiTrajectory>;
0045
0046 using TrackContainer =
0047     Acts::TrackContainer<Acts::VectorTrackContainer,
0048                          Acts::VectorMultiTrajectory, std::shared_ptr>;
0049
0050 using namespace ActsExamples;
0051
0052 struct KalmanReferenceTrajectoryFitterFunctionImpl final
0053     : public TrackFitterFunction {
0054   Propagator extrapolator;
0055
0056   ReferenceTrajectoryBuilder referenceTrajectoryBuilder;
0057   DirectReferenceTrajectoryBuilder directReferenceTrajectoryBuilder;
0058
0059   Acts::GainMatrixUpdater kfUpdater;
0060   Acts::MbfSmoother kfSmoother;
0061
0062   bool multipleScattering = false;
0063   bool energyLoss = false;
0064   Acts::FreeToBoundCorrection freeToBoundCorrection;
0065
0066   IndexSourceLink::SurfaceAccessor slSurfaceAccessor;
0067
0068   std::unique_ptr<const Acts::Logger> m_smootherLogger;
0069   std::unique_ptr<const Acts::Logger> m_extrapolationLogger;
0070
0071   KalmanReferenceTrajectoryFitterFunctionImpl(
0072       Propagator&& ext, ReferenceTrajectoryBuilder&& rtBuilder,
0073       DirectReferenceTrajectoryBuilder&& dRtBuilder,
0074       const Acts::TrackingGeometry& trkGeo, const Acts::Logger& logger)
0075       : extrapolator(std::move(ext)),
0076         referenceTrajectoryBuilder(std::move(rtBuilder)),
0077         directReferenceTrajectoryBuilder(std::move(dRtBuilder)),
0078         slSurfaceAccessor{trkGeo} {
0079     m_smootherLogger = logger.cloneWithSuffix("Smoother");
0080     m_extrapolationLogger = logger.cloneWithSuffix("Extrapolation");
0081   }
0082
0083   auto makeReferenceTrajectoryBuilderOptions(
0084       const GeneralFitterOptions& options) const {
0085     Acts::Experimental::ReferenceTrajectoryBuilderOptions<
0086         Acts::VectorMultiTrajectory>
0087         rtOptions(options.geoContext, options.magFieldContext,
0088                   options.propOptions, nullptr);
0089
0090     rtOptions.multipleScattering = multipleScattering;
0091     rtOptions.energyLoss = energyLoss;
0092     rtOptions.freeToBoundCorrection = freeToBoundCorrection;
0093
0094     return rtOptions;
0095   }
0096
0097   TrackFitterResult operator()(const std::vector<Acts::SourceLink>& sourceLinks,
0098                                const TrackParameters& initialParameters,
0099                                const GeneralFitterOptions& options,
0100                                const MeasurementCalibratorAdapter& calibrator,
0101                                TrackContainer& tracks) const override {
0102     const auto referenceTrajectoryBuilderOptions =
0103         makeReferenceTrajectoryBuilderOptions(options);
0104
0105     Acts::SourceLinkSurfaceAccessor sourceLinkAccessorDelegate;
0106     sourceLinkAccessorDelegate
0107         .connect<&IndexSourceLink::SurfaceAccessor::operator()>(
0108             &slSurfaceAccessor);
0109
0110     ReferenceTrajectoryBuilder::Calibrator calibratorDelegate;
0111     calibratorDelegate.connect<&MeasurementCalibratorAdapter::calibrate>(
0112         &calibrator);
0113
0114     ReferenceTrajectoryBuilder::Updater updaterDelegate;
0115     updaterDelegate.connect<
0116         &Acts::GainMatrixUpdater::operator()<Acts::VectorMultiTrajectory>>(
0117         &kfUpdater);
0118
0119     auto buildResult = referenceTrajectoryBuilder.build(
0120         initialParameters, referenceTrajectoryBuilderOptions, tracks);
0121     if (!buildResult.ok()) {
0122       return buildResult.error();
0123     }
0124     auto track = *buildResult;
0125
0126     referenceTrajectoryBuilder.attachSourceLinks(track, sourceLinks,
0127                                                  sourceLinkAccessorDelegate);
0128
0129     referenceTrajectoryBuilder.calibrateMeasurements(options.geoContext,
0130                                                      options.calibrationContext,
0131                                                      track, calibratorDelegate);
0132
0133     auto fitterResult = referenceTrajectoryBuilder.filter(
0134         options.geoContext, track, updaterDelegate);
0135     if (!fitterResult.ok()) {
0136       return fitterResult.error();
0137     }
0138
0139     auto smoothRes =
0140         kfSmoother(options.geoContext, tracks.trackStateContainer(),
0141                    track.tipIndex(), *m_smootherLogger);
0142     if (!smoothRes.ok()) {
0143       return smoothRes.error();
0144     }
0145
0146     if (!track.hasReferenceSurface() && options.referenceSurface != nullptr) {
0147       typename Propagator::template Options<> extrapolationOptions(
0148           options.geoContext, options.magFieldContext);
0149       auto extrapolationResult = extrapolateTrackToReferenceSurface(
0150           track, *options.referenceSurface, extrapolator, extrapolationOptions,
0151           Acts::TrackExtrapolationStrategy::first, *m_extrapolationLogger);
0152
0153       if (!extrapolationResult.ok()) {
0154         return extrapolationResult.error();
0155       }
0156     }
0157
0158     Acts::calculateTrackQuantities(track);
0159
0160     return TrackFitterResult::success(track);
0161   }
0162
0163   TrackFitterResult operator()(
0164       const std::vector<Acts::SourceLink>& sourceLinks,
0165       const TrackParameters& initialParameters,
0166       const GeneralFitterOptions& options,
0167       const RefittingCalibrator& calibrator,
0168       const std::vector<const Acts::Surface*>& surfaceSequence,
0169       TrackContainer& tracks) const override {
0170     const auto referenceTrajectoryBuilderOptions =
0171         makeReferenceTrajectoryBuilderOptions(options);
0172
0173     Acts::SourceLinkSurfaceAccessor sourceLinkAccessorDelegate;
0174     sourceLinkAccessorDelegate.connect<&RefittingCalibrator::accessSurface>();
0175
0176     DirectReferenceTrajectoryBuilder::Calibrator calibratorDelegate;
0177     calibratorDelegate.connect<&RefittingCalibrator::calibrate>(&calibrator);
0178
0179     DirectReferenceTrajectoryBuilder::Updater updaterDelegate;
0180     updaterDelegate.connect<
0181         &Acts::GainMatrixUpdater::operator()<Acts::VectorMultiTrajectory>>(
0182         &kfUpdater);
0183
0184     auto buildResult = directReferenceTrajectoryBuilder.build(
0185         initialParameters, referenceTrajectoryBuilderOptions, surfaceSequence,
0186         tracks);
0187     if (!buildResult.ok()) {
0188       return buildResult.error();
0189     }
0190     auto track = *buildResult;
0191
0192     directReferenceTrajectoryBuilder.attachSourceLinks(
0193         track, sourceLinks, sourceLinkAccessorDelegate);
0194
0195     directReferenceTrajectoryBuilder.calibrateMeasurements(
0196         options.geoContext, options.calibrationContext, track,
0197         calibratorDelegate);
0198
0199     directReferenceTrajectoryBuilder.filter(options.geoContext, track,
0200                                             updaterDelegate);
0201
0202     auto smoothRes = kfSmoother(options.geoContext,
0203                                 tracks.trackStateContainer(), track.tipIndex());
0204     if (!smoothRes.ok()) {
0205       return smoothRes.error();
0206     }
0207
0208     if (!track.hasReferenceSurface() && options.referenceSurface != nullptr) {
0209       typename Propagator::template Options<> extrapolationOptions(
0210           options.geoContext, options.magFieldContext);
0211       auto extrapolationResult = extrapolateTrackToReferenceSurface(
0212           track, *options.referenceSurface, extrapolator, extrapolationOptions,
0213           Acts::TrackExtrapolationStrategy::first);
0214
0215       if (!extrapolationResult.ok()) {
0216         return extrapolationResult.error();
0217       }
0218     }
0219
0220     Acts::calculateTrackQuantities(track);
0221
0222     return TrackFitterResult::success(track);
0223   }
0224 };
0225
0226 }  // namespace
0227
0228 std::shared_ptr<TrackFitterFunction>
0229 ActsExamples::makeKalmanReferenceTrajectoryFitterFunction(
0230     std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
0231     std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
0232     bool multipleScattering, bool energyLoss,
0233     const Acts::FreeToBoundCorrection& freeToBoundCorrection,
0234     bool useJosephFormulation, const Acts::Logger& logger) {
0235   const Stepper stepper(std::move(magneticField));
0236
0237   const auto& geo = *trackingGeometry;
0238   Acts::Navigator::Config cfg{std::move(trackingGeometry)};
0239   cfg.resolvePassive = false;
0240   cfg.resolveMaterial = true;
0241   cfg.resolveSensitive = true;
0242   Acts::Navigator navigator(cfg, logger.cloneWithSuffix("Navigator"));
0243   Propagator propagator(stepper, navigator,
0244                         logger.cloneWithSuffix("Propagator"));
0245   ReferenceTrajectoryBuilder referenceTrajectoryBuilder(
0246       std::move(propagator),
0247       logger.cloneWithSuffix("ReferenceTrajectoryBuilder"));
0248
0249   Acts::DirectNavigator directNavigator{
0250       logger.cloneWithSuffix("DirectNavigator")};
0251   DirectPropagator directPropagator(stepper, std::move(directNavigator),
0252                                     logger.cloneWithSuffix("DirectPropagator"));
0253   DirectReferenceTrajectoryBuilder directReferenceTrajectoryBuilder(
0254       std::move(directPropagator),
0255       logger.cloneWithSuffix("DirectReferenceTrajectoryBuilder"));
0256
0257   Propagator extrapolator(stepper, navigator,
0258                           logger.cloneWithSuffix("Extrapolator"));
0259
0260   auto fitterFunction =
0261       std::make_shared<KalmanReferenceTrajectoryFitterFunctionImpl>(
0262           std::move(extrapolator), std::move(referenceTrajectoryBuilder),
0263           std::move(directReferenceTrajectoryBuilder), geo, logger);
0264   fitterFunction->multipleScattering = multipleScattering;
0265   fitterFunction->energyLoss = energyLoss;
0266   fitterFunction->freeToBoundCorrection = freeToBoundCorrection;
0267   fitterFunction->kfUpdater = Acts::GainMatrixUpdater(useJosephFormulation);
0268
0269   return fitterFunction;
0270 }