TrackFitting/src/GsfFitterFunction.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/Geometry/GeometryIdentifier.hpp"
0014 #include "Acts/Propagator/DirectNavigator.hpp"
0015 #include "Acts/Propagator/MultiEigenStepperLoop.hpp"
0016 #include "Acts/Propagator/MultiStepperLoop.hpp"
0017 #include "Acts/Propagator/Navigator.hpp"
0018 #include "Acts/Propagator/Propagator.hpp"
0019 #include "Acts/Propagator/SympyStepper.hpp"
0020 #include "Acts/TrackFitting/GainMatrixUpdater.hpp"
0021 #include "Acts/TrackFitting/GaussianSumFitter.hpp"
0022 #include "Acts/TrackFitting/GsfMixtureReduction.hpp"
0023 #include "Acts/TrackFitting/GsfOptions.hpp"
0024 #include "Acts/Utilities/Delegate.hpp"
0025 #include "Acts/Utilities/HashedString.hpp"
0026 #include "Acts/Utilities/Logger.hpp"
0027 #include "ActsExamples/EventData/IndexSourceLink.hpp"
0028 #include "ActsExamples/EventData/MeasurementCalibration.hpp"
0029 #include "ActsExamples/EventData/Track.hpp"
0030 #include "ActsExamples/TrackFitting/RefittingCalibrator.hpp"
0031 #include "ActsExamples/TrackFitting/TrackFitterFunction.hpp"
0032
0033 #include <cstddef>
0034 #include <memory>
0035 #include <string>
0036 #include <string_view>
0037 #include <utility>
0038 #include <vector>
0039
0040 using namespace ActsExamples;
0041
0042 namespace {
0043
0044 using MultiStepper =
0045     Acts::MultiStepperLoop<Acts::SympyStepper, Acts::MaxWeightReducerLoop>;
0046 using Propagator = Acts::Propagator<MultiStepper, Acts::Navigator>;
0047 using DirectPropagator = Acts::Propagator<MultiStepper, Acts::DirectNavigator>;
0048
0049 using Fitter = Acts::GaussianSumFitter<Propagator, Acts::VectorMultiTrajectory>;
0050 using DirectFitter =
0051     Acts::GaussianSumFitter<DirectPropagator, Acts::VectorMultiTrajectory>;
0052 using TrackContainer =
0053     Acts::TrackContainer<Acts::VectorTrackContainer,
0054                          Acts::VectorMultiTrajectory, std::shared_ptr>;
0055
0056 struct GsfFitterFunctionImpl final : public TrackFitterFunction {
0057   Fitter fitter;
0058   DirectFitter directFitter;
0059
0060   Acts::GainMatrixUpdater updater;
0061
0062   std::size_t maxComponents = 0;
0063   double weightCutoff = 0;
0064   const double momentumCutoff = 0;  // 500_MeV;
0065   bool abortOnError = false;
0066   bool disableAllMaterialHandling = false;
0067   MixtureReductionAlgorithm reductionAlg =
0068       MixtureReductionAlgorithm::KLDistance;
0069   Acts::ComponentMergeMethod mergeMethod =
0070       Acts::ComponentMergeMethod::eMaxWeight;
0071   double reverseFilteringCovarianceScaling = 100.0;
0072
0073   IndexSourceLink::SurfaceAccessor m_slSurfaceAccessor;
0074
0075   GsfFitterFunctionImpl(Fitter&& f, DirectFitter&& df,
0076                         const Acts::TrackingGeometry& trkGeo)
0077       : fitter(std::move(f)),
0078         directFitter(std::move(df)),
0079         m_slSurfaceAccessor{trkGeo} {}
0080
0081   template <typename calibrator_t>
0082   auto makeGsfOptions(const GeneralFitterOptions& options,
0083                       const calibrator_t& calibrator) const {
0084     Acts::GsfExtensions<Acts::VectorMultiTrajectory> extensions;
0085     extensions.updater.connect<
0086         &Acts::GainMatrixUpdater::operator()<Acts::VectorMultiTrajectory>>(
0087         &updater);
0088
0089     Acts::GsfOptions<Acts::VectorMultiTrajectory> gsfOptions{
0090         options.geoContext, options.magFieldContext,
0091         options.calibrationContext};
0092     gsfOptions.extensions = extensions;
0093     gsfOptions.propagatorPlainOptions = options.propOptions;
0094     gsfOptions.referenceSurface = options.referenceSurface;
0095     gsfOptions.maxComponents = maxComponents;
0096     gsfOptions.weightCutoff = weightCutoff;
0097     gsfOptions.abortOnError = abortOnError;
0098     gsfOptions.disableAllMaterialHandling = disableAllMaterialHandling;
0099     gsfOptions.componentMergeMethod = mergeMethod;
0100     gsfOptions.reverseFilteringCovarianceScaling =
0101         reverseFilteringCovarianceScaling;
0102
0103     gsfOptions.extensions.calibrator.connect<&calibrator_t::calibrate>(
0104         &calibrator);
0105
0106     if (options.doRefit) {
0107       gsfOptions.extensions.surfaceAccessor
0108           .connect<&RefittingCalibrator::accessSurface>();
0109     } else {
0110       gsfOptions.extensions.surfaceAccessor
0111           .connect<&IndexSourceLink::SurfaceAccessor::operator()>(
0112               &m_slSurfaceAccessor);
0113     }
0114     switch (reductionAlg) {
0115       case MixtureReductionAlgorithm::weightCut: {
0116         gsfOptions.extensions.mixtureReducer
0117             .connect<&Acts::reduceMixtureLargestWeights>();
0118       } break;
0119       case MixtureReductionAlgorithm::KLDistance: {
0120         gsfOptions.extensions.mixtureReducer
0121             .connect<&Acts::reduceMixtureWithKLDistance>();
0122       } break;
0123       case MixtureReductionAlgorithm::KLDistanceNaive: {
0124         gsfOptions.extensions.mixtureReducer
0125             .connect<&Acts::reduceMixtureWithKLDistanceNaive>();
0126       } break;
0127     }
0128
0129     return gsfOptions;
0130   }
0131
0132   TrackFitterResult operator()(const std::vector<Acts::SourceLink>& sourceLinks,
0133                                const TrackParameters& initialParameters,
0134                                const GeneralFitterOptions& options,
0135                                const MeasurementCalibratorAdapter& calibrator,
0136                                TrackContainer& tracks) const override {
0137     const auto gsfOptions = makeGsfOptions(options, calibrator);
0138
0139     using namespace Acts::GsfConstants;
0140     if (!tracks.hasColumn(Acts::hashString(kFinalMultiComponentStateColumn))) {
0141       std::string key(kFinalMultiComponentStateColumn);
0142       tracks.template addColumn<FinalMultiComponentState>(key);
0143     }
0144     if (!tracks.hasColumn(Acts::hashString(kFwdMaxMaterialXOverX0))) {
0145       tracks.template addColumn<double>(std::string(kFwdMaxMaterialXOverX0));
0146     }
0147     if (!tracks.hasColumn(Acts::hashString(kFwdSumMaterialXOverX0))) {
0148       tracks.template addColumn<double>(std::string(kFwdSumMaterialXOverX0));
0149     }
0150
0151     return fitter.fit(sourceLinks.begin(), sourceLinks.end(), initialParameters,
0152                       gsfOptions, tracks);
0153   }
0154
0155   TrackFitterResult operator()(
0156       const std::vector<Acts::SourceLink>& sourceLinks,
0157       const TrackParameters& initialParameters,
0158       const GeneralFitterOptions& options,
0159       const RefittingCalibrator& calibrator,
0160       const std::vector<const Acts::Surface*>& surfaceSequence,
0161       TrackContainer& tracks) const override {
0162     const auto gsfOptions = makeGsfOptions(options, calibrator);
0163
0164     using namespace Acts::GsfConstants;
0165     if (!tracks.hasColumn(Acts::hashString(kFinalMultiComponentStateColumn))) {
0166       std::string key(kFinalMultiComponentStateColumn);
0167       tracks.template addColumn<FinalMultiComponentState>(key);
0168     }
0169     if (!tracks.hasColumn(Acts::hashString(kFwdMaxMaterialXOverX0))) {
0170       tracks.template addColumn<double>(std::string(kFwdMaxMaterialXOverX0));
0171     }
0172     if (!tracks.hasColumn(Acts::hashString(kFwdSumMaterialXOverX0))) {
0173       tracks.template addColumn<double>(std::string(kFwdSumMaterialXOverX0));
0174     }
0175
0176     return directFitter.fit(sourceLinks.begin(), sourceLinks.end(),
0177                             initialParameters, gsfOptions, surfaceSequence,
0178                             tracks);
0179   }
0180 };
0181
0182 }  // namespace
0183
0184 std::shared_ptr<TrackFitterFunction> ActsExamples::makeGsfFitterFunction(
0185     std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
0186     std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
0187     const std::shared_ptr<const Acts::BetheHeitlerApprox>& betheHeitlerApprox,
0188     std::size_t maxComponents, double weightCutoff,
0189     Acts::ComponentMergeMethod componentMergeMethod,
0190     MixtureReductionAlgorithm mixtureReductionAlgorithm,
0191     double reverseFilteringCovarianceScaling, const Acts::Logger& logger) {
0192   // Standard fitter
0193   MultiStepper stepper(magneticField, logger.cloneWithSuffix("Step"));
0194   const auto& geo = *trackingGeometry;
0195   Acts::Navigator::Config cfg{std::move(trackingGeometry)};
0196   cfg.resolvePassive = false;
0197   cfg.resolveMaterial = true;
0198   cfg.resolveSensitive = true;
0199   Acts::Navigator navigator(cfg, logger.cloneWithSuffix("Navigator"));
0200   Propagator propagator(std::move(stepper), std::move(navigator),
0201                         logger.cloneWithSuffix("Propagator"));
0202   Fitter trackFitter(std::move(propagator), betheHeitlerApprox,
0203                      logger.cloneWithSuffix("GSF"));
0204
0205   // Direct fitter
0206   MultiStepper directStepper(std::move(magneticField),
0207                              logger.cloneWithSuffix("Step"));
0208   Acts::DirectNavigator directNavigator{
0209       logger.cloneWithSuffix("DirectNavigator")};
0210   DirectPropagator directPropagator(std::move(directStepper),
0211                                     std::move(directNavigator),
0212                                     logger.cloneWithSuffix("DirectPropagator"));
0213   DirectFitter directTrackFitter(std::move(directPropagator),
0214                                  betheHeitlerApprox,
0215                                  logger.cloneWithSuffix("DirectGSF"));
0216
0217   // build the fitter functions. owns the fitter object.
0218   auto fitterFunction = std::make_shared<GsfFitterFunctionImpl>(
0219       std::move(trackFitter), std::move(directTrackFitter), geo);
0220   fitterFunction->maxComponents = maxComponents;
0221   fitterFunction->weightCutoff = weightCutoff;
0222   fitterFunction->mergeMethod = componentMergeMethod;
0223   fitterFunction->reductionAlg = mixtureReductionAlgorithm;
0224   fitterFunction->reverseFilteringCovarianceScaling =
0225       reverseFilteringCovarianceScaling;
0226
0227   return fitterFunction;
0228 }