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;
0094     auto c = py::class_<Config>(mex, "SeedFinderGbtsConfig").def(py::init<>());
0095     ACTS_PYTHON_STRUCT(c, minPt, ConnectorInputFile, phiSliceWidth,
0096                        nMaxPhiSlice);
0097     patchKwargsConstructor(c);
0098   }
0099
0100   ACTS_PYTHON_DECLARE_ALGORITHM(
0101       SeedingAlgorithm, mex, "SeedingAlgorithm", inputSpacePoints, outputSeeds,
0102       seedFilterConfig, seedFinderConfig, seedFinderOptions, gridConfig,
0103       gridOptions, allowSeparateRMax, zBinNeighborsTop, zBinNeighborsBottom,
0104       numPhiNeighbors, useExtraCuts);
0105
0106   ACTS_PYTHON_DECLARE_ALGORITHM(
0107       GridTripletSeedingAlgorithm, mex, "GridTripletSeedingAlgorithm",
0108       inputSpacePoints, outputSeeds, bFieldInZ, minPt, cotThetaMax, impactMax,
0109       deltaRMin, deltaRMax, deltaRMinTop, deltaRMaxTop, deltaRMinBottom,
0110       deltaRMaxBottom, rMin, rMax, zMin, zMax, phiMin, phiMax,
0111       phiBinDeflectionCoverage, maxPhiBins, zBinNeighborsTop,
0112       zBinNeighborsBottom, numPhiNeighbors, zBinEdges, zBinsCustomLooping,
0113       rMinMiddle, rMaxMiddle, useVariableMiddleSPRange, rRangeMiddleSP,
0114       deltaRMiddleMinSPRange, deltaRMiddleMaxSPRange, deltaZMin, deltaZMax,
0115       interactionPointCut, collisionRegionMin, collisionRegionMax,
0116       helixCutTolerance, sigmaScattering, radLengthPerSeed, toleranceParam,
0117       deltaInvHelixDiameter, compatSeedWeight, impactWeightFactor,
0118       zOriginWeightFactor, maxSeedsPerSpM, compatSeedLimit, seedWeightIncrement,
0119       numSeedIncrement, seedConfirmation, centralSeedConfirmationRange,
0120       forwardSeedConfirmationRange, maxSeedsPerSpMConf,
0121       maxQualitySeedsPerSpMConf, useDeltaRinsteadOfTopRadius, useExtraCuts);
0122
0123   ACTS_PYTHON_DECLARE_ALGORITHM(
0124       OrthogonalTripletSeedingAlgorithm, mex,
0125       "OrthogonalTripletSeedingAlgorithm", inputSpacePoints, outputSeeds,
0126       bFieldInZ, minPt, cotThetaMax, impactMax, deltaRMin, deltaRMax,
0127       deltaRMinTop, deltaRMaxTop, deltaRMinBottom, deltaRMaxBottom, rMin, rMax,
0128       zMin, zMax, phiMin, phiMax, rMinMiddle, rMaxMiddle,
0129       useVariableMiddleSPRange, rRangeMiddleSP, deltaRMiddleMinSPRange,
0130       deltaRMiddleMaxSPRange, deltaZMin, deltaZMax, interactionPointCut,
0131       collisionRegionMin, collisionRegionMax, helixCutTolerance,
0132       sigmaScattering, radLengthPerSeed, toleranceParam, deltaInvHelixDiameter,
0133       compatSeedWeight, impactWeightFactor, zOriginWeightFactor, maxSeedsPerSpM,
0134       compatSeedLimit, seedWeightIncrement, numSeedIncrement, seedConfirmation,
0135       centralSeedConfirmationRange, forwardSeedConfirmationRange,
0136       maxSeedsPerSpMConf, maxQualitySeedsPerSpMConf,
0137       useDeltaRinsteadOfTopRadius, useExtraCuts);
0138
0139   ACTS_PYTHON_DECLARE_ALGORITHM(SeedingOrthogonalAlgorithm, mex,
0140                                 "SeedingOrthogonalAlgorithm", inputSpacePoints,
0141                                 outputSeeds, seedFilterConfig, seedFinderConfig,
0142                                 seedFinderOptions);
0143
0144   ACTS_PYTHON_DECLARE_ALGORITHM(
0145       ActsExamples::GbtsSeedingAlgorithm, mex, "GbtsSeedingAlgorithm",
0146       inputSpacePoints, outputSeeds, seedFinderConfig, seedFinderOptions,
0147       layerMappingFile, trackingGeometry, ActsGbtsMap, fill_module_csv,
0148       inputClusters);
0149
0150   ACTS_PYTHON_DECLARE_ALGORITHM(
0151       HoughTransformSeeder, mex, "HoughTransformSeeder", inputSpacePoints,
0152       outputProtoTracks, trackingGeometry, geometrySelection, inputMeasurements,
0153       subRegions, nLayers, xMin, xMax, yMin, yMax, houghHistSize_x,
0154       houghHistSize_y, hitExtend_x, threshold, localMaxWindowSize, kA);
0155
0156   ACTS_PYTHON_DECLARE_ALGORITHM(
0157       AdaptiveHoughTransformSeeder, mex, "AdaptiveHoughTransformSeeder",
0158       inputSpacePoints, outputSeeds, outputProtoTracks, trackingGeometry,
0159       qOverPtMin, qOverPtMinBinSize, phiMinBinSize, threshold, noiseThreshold,
0160       deduplicate, inverseA, doSecondPhase, zRange, cotThetaRange,
0161       cotThetaMinBinSize, zMinBinSize);
0162
0163   ACTS_PYTHON_DECLARE_ALGORITHM(MuonHoughSeeder, mex, "MuonHoughSeeder",
0164                                 inTruthSegments, inSpacePoints, outHoughMax,
0165                                 nBinsTanTheta, nBinsY0, nBinsTanPhi, nBinsX0);
0166
0167   ACTS_PYTHON_DECLARE_ALGORITHM(
0168       TrackParamsEstimationAlgorithm, mex, "TrackParamsEstimationAlgorithm",
0169       inputSeeds, inputProtoTracks, inputParticleHypotheses,
0170       outputTrackParameters, outputSeeds, outputProtoTracks, trackingGeometry,
0171       magneticField, bFieldMin, initialSigmas, initialSigmaQoverPt,
0172       initialSigmaPtRel, initialVarInflation, noTimeVarInflation,
0173       particleHypothesis);
0174
0175   ACTS_PYTHON_DECLARE_ALGORITHM(
0176       TrackParamsLookupEstimation, mex, "TrackParamsLookupEstimation",
0177       refLayers, bins, inputHits, inputParticles, trackLookupGridWriters);
0178
0179   {
0180     using Alg = TrackFindingAlgorithm;
0181     using Config = Alg::Config;
0182
0183     auto alg =
0184         py::class_<Alg, IAlgorithm, std::shared_ptr<Alg>>(
0185             mex, "TrackFindingAlgorithm")
0186             .def(py::init<const Config&, Acts::Logging::Level>(),
0187                  py::arg("config"), py::arg("level"))
0188             .def_property_readonly("config", &Alg::config)
0189             .def_static("makeTrackFinderFunction",
0190                         [](std::shared_ptr<const Acts::TrackingGeometry>
0191                                trackingGeometry,
0192                            std::shared_ptr<const Acts::MagneticFieldProvider>
0193                                magneticField,
0194                            Acts::Logging::Level level) {
0195                           return Alg::makeTrackFinderFunction(
0196                               std::move(trackingGeometry),
0197                               std::move(magneticField),
0198                               *Acts::getDefaultLogger("TrackFinding", level));
0199                         });
0200
0201     py::class_<Alg::TrackFinderFunction,
0202                std::shared_ptr<Alg::TrackFinderFunction>>(
0203         alg, "TrackFinderFunction");
0204
0205     auto c = py::class_<Config>(alg, "Config").def(py::init<>());
0206     ACTS_PYTHON_STRUCT(c, inputMeasurements, inputInitialTrackParameters,
0207                        inputSeeds, outputTracks, trackingGeometry,
0208                        magneticField, findTracks, measurementSelectorCfg,
0209                        trackSelectorCfg, maxSteps, twoWay, reverseSearch,
0210                        seedDeduplication, stayOnSeed, pixelVolumeIds,
0211                        stripVolumeIds, maxPixelHoles, maxStripHoles, trimTracks,
0212                        constrainToVolumeIds, endOfWorldVolumeIds);
0213   }
0214 }
0215
0216 }  // namespace ActsPython