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