// This file is part of the ACTS project.

//

// Copyright (C) 2016 CERN for the benefit of the ACTS project

//

// This Source Code Form is subject to the terms of the Mozilla Public

// License, v. 2.0. If a copy of the MPL was not distributed with this

// file, You can obtain one at https://mozilla.org/MPL/2.0/.

#include "Acts/Propagator/AtlasStepper.hpp"

#include "Acts/Propagator/EigenStepper.hpp"

#include "Acts/Propagator/Navigator.hpp"

#include "Acts/Propagator/Propagator.hpp"

#include "Acts/Propagator/StraightLineStepper.hpp"

#include "Acts/Propagator/SympyStepper.hpp"

#include "Acts/Utilities/Logger.hpp"

#include "ActsPython/Utilities/Helpers.hpp"

#include "ActsPython/Utilities/Macros.hpp"

#include <memory>

#include <pybind11/pybind11.h>

#include <pybind11/stl.h>

namespace py = pybind11;

using namespace pybind11::literals;

using namespace Acts;

namespace ActsPython {

template <typename stepper_t, typename navigator_t>

void addPropagator(py::module_& m, const std::string& prefix) {

using propagator_t = Propagator<stepper_t, navigator_t>;

py::class_<propagator_t>(m, (prefix + "Propagator").c_str())

.def(py::init<>([=](stepper_t stepper, navigator_t navigator,

Logging::Level level = Logging::Level::INFO) {

return propagator_t{

std::move(stepper), std::move(navigator),

getDefaultLogger(prefix + "Propagator", level)};

}),

py::arg("stepper"), py::arg("navigator"),

py::arg("level") = Logging::INFO);

}

/// @brief Bind propagation related functions to the Python module

/// @param m The Python module to which the functions will be bound

void addPropagation(py::module_& m) {

{

using Config = Navigator::Config;

auto nav =

py::class_<Navigator, std::shared_ptr<Navigator>>(m, "Navigator")

.def(py::init<>([](const Config& cfg,

Logging::Level level = Logging::INFO) {

return Navigator{cfg, getDefaultLogger("Navigator", level)};

}),

py::arg("cfg"), py::arg("level") = Logging::INFO);

auto c = py::class_<Config>(nav, "Config").def(py::init<>());

ACTS_PYTHON_STRUCT(c, resolveMaterial, resolvePassive, resolveSensitive,

trackingGeometry);

}

{

auto stepper = py::class_<AtlasStepper>(m, "AtlasStepper");

stepper.def(py::init<std::shared_ptr<const MagneticFieldProvider>>());

addPropagator<AtlasStepper, Navigator>(m, "Atlas");

}

{

auto stepper = py::class_<EigenStepper<>>(m, "EigenStepper");

stepper.def(py::init<std::shared_ptr<const MagneticFieldProvider>>());

addPropagator<EigenStepper<>, Navigator>(m, "Eigen");

}

{

auto stepper = py::class_<StraightLineStepper>(m, "StraightLineStepper");

stepper.def(py::init<>());

addPropagator<StraightLineStepper, Navigator>(m, "StraightLine");

}

{

auto stepper = py::class_<SympyStepper>(m, "SympyStepper");

stepper.def(py::init<std::shared_ptr<const MagneticFieldProvider>>());

addPropagator<SympyStepper, Navigator>(m, "Sympy");

}

}

} // namespace ActsPython