Python/src/TrackFinding.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/SpacePointContainer.hpp"
0010 #include "Acts/Geometry/GeometryIdentifier.hpp"
0011 #include "Acts/Plugins/Python/Utilities.hpp"
0012 #include "Acts/Seeding/SeedConfirmationRangeConfig.hpp"
0013 #include "Acts/Seeding/SeedFilterConfig.hpp"
0014 #include "Acts/Seeding/SeedFinderConfig.hpp"
0015 #include "Acts/Seeding/SeedFinderGbtsConfig.hpp"
0016 #include "Acts/Seeding/SeedFinderOrthogonalConfig.hpp"
0017 #include "Acts/TrackFinding/MeasurementSelector.hpp"
0018 #include "Acts/Utilities/Logger.hpp"
0019 #include "ActsExamples/EventData/SpacePointContainer.hpp"
0020 #include "ActsExamples/TrackFinding/GbtsSeedingAlgorithm.hpp"
0021 #include "ActsExamples/TrackFinding/HoughTransformSeeder.hpp"
0022 #include "ActsExamples/TrackFinding/MuonHoughSeeder.hpp"
0023 #include "ActsExamples/TrackFinding/SeedingAlgorithm.hpp"
0024 #include "ActsExamples/TrackFinding/SeedingOrthogonalAlgorithm.hpp"
0025 #include "ActsExamples/TrackFinding/SpacePointMaker.hpp"
0026 #include "ActsExamples/TrackFinding/TrackFindingAlgorithm.hpp"
0027 #include "ActsExamples/TrackFinding/TrackParamsEstimationAlgorithm.hpp"
0028 #include "ActsExamples/TrackFinding/TrackParamsLookupEstimation.hpp"
0029
0030 #include <cstddef>
0031 #include <memory>
0032 #include <tuple>
0033 #include <utility>
0034 #include <vector>
0035
0036 #include <pybind11/pybind11.h>
0037 #include <pybind11/stl.h>
0038
0039 namespace py = pybind11;
0040
0041 using namespace ActsExamples;
0042 using namespace Acts;
0043
0044 namespace Acts::Python {
0045
0046 void addTrackFinding(Context& ctx) {
0047   auto [m, mex] = ctx.get("main", "examples");
0048
0049   ACTS_PYTHON_DECLARE_ALGORITHM(ActsExamples::SpacePointMaker, mex,
0050                                 "SpacePointMaker", inputMeasurements,
0051                                 outputSpacePoints, trackingGeometry,
0052                                 geometrySelection, stripGeometrySelection);
0053
0054   {
0055     using Config = Acts::SeedFilterConfig;
0056     auto c = py::class_<Config>(m, "SeedFilterConfig").def(py::init<>());
0057     ACTS_PYTHON_STRUCT(
0058         c, deltaInvHelixDiameter, impactWeightFactor, zOriginWeightFactor,
0059         compatSeedWeight, deltaRMin, maxSeedsPerSpM, compatSeedLimit,
0060         seedConfirmation, centralSeedConfirmationRange,
0061         forwardSeedConfirmationRange, useDeltaRorTopRadius, seedWeightIncrement,
0062         numSeedIncrement, maxSeedsPerSpMConf, maxQualitySeedsPerSpMConf);
0063     patchKwargsConstructor(c);
0064   }
0065
0066   {
0067     using Config = Acts::SeedFinderConfig<typename Acts::SpacePointContainer<
0068         ActsExamples::SpacePointContainer<std::vector<const SimSpacePoint*>>,
0069         Acts::detail::RefHolder>::SpacePointProxyType>;
0070     auto c = py::class_<Config>(m, "SeedFinderConfig").def(py::init<>());
0071     ACTS_PYTHON_STRUCT(
0072         c, minPt, cotThetaMax, deltaRMin, deltaRMax, deltaRMinBottomSP,
0073         deltaRMaxBottomSP, deltaRMinTopSP, deltaRMaxTopSP, impactMax,
0074         sigmaScattering, maxPtScattering, maxSeedsPerSpM, collisionRegionMin,
0075         collisionRegionMax, phiMin, phiMax, zMin, zMax, rMax, rMin,
0076         radLengthPerSeed, zAlign, rAlign, sigmaError, maxBlockSize,
0077         nTrplPerSpBLimit, nAvgTrplPerSpBLimit, deltaZMax, zBinEdges,
0078         interactionPointCut, zBinsCustomLooping, useVariableMiddleSPRange,
0079         deltaRMiddleMinSPRange, deltaRMiddleMaxSPRange, rRangeMiddleSP,
0080         rMinMiddle, rMaxMiddle, binSizeR, seedConfirmation,
0081         centralSeedConfirmationRange, forwardSeedConfirmationRange,
0082         useDetailedDoubleMeasurementInfo);
0083     patchKwargsConstructor(c);
0084   }
0085   {
0086     using seedOptions = Acts::SeedFinderOptions;
0087     auto c = py::class_<seedOptions>(m, "SeedFinderOptions").def(py::init<>());
0088     ACTS_PYTHON_STRUCT(c, beamPos, bFieldInZ);
0089     patchKwargsConstructor(c);
0090   }
0091   {
0092     using Config =
0093         Acts::SeedFinderOrthogonalConfig<typename Acts::SpacePointContainer<
0094             ActsExamples::SpacePointContainer<
0095                 std::vector<const SimSpacePoint*>>,
0096             Acts::detail::RefHolder>::SpacePointProxyType>;
0097     auto c =
0098         py::class_<Config>(m, "SeedFinderOrthogonalConfig").def(py::init<>());
0099     ACTS_PYTHON_STRUCT(
0100         c, minPt, cotThetaMax, deltaRMinBottomSP, deltaRMaxBottomSP,
0101         deltaRMinTopSP, deltaRMaxTopSP, impactMax, deltaZMax, sigmaScattering,
0102         maxPtScattering, maxSeedsPerSpM, collisionRegionMin, collisionRegionMax,
0103         phiMin, phiMax, zMin, zMax, rMax, rMin, radLengthPerSeed,
0104         interactionPointCut, deltaPhiMax, highland, maxScatteringAngle2,
0105         useVariableMiddleSPRange, deltaRMiddleMinSPRange,
0106         deltaRMiddleMaxSPRange, rRangeMiddleSP, rMinMiddle, rMaxMiddle,
0107         seedConfirmation, centralSeedConfirmationRange,
0108         forwardSeedConfirmationRange);
0109     patchKwargsConstructor(c);
0110   }
0111
0112   {
0113     using Config = Acts::Experimental::SeedFinderGbtsConfig<SimSpacePoint>;
0114     auto c = py::class_<Config>(m, "SeedFinderGbtsConfig").def(py::init<>());
0115     ACTS_PYTHON_STRUCT(c, minPt, sigmaScattering, highland, maxScatteringAngle2,
0116                        ConnectorInputFile, m_phiSliceWidth, m_nMaxPhiSlice,
0117                        m_useClusterWidth, m_layerGeometry);
0118     patchKwargsConstructor(c);
0119   }
0120
0121   {
0122     using seedConf = Acts::SeedConfirmationRangeConfig;
0123     auto c = py::class_<seedConf>(m, "SeedConfirmationRangeConfig")
0124                  .def(py::init<>());
0125     ACTS_PYTHON_STRUCT(c, zMinSeedConf, zMaxSeedConf, rMaxSeedConf,
0126                        nTopForLargeR, nTopForSmallR, seedConfMinBottomRadius,
0127                        seedConfMaxZOrigin, minImpactSeedConf);
0128     patchKwargsConstructor(c);
0129   }
0130
0131   {
0132     using Config = Acts::CylindricalSpacePointGridConfig;
0133     auto c = py::class_<Config>(m, "SpacePointGridConfig").def(py::init<>());
0134
0135     ACTS_PYTHON_STRUCT(c, minPt, rMax, zMax, zMin, phiMin, phiMax, deltaRMax,
0136                        cotThetaMax, phiBinDeflectionCoverage, maxPhiBins,
0137                        impactMax, zBinEdges);
0138     patchKwargsConstructor(c);
0139   }
0140   {
0141     using Options = Acts::CylindricalSpacePointGridOptions;
0142     auto c = py::class_<Options>(m, "SpacePointGridOptions").def(py::init<>());
0143
0144     ACTS_PYTHON_STRUCT(c, bFieldInZ);
0145     patchKwargsConstructor(c);
0146   }
0147
0148   ACTS_PYTHON_DECLARE_ALGORITHM(
0149       ActsExamples::SeedingAlgorithm, mex, "SeedingAlgorithm", inputSpacePoints,
0150       outputSeeds, seedFilterConfig, seedFinderConfig, seedFinderOptions,
0151       gridConfig, gridOptions, allowSeparateRMax, zBinNeighborsTop,
0152       zBinNeighborsBottom, numPhiNeighbors, useExtraCuts);
0153
0154   ACTS_PYTHON_DECLARE_ALGORITHM(ActsExamples::SeedingOrthogonalAlgorithm, mex,
0155                                 "SeedingOrthogonalAlgorithm", inputSpacePoints,
0156                                 outputSeeds, seedFilterConfig, seedFinderConfig,
0157                                 seedFinderOptions);
0158
0159   ACTS_PYTHON_DECLARE_ALGORITHM(
0160       ActsExamples::GbtsSeedingAlgorithm, mex, "GbtsSeedingAlgorithm",
0161       inputSpacePoints, outputSeeds, seedFinderConfig, seedFinderOptions,
0162       layerMappingFile, geometrySelection, trackingGeometry, ActsGbtsMap,
0163       fill_module_csv, inputClusters);
0164
0165   ACTS_PYTHON_DECLARE_ALGORITHM(
0166       ActsExamples::HoughTransformSeeder, mex, "HoughTransformSeeder",
0167       inputSpacePoints, outputProtoTracks, trackingGeometry, geometrySelection,
0168       inputMeasurements, subRegions, nLayers, xMin, xMax, yMin, yMax,
0169       houghHistSize_x, houghHistSize_y, hitExtend_x, threshold,
0170       localMaxWindowSize, kA);
0171
0172   ACTS_PYTHON_DECLARE_ALGORITHM(ActsExamples::MuonHoughSeeder, mex,
0173                                 "MuonHoughSeeder", inTruthSegments,
0174                                 inSpacePoints, outHoughMax);
0175
0176   ACTS_PYTHON_DECLARE_ALGORITHM(
0177       ActsExamples::TrackParamsEstimationAlgorithm, mex,
0178       "TrackParamsEstimationAlgorithm", inputSeeds, inputProtoTracks,
0179       outputTrackParameters, outputSeeds, outputProtoTracks, trackingGeometry,
0180       magneticField, bFieldMin, initialSigmas, initialSigmaQoverPt,
0181       initialSigmaPtRel, initialVarInflation, noTimeVarInflation,
0182       particleHypothesis);
0183
0184   ACTS_PYTHON_DECLARE_ALGORITHM(ActsExamples::TrackParamsLookupEstimation, mex,
0185                                 "TrackParamsLookupEstimation", refLayers, bins,
0186                                 inputHits, inputParticles,
0187                                 trackLookupGridWriters);
0188
0189   {
0190     using Alg = ActsExamples::TrackFindingAlgorithm;
0191     using Config = Alg::Config;
0192
0193     auto alg =
0194         py::class_<Alg, ActsExamples::IAlgorithm, std::shared_ptr<Alg>>(
0195             mex, "TrackFindingAlgorithm")
0196             .def(py::init<const Config&, Acts::Logging::Level>(),
0197                  py::arg("config"), py::arg("level"))
0198             .def_property_readonly("config", &Alg::config)
0199             .def_static("makeTrackFinderFunction",
0200                         [](std::shared_ptr<const Acts::TrackingGeometry>
0201                                trackingGeometry,
0202                            std::shared_ptr<const Acts::MagneticFieldProvider>
0203                                magneticField,
0204                            Logging::Level level) {
0205                           return Alg::makeTrackFinderFunction(
0206                               std::move(trackingGeometry),
0207                               std::move(magneticField),
0208                               *Acts::getDefaultLogger("TrackFinding", level));
0209                         });
0210
0211     py::class_<Alg::TrackFinderFunction,
0212                std::shared_ptr<Alg::TrackFinderFunction>>(
0213         alg, "TrackFinderFunction");
0214
0215     auto c = py::class_<Config>(alg, "Config").def(py::init<>());
0216     ACTS_PYTHON_STRUCT(c, inputMeasurements, inputInitialTrackParameters,
0217                        inputSeeds, outputTracks, trackingGeometry,
0218                        magneticField, findTracks, measurementSelectorCfg,
0219                        trackSelectorCfg, maxSteps, twoWay, reverseSearch,
0220                        seedDeduplication, stayOnSeed, pixelVolumeIds,
0221                        stripVolumeIds, maxPixelHoles, maxStripHoles, trimTracks,
0222                        constrainToVolumeIds, endOfWorldVolumeIds);
0223   }
0224
0225   {
0226     auto constructor =
0227         [](const std::vector<std::pair<
0228                GeometryIdentifier,
0229                std::tuple<std::vector<double>, std::vector<double>,
0230                           std::vector<double>, std::vector<std::size_t>>>>&
0231                input) {
0232           std::vector<std::pair<GeometryIdentifier, MeasurementSelectorCuts>>
0233               converted;
0234           converted.reserve(input.size());
0235           for (const auto& [id, cuts] : input) {
0236             const auto& [bins, chi2Measurement, chi2Outlier, num] = cuts;
0237             converted.emplace_back(
0238                 id, MeasurementSelectorCuts{bins, chi2Measurement, num,
0239                                             chi2Outlier});
0240           }
0241           return std::make_unique<MeasurementSelector::Config>(converted);
0242         };
0243
0244     py::class_<MeasurementSelectorCuts>(m, "MeasurementSelectorCuts")
0245         .def(py::init<>())
0246         .def(py::init<std::vector<double>, std::vector<double>,
0247                       std::vector<std::size_t>, std::vector<double>>())
0248         .def_readwrite("etaBins", &MeasurementSelectorCuts::etaBins)
0249         .def_readwrite("chi2CutOffMeasurement",
0250                        &MeasurementSelectorCuts::chi2CutOff)
0251         .def_readwrite("chi2CutOffOutlier",
0252                        &MeasurementSelectorCuts::chi2CutOffOutlier)
0253         .def_readwrite("numMeasurementsCutOff",
0254                        &MeasurementSelectorCuts::numMeasurementsCutOff);
0255
0256     auto ms = py::class_<MeasurementSelector>(m, "MeasurementSelector");
0257     auto c =
0258         py::class_<MeasurementSelector::Config>(ms, "Config")
0259             .def(py::init<std::vector<
0260                      std::pair<GeometryIdentifier, MeasurementSelectorCuts>>>())
0261             .def(py::init(constructor));
0262   }
0263 }
0264
0265 }  // namespace Acts::Python