Python/src/Propagation.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/Definitions/Direction.hpp"
0010 #include "Acts/EventData/TrackParameters.hpp"
0011 #include "Acts/Navigation/DetectorNavigator.hpp"
0012 #include "Acts/Plugins/Python/Utilities.hpp"
0013 #include "Acts/Propagator/AtlasStepper.hpp"
0014 #include "Acts/Propagator/EigenStepper.hpp"
0015 #include "Acts/Propagator/Navigator.hpp"
0016 #include "Acts/Propagator/Propagator.hpp"
0017 #include "Acts/Propagator/StraightLineStepper.hpp"
0018 #include "Acts/Propagator/SympyStepper.hpp"
0019 #include "Acts/Utilities/Logger.hpp"
0020 #include "ActsExamples/Propagation/PropagationAlgorithm.hpp"
0021 #include "ActsExamples/Propagation/PropagatorInterface.hpp"
0022
0023 #include <algorithm>
0024 #include <array>
0025 #include <map>
0026 #include <memory>
0027 #include <optional>
0028 #include <string>
0029 #include <tuple>
0030 #include <utility>
0031 #include <vector>
0032
0033 #include <pybind11/pybind11.h>
0034 #include <pybind11/stl.h>
0035
0036 namespace Acts {
0037 class MagneticFieldProvider;
0038 }  // namespace Acts
0039
0040 namespace py = pybind11;
0041
0042 namespace {
0043
0044 template <typename stepper_t, typename navigator_t>
0045 void addPropagator(py::module_& m, const std::string& prefix) {
0046   using propagator_t = Acts::Propagator<stepper_t, navigator_t>;
0047   py::class_<propagator_t>(m, (prefix + "Propagator").c_str())
0048       .def(py::init<>(
0049                [=](stepper_t stepper, navigator_t navigator,
0050                    Acts::Logging::Level level = Acts::Logging::Level::INFO) {
0051                  return propagator_t{
0052                      std::move(stepper), std::move(navigator),
0053                      Acts::getDefaultLogger(prefix + "Propagator", level)};
0054                }),
0055            py::arg("stepper"), py::arg("navigator"),
0056            py::arg("level") = Acts::Logging::INFO);
0057
0058   using prop_if_t = ActsExamples::ConcretePropagator<propagator_t>;
0059   py::class_<prop_if_t, ActsExamples::PropagatorInterface,
0060              std::shared_ptr<prop_if_t>>(
0061       m, (prefix + "ConcretePropagator").c_str())
0062       .def(py::init<propagator_t>());
0063 }
0064
0065 }  // namespace
0066
0067 namespace Acts::Python {
0068 void addPropagation(Context& ctx) {
0069   auto [m, prop, mex] = ctx.get("main", "propagation", "examples");
0070
0071   {
0072     using Config = Acts::Navigator::Config;
0073     auto nav =
0074         py::class_<Acts::Navigator, std::shared_ptr<Acts::Navigator>>(
0075             m, "Navigator")
0076             .def(py::init<>([](Config cfg,
0077                                Logging::Level level = Logging::INFO) {
0078                    return Navigator{cfg, getDefaultLogger("Navigator", level)};
0079                  }),
0080                  py::arg("cfg"), py::arg("level") = Logging::INFO);
0081
0082     auto c = py::class_<Config>(nav, "Config").def(py::init<>());
0083
0084     ACTS_PYTHON_STRUCT(c, resolveMaterial, resolvePassive, resolveSensitive,
0085                        trackingGeometry);
0086   }
0087
0088   {
0089     using Config = Acts::Experimental::DetectorNavigator::Config;
0090     auto nav =
0091         py::class_<Acts::Experimental::DetectorNavigator,
0092                    std::shared_ptr<Acts::Experimental::DetectorNavigator>>(
0093             m, "DetectorNavigator")
0094             .def(py::init<>(
0095                      [](Config cfg, Logging::Level level = Logging::INFO) {
0096                        return Acts::Experimental::DetectorNavigator{
0097                            cfg, getDefaultLogger("DetectorNavigator", level)};
0098                      }),
0099                  py::arg("cfg"), py::arg("level") = Logging::INFO);
0100
0101     auto c = py::class_<Config>(nav, "Config").def(py::init<>());
0102
0103     ACTS_PYTHON_STRUCT(c, resolveMaterial, resolvePassive, resolveSensitive,
0104                        detector);
0105   }
0106
0107   ACTS_PYTHON_DECLARE_ALGORITHM(
0108       ActsExamples::PropagationAlgorithm, mex, "PropagationAlgorithm",
0109       propagatorImpl, sterileLogger, debugOutput, energyLoss,
0110       multipleScattering, recordMaterialInteractions, ptLoopers, maxStepSize,
0111       covarianceTransport, inputTrackParameters, outputSummaryCollection,
0112       outputMaterialCollection);
0113
0114   py::class_<ActsExamples::PropagatorInterface,
0115              std::shared_ptr<ActsExamples::PropagatorInterface>>(
0116       mex, "PropagatorInterface");
0117
0118   // Eigen based stepper
0119   {
0120     auto stepper = py::class_<Acts::EigenStepper<>>(m, "EigenStepper");
0121     stepper.def(py::init<std::shared_ptr<const Acts::MagneticFieldProvider>>());
0122
0123     addPropagator<Acts::EigenStepper<>, Acts::Navigator>(prop, "Eigen");
0124   }
0125
0126   {
0127     addPropagator<Acts::EigenStepper<>, Acts::Experimental::DetectorNavigator>(
0128         prop, "EigenDetector");
0129   }
0130
0131   // ATLAS based stepper
0132   {
0133     auto stepper = py::class_<Acts::AtlasStepper>(m, "AtlasStepper");
0134     stepper.def(py::init<std::shared_ptr<const Acts::MagneticFieldProvider>>());
0135
0136     addPropagator<Acts::AtlasStepper, Acts::Navigator>(prop, "Atlas");
0137   }
0138
0139   {
0140     addPropagator<Acts::AtlasStepper, Acts::Experimental::DetectorNavigator>(
0141         prop, "AtlasDetector");
0142   }
0143
0144   // Sympy based stepper
0145   {
0146     auto stepper = py::class_<Acts::SympyStepper>(m, "SympyStepper");
0147     stepper.def(py::init<std::shared_ptr<const Acts::MagneticFieldProvider>>());
0148
0149     addPropagator<Acts::SympyStepper, Acts::Navigator>(prop, "Sympy");
0150   }
0151
0152   {
0153     addPropagator<Acts::SympyStepper, Acts::Experimental::DetectorNavigator>(
0154         prop, "SympyDetector");
0155   }
0156
0157   // Straight line stepper
0158   {
0159     auto stepper =
0160         py::class_<Acts::StraightLineStepper>(m, "StraightLineStepper");
0161     stepper.def(py::init<>());
0162
0163     addPropagator<Acts::StraightLineStepper, Acts::Navigator>(prop,
0164                                                               "StraightLine");
0165   }
0166
0167   {
0168     addPropagator<Acts::StraightLineStepper,
0169                   Acts::Experimental::DetectorNavigator>(
0170         prop, "StraightLineDetector");
0171   }
0172 }
0173
0174 }  // namespace Acts::Python