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