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