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