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