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/Seeding/SeedFinderConfig.hpp"
0011 #include "Acts/Seeding/SeedFinderGbtsConfig.hpp"
0012 #include "Acts/Seeding/SeedFinderOrthogonalConfig.hpp"
0013 #include "Acts/Utilities/Logger.hpp"
0014 #include "ActsExamples/EventData/SpacePointContainer.hpp"
0015 #include "ActsExamples/TrackFinding/AdaptiveHoughTransformSeeder.hpp"
0016 #include "ActsExamples/TrackFinding/GbtsSeedingAlgorithm.hpp"
0017 #include "ActsExamples/TrackFinding/GridTripletSeedingAlgorithm.hpp"
0018 #include "ActsExamples/TrackFinding/HoughTransformSeeder.hpp"
0019 #include "ActsExamples/TrackFinding/MuonHoughSeeder.hpp"
0020 #include "ActsExamples/TrackFinding/OrthogonalTripletSeedingAlgorithm.hpp"
0021 #include "ActsExamples/TrackFinding/SeedingAlgorithm.hpp"
0022 #include "ActsExamples/TrackFinding/SeedingOrthogonalAlgorithm.hpp"
0023 #include "ActsExamples/TrackFinding/SpacePointMaker.hpp"
0024 #include "ActsExamples/TrackFinding/TrackFindingAlgorithm.hpp"
0025 #include "ActsExamples/TrackFinding/TrackParamsEstimationAlgorithm.hpp"
0026 #include "ActsExamples/TrackFinding/TrackParamsLookupEstimation.hpp"
0027 #include "ActsPython/Utilities/Helpers.hpp"
0028 #include "ActsPython/Utilities/Macros.hpp"
0029
0030 #include <cstddef>
0031 #include <memory>
0032 #include <utility>
0033 #include <vector>
0034
0035 #include <pybind11/pybind11.h>
0036 #include <pybind11/stl.h>
0037
0038 namespace py = pybind11;
0039
0040 using namespace ActsExamples;
0041
0042 namespace ActsPython {
0043
0044 void addTrackFinding(Context& ctx) {
0045   auto& mex = ctx.get("examples");
0046
0047   ACTS_PYTHON_DECLARE_ALGORITHM(SpacePointMaker, mex, "SpacePointMaker",
0048                                 inputMeasurements, outputSpacePoints,
0049                                 trackingGeometry, geometrySelection,
0050                                 stripGeometrySelection);
0051
0052   {
0053     using Config = Acts::SeedFinderConfig<typename Acts::SpacePointContainer<
0054         SpacePointContainer<std::vector<const SimSpacePoint*>>,
0055         Acts::detail::RefHolder>::SpacePointProxyType>;
0056     auto c = py::class_<Config>(mex, "SeedFinderConfig").def(py::init<>());
0057     ACTS_PYTHON_STRUCT(
0058         c, minPt, cotThetaMax, deltaRMin, deltaRMax, deltaRMinBottomSP,
0059         deltaRMaxBottomSP, deltaRMinTopSP, deltaRMaxTopSP, impactMax,
0060         sigmaScattering, maxPtScattering, maxSeedsPerSpM, collisionRegionMin,
0061         collisionRegionMax, phiMin, phiMax, zMin, zMax, rMax, rMin,
0062         radLengthPerSeed, zAlign, rAlign, sigmaError, maxBlockSize,
0063         nTrplPerSpBLimit, nAvgTrplPerSpBLimit, deltaZMax, zBinEdges,
0064         interactionPointCut, zBinsCustomLooping, useVariableMiddleSPRange,
0065         deltaRMiddleMinSPRange, deltaRMiddleMaxSPRange, rRangeMiddleSP,
0066         rMinMiddle, rMaxMiddle, binSizeR, seedConfirmation,
0067         centralSeedConfirmationRange, forwardSeedConfirmationRange,
0068         useDetailedDoubleMeasurementInfo);
0069     patchKwargsConstructor(c);
0070   }
0071
0072   {
0073     using Config =
0074         Acts::SeedFinderOrthogonalConfig<typename Acts::SpacePointContainer<
0075             SpacePointContainer<std::vector<const SimSpacePoint*>>,
0076             Acts::detail::RefHolder>::SpacePointProxyType>;
0077     auto c =
0078         py::class_<Config>(mex, "SeedFinderOrthogonalConfig").def(py::init<>());
0079     ACTS_PYTHON_STRUCT(
0080         c, minPt, cotThetaMax, deltaRMinBottomSP, deltaRMaxBottomSP,
0081         deltaRMinTopSP, deltaRMaxTopSP, impactMax, deltaZMax, sigmaScattering,
0082         maxPtScattering, maxSeedsPerSpM, collisionRegionMin, collisionRegionMax,
0083         phiMin, phiMax, zMin, zMax, rMax, rMin, radLengthPerSeed,
0084         interactionPointCut, deltaPhiMax, highland, maxScatteringAngle2,
0085         useVariableMiddleSPRange, deltaRMiddleMinSPRange,
0086         deltaRMiddleMaxSPRange, rRangeMiddleSP, rMinMiddle, rMaxMiddle,
0087         seedConfirmation, centralSeedConfirmationRange,
0088         forwardSeedConfirmationRange);
0089     patchKwargsConstructor(c);
0090   }
0091
0092   {
0093     using Config = Acts::Experimental::SeedFinderGbtsConfig<SimSpacePoint>;
0094     auto c = py::class_<Config>(mex, "SeedFinderGbtsConfig").def(py::init<>());
0095     ACTS_PYTHON_STRUCT(c, minPt, sigmaScattering, highland, maxScatteringAngle2,
0096                        ConnectorInputFile, m_phiSliceWidth, m_nMaxPhiSlice,
0097                        m_useClusterWidth, m_layerGeometry);
0098     patchKwargsConstructor(c);
0099   }
0100
0101   ACTS_PYTHON_DECLARE_ALGORITHM(
0102       SeedingAlgorithm, mex, "SeedingAlgorithm", inputSpacePoints, outputSeeds,
0103       seedFilterConfig, seedFinderConfig, seedFinderOptions, gridConfig,
0104       gridOptions, allowSeparateRMax, zBinNeighborsTop, zBinNeighborsBottom,
0105       numPhiNeighbors, useExtraCuts);
0106
0107   ACTS_PYTHON_DECLARE_ALGORITHM(
0108       GridTripletSeedingAlgorithm, mex, "GridTripletSeedingAlgorithm",
0109       inputSpacePoints, outputSeeds, bFieldInZ, minPt, cotThetaMax, impactMax,
0110       deltaRMin, deltaRMax, deltaRMinTop, deltaRMaxTop, deltaRMinBottom,
0111       deltaRMaxBottom, rMin, rMax, zMin, zMax, phiMin, phiMax,
0112       phiBinDeflectionCoverage, maxPhiBins, zBinNeighborsTop,
0113       zBinNeighborsBottom, numPhiNeighbors, zBinEdges, zBinsCustomLooping,
0114       rMinMiddle, rMaxMiddle, useVariableMiddleSPRange, rRangeMiddleSP,
0115       deltaRMiddleMinSPRange, deltaRMiddleMaxSPRange, deltaZMin, deltaZMax,
0116       interactionPointCut, collisionRegionMin, collisionRegionMax,
0117       helixCutTolerance, sigmaScattering, radLengthPerSeed, toleranceParam,
0118       deltaInvHelixDiameter, compatSeedWeight, impactWeightFactor,
0119       zOriginWeightFactor, maxSeedsPerSpM, compatSeedLimit, seedWeightIncrement,
0120       numSeedIncrement, seedConfirmation, centralSeedConfirmationRange,
0121       forwardSeedConfirmationRange, maxSeedsPerSpMConf,
0122       maxQualitySeedsPerSpMConf, useDeltaRinsteadOfTopRadius, useExtraCuts);
0123
0124   ACTS_PYTHON_DECLARE_ALGORITHM(
0125       OrthogonalTripletSeedingAlgorithm, mex,
0126       "OrthogonalTripletSeedingAlgorithm", inputSpacePoints, outputSeeds,
0127       bFieldInZ, minPt, cotThetaMax, impactMax, deltaRMin, deltaRMax,
0128       deltaRMinTop, deltaRMaxTop, deltaRMinBottom, deltaRMaxBottom, rMin, rMax,
0129       zMin, zMax, phiMin, phiMax, rMinMiddle, rMaxMiddle,
0130       useVariableMiddleSPRange, rRangeMiddleSP, deltaRMiddleMinSPRange,
0131       deltaRMiddleMaxSPRange, deltaZMin, deltaZMax, interactionPointCut,
0132       collisionRegionMin, collisionRegionMax, helixCutTolerance,
0133       sigmaScattering, radLengthPerSeed, toleranceParam, deltaInvHelixDiameter,
0134       compatSeedWeight, impactWeightFactor, zOriginWeightFactor, maxSeedsPerSpM,
0135       compatSeedLimit, seedWeightIncrement, numSeedIncrement, seedConfirmation,
0136       centralSeedConfirmationRange, forwardSeedConfirmationRange,
0137       maxSeedsPerSpMConf, maxQualitySeedsPerSpMConf,
0138       useDeltaRinsteadOfTopRadius, useExtraCuts);
0139
0140   ACTS_PYTHON_DECLARE_ALGORITHM(SeedingOrthogonalAlgorithm, mex,
0141                                 "SeedingOrthogonalAlgorithm", inputSpacePoints,
0142                                 outputSeeds, seedFilterConfig, seedFinderConfig,
0143                                 seedFinderOptions);
0144
0145   ACTS_PYTHON_DECLARE_ALGORITHM(
0146       GbtsSeedingAlgorithm, mex, "GbtsSeedingAlgorithm", inputSpacePoints,
0147       outputSeeds, seedFinderConfig, seedFinderOptions, layerMappingFile,
0148       geometrySelection, trackingGeometry, ActsGbtsMap, fill_module_csv,
0149       inputClusters);
0150
0151   ACTS_PYTHON_DECLARE_ALGORITHM(
0152       HoughTransformSeeder, mex, "HoughTransformSeeder", inputSpacePoints,
0153       outputProtoTracks, trackingGeometry, geometrySelection, inputMeasurements,
0154       subRegions, nLayers, xMin, xMax, yMin, yMax, houghHistSize_x,
0155       houghHistSize_y, hitExtend_x, threshold, localMaxWindowSize, kA);
0156
0157   ACTS_PYTHON_DECLARE_ALGORITHM(
0158       AdaptiveHoughTransformSeeder, mex, "AdaptiveHoughTransformSeeder",
0159       inputSpacePoints, outputSeeds, outputProtoTracks, trackingGeometry,
0160       qOverPtMin, qOverPtMinBinSize, phiMinBinSize, threshold, noiseThreshold,
0161       deduplicate, inverseA, doSecondPhase, zRange, cotThetaRange,
0162       cotThetaMinBinSize, zMinBinSize);
0163
0164   ACTS_PYTHON_DECLARE_ALGORITHM(MuonHoughSeeder, mex, "MuonHoughSeeder",
0165                                 inTruthSegments, inSpacePoints, outHoughMax,
0166                                 nBinsTanTheta, nBinsY0, nBinsTanPhi, nBinsX0);
0167
0168   ACTS_PYTHON_DECLARE_ALGORITHM(
0169       TrackParamsEstimationAlgorithm, mex, "TrackParamsEstimationAlgorithm",
0170       inputSeeds, inputProtoTracks, inputParticleHypotheses,
0171       outputTrackParameters, outputSeeds, outputProtoTracks, trackingGeometry,
0172       magneticField, bFieldMin, initialSigmas, initialSigmaQoverPt,
0173       initialSigmaPtRel, initialVarInflation, noTimeVarInflation,
0174       particleHypothesis);
0175
0176   ACTS_PYTHON_DECLARE_ALGORITHM(
0177       TrackParamsLookupEstimation, mex, "TrackParamsLookupEstimation",
0178       refLayers, bins, inputHits, inputParticles, trackLookupGridWriters);
0179
0180   {
0181     using Alg = TrackFindingAlgorithm;
0182     using Config = Alg::Config;
0183
0184     auto alg =
0185         py::class_<Alg, IAlgorithm, std::shared_ptr<Alg>>(
0186             mex, "TrackFindingAlgorithm")
0187             .def(py::init<const Config&, Acts::Logging::Level>(),
0188                  py::arg("config"), py::arg("level"))
0189             .def_property_readonly("config", &Alg::config)
0190             .def_static("makeTrackFinderFunction",
0191                         [](std::shared_ptr<const Acts::TrackingGeometry>
0192                                trackingGeometry,
0193                            std::shared_ptr<const Acts::MagneticFieldProvider>
0194                                magneticField,
0195                            Acts::Logging::Level level) {
0196                           return Alg::makeTrackFinderFunction(
0197                               std::move(trackingGeometry),
0198                               std::move(magneticField),
0199                               *Acts::getDefaultLogger("TrackFinding", level));
0200                         });
0201
0202     py::class_<Alg::TrackFinderFunction,
0203                std::shared_ptr<Alg::TrackFinderFunction>>(
0204         alg, "TrackFinderFunction");
0205
0206     auto c = py::class_<Config>(alg, "Config").def(py::init<>());
0207     ACTS_PYTHON_STRUCT(c, inputMeasurements, inputInitialTrackParameters,
0208                        inputSeeds, outputTracks, trackingGeometry,
0209                        magneticField, findTracks, measurementSelectorCfg,
0210                        trackSelectorCfg, maxSteps, twoWay, reverseSearch,
0211                        seedDeduplication, stayOnSeed, pixelVolumeIds,
0212                        stripVolumeIds, maxPixelHoles, maxStripHoles, trimTracks,
0213                        constrainToVolumeIds, endOfWorldVolumeIds);
0214   }
0215 }
0216
0217 }  // namespace ActsPython