From 2a4ff54bca64971c8e7b8f9e9ec290a22e912112 Mon Sep 17 00:00:00 2001 From: Dario Izzo Date: Tue, 28 Jan 2025 17:15:19 +0100 Subject: [PATCH 1/3] Moving some python routines to C++ (speedup > 4x) --- CMakeLists.txt | 1 + include/kep3/core_astro/encodings.hpp | 25 +++++++++++ pykep/core.cpp | 9 +++- pykep/docstrings.cpp | 62 +++++++++++++++++++++++++++ pykep/docstrings.hpp | 6 +++ pykep/test_utils.py | 16 +++---- pykep/trajopt/_mga.py | 10 ++--- pykep/trajopt/_mga_1dsm.py | 12 +++--- pykep/utils/__init__.py | 2 +- pykep/utils/_encoding_conversions.py | 11 +++-- src/core_astro/encodings.cpp | 61 ++++++++++++++++++++++++++ test/CMakeLists.txt | 3 +- test/convert_anomalies_test.cpp | 2 - test/encodings_test.cpp | 21 +++++++++ 14 files changed, 211 insertions(+), 30 deletions(-) create mode 100644 include/kep3/core_astro/encodings.hpp create mode 100644 src/core_astro/encodings.cpp create mode 100644 test/encodings_test.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 53631890..e6d5305f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -153,6 +153,7 @@ set(kep3_SRC_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src/core_astro/eq2par2eq.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/core_astro/stm.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/core_astro/propagate_lagrangian.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/core_astro/encodings.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/ta/stark.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/ta/cr3bp.cpp" ) diff --git a/include/kep3/core_astro/encodings.hpp b/include/kep3/core_astro/encodings.hpp new file mode 100644 index 00000000..56e2d13b --- /dev/null +++ b/include/kep3/core_astro/encodings.hpp @@ -0,0 +1,25 @@ +// Copyright 2023, 2024 Dario Izzo (dario.izzo@gmail.com), Francesco Biscani +// (bluescarni@gmail.com) +// +// This file is part of the kep3 library. +// +// 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 http://mozilla.org/MPL/2.0/. + +#ifndef kep3_ENCODING_CONVERSIONS_H +#define kep3_ENCODING_CONVERSIONS_H + +#include + +#include + +namespace kep3 +{ +kep3_DLL_PUBLIC std::vector alpha2direct(const std::vector &alphas, double tof); +kep3_DLL_PUBLIC std::pair, double> direct2alpha(const std::vector &tofs); +kep3_DLL_PUBLIC std::vector eta2direct(const std::vector &etas, double max_tof); +kep3_DLL_PUBLIC std::vector direct2eta(const std::vector &tofs, double max_tof); +} // namespace kep3 + +#endif \ No newline at end of file diff --git a/pykep/core.cpp b/pykep/core.cpp index 6298a5fd..73654644 100644 --- a/pykep/core.cpp +++ b/pykep/core.cpp @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -109,7 +110,7 @@ PYBIND11_MODULE(core, m) // NOLINT m.def("zeta2f_v", py::vectorize(kep3::zeta2f), pk::zeta2f_v_doc().c_str()); m.def("f2zeta_v", py::vectorize(kep3::f2zeta), pk::f2zeta_v_doc().c_str()); - // Eposing element conversions + // Exposing element conversions m.def("ic2par", &kep3::ic2par); m.def("par2ic", &kep3::par2ic); m.def("ic2eq", &kep3::ic2eq); @@ -117,6 +118,12 @@ PYBIND11_MODULE(core, m) // NOLINT m.def("par2eq", &kep3::par2eq); m.def("eq2par", &kep3::eq2par); + // Exposing encoding conversions + m.def("alpha2direct", &kep3::alpha2direct, py::arg("alphas"), py::arg("tof"), pk::alpha2direct_doc().c_str()); + m.def("direct2alpha", &kep3::direct2alpha, py::arg("tofs") , pk::direct2alpha_doc().c_str()); + m.def("eta2direct", &kep3::eta2direct, py::arg("etas"), py::arg("max_tof"), pk::eta2direct_doc().c_str()); + m.def("direct2eta", &kep3::direct2eta, py::arg("tofs"), py::arg("max_tof"), pk::direct2eta_doc().c_str()); + // Class epoch py::class_ epoch_class(m, "epoch", "Represents a specific point in time."); diff --git a/pykep/docstrings.cpp b/pykep/docstrings.cpp index e9991745..18940590 100644 --- a/pykep/docstrings.cpp +++ b/pykep/docstrings.cpp @@ -698,6 +698,68 @@ std::string f2zeta_v_doc() )"; } +std::string alpha2direct_doc() +{ + return R"(alpha2direct(alphas) + + Converts from alpha encoded to transfer times. + + Args: + *alphas* (:class:`list`): a sequence of transfer times encoded using the alpha encoding. + + *T* (:class:`float`): the total transfer time. + + Returns: + :class:`list`:: The encoded transfer times +)"; +} + +std::string direct2alpha_doc() +{ + return R"(direct2alpha(tofs) + + Converts from transfer times to alpha encoded. + + Args: + *tofs* (:class:`list`): a sequence of transfer times. + + Returns: + :class:`list`:, :class:`float`: The alpha-encoded transfer times, the total transfer time (for cenvenience) +)"; +} + +std::string eta2direct_doc() +{ + return R"(eta2direct(etas, max_tof) + + Converts from eta encoded to transfer times. + + Args: + *etas* (:class:`list`): a sequence of transfer times encoded using the eta encoding. + + *max_tof* (:class:`float`): maximum time of flight (might actually be less according to the value of the last eta.) + + Returns: + :class:`list`: The encoded transfer times +)"; +} + +std::string direct2eta_doc() +{ + return R"(direct2eta(tofs, max_tof) + + Converts from transfer times to eta encoded. + + Args: + *tofs* (:class:`list`): a sequence of transfer times + + *max_tof* (:class:`float`): maximum time of flight (might actually be less according to the value of the last eta.) + + Returns: + :class:`list`: The eta-encoded transfer times +)"; +} + std::string epoch_from_float_doc() { return R"(__init__(when: float, julian_type = MJD2000) diff --git a/pykep/docstrings.hpp b/pykep/docstrings.hpp index 57a1ca06..2afd876d 100644 --- a/pykep/docstrings.hpp +++ b/pykep/docstrings.hpp @@ -54,6 +54,12 @@ std::string f2h_v_doc(); std::string zeta2f_v_doc(); std::string f2zeta_v_doc(); +// Encodings +std::string alpha2direct_doc(); +std::string direct2alpha_doc(); +std::string eta2direct_doc(); +std::string direct2eta_doc(); + // Epoch std::string epoch_from_float_doc(); std::string epoch_from_datetime_doc(); diff --git a/pykep/test_utils.py b/pykep/test_utils.py index 862839f9..1f863813 100644 --- a/pykep/test_utils.py +++ b/pykep/test_utils.py @@ -23,15 +23,15 @@ def test_alpha_direct_conversion(self): import pykep as pk tofs = [12.34, 232.2, 23.45, 134.3] - alphas, T = pk.utils.direct2alpha(tofs) - tofs_from_alphas = pk.utils.alpha2direct(alphas, T) + alphas, T = pk.direct2alpha(tofs) + tofs_from_alphas = pk.alpha2direct(alphas, T) err = [a - b for a, b in zip(tofs, tofs_from_alphas)] err = np.linalg.norm(err) self.assertTrue(err < 1e-13) tofs = np.random.random((4,)) * 20 - alphas, T = pk.utils.direct2alpha(tofs) - tofs_from_alphas = pk.utils.alpha2direct(alphas, T) + alphas, T = pk.direct2alpha(tofs) + tofs_from_alphas = pk.alpha2direct(alphas, T) err = [a - b for a, b in zip(tofs, tofs_from_alphas)] err = np.linalg.norm(err) self.assertTrue(err < 1e-13) @@ -41,16 +41,16 @@ def test_eta_direct_conversion(self): tofs = [12.34, 232.2, 23.45, 134.3] tmax = 300 - etas = pk.utils.direct2eta(tofs, tmax) - tofs_from_etas = pk.utils.eta2direct(etas, tmax) + etas = pk.direct2eta(tofs, tmax) + tofs_from_etas = pk.eta2direct(etas, tmax) err = [a - b for a, b in zip(tofs, tofs_from_etas)] err = np.linalg.norm(err) self.assertTrue(err < 1e-13) tofs = np.random.random((4,)) * 100 tmax = 400 - etas = pk.utils.direct2eta(tofs, tmax) - tofs_from_etas = pk.utils.eta2direct(etas, tmax) + etas = pk.direct2eta(tofs, tmax) + tofs_from_etas = pk.eta2direct(etas, tmax) err = [a - b for a, b in zip(tofs, tofs_from_etas)] err = np.linalg.norm(err) self.assertTrue(err < 1e-13) diff --git a/pykep/trajopt/_mga.py b/pykep/trajopt/_mga.py index 760cfb5b..9100a20b 100644 --- a/pykep/trajopt/_mga.py +++ b/pykep/trajopt/_mga.py @@ -194,13 +194,13 @@ def get_bounds(self): def _decode_tofs(self, x: List[float]) -> List[float]: if self.tof_encoding == "alpha": # decision vector is [t0, T, a1, a2, ....] - return _pk.utils.alpha2direct(x[2:], x[1]) + return _pk.alpha2direct(x[2:], x[1]) elif self.tof_encoding == "direct": # decision vector is [t0, T1, T2, T3, ... ] return x[1:] elif self.tof_encoding == "eta": # decision vector is [t0, n1, n2, n3, ... ] - return _pk.utils.eta2direct(x[1:], self.tof) + return _pk.eta2direct(x[1:], self.tof) @staticmethod def alpha2direct(x): @@ -214,7 +214,7 @@ def alpha2direct(x): Returns: :class:`numpy.ndarray`: a chromosome encoding the MGA trajectory using the direct encoding """ - retval = _pk.utils.alpha2direct(x[2:], x[1]) + retval = _pk.alpha2direct(x[2:], x[1]) retval = _np.insert(retval, 0, x[0]) return retval @@ -228,7 +228,7 @@ def direct2alpha(x): Returns: :class:`numpy.ndarray`: a chromosome encoding the MGA trajectory using the alpha encoding """ - alphas, T = _pk.utils.direct2alpha(x[1:]) + alphas, T = _pk.direct2alpha(x[1:]) retval = _np.insert(alphas, 0, [x[0], T]) return retval @@ -269,7 +269,7 @@ def direct2eta(self, x): from copy import deepcopy retval = deepcopy(x) - retval[1:] = _pk.utils.direct2eta(x[1:], self.tof) + retval[1:] = _pk.direct2eta(x[1:], self.tof) return retval def _compute_dvs(self, x: List[float]) -> Tuple[ diff --git a/pykep/trajopt/_mga_1dsm.py b/pykep/trajopt/_mga_1dsm.py index 2fcc711a..75290a79 100644 --- a/pykep/trajopt/_mga_1dsm.py +++ b/pykep/trajopt/_mga_1dsm.py @@ -220,13 +220,13 @@ def _decode_times_and_vinf(self, x): # 1 - we decode the times of flight if self._tof_encoding == "alpha": # decision vector is [t0] + [u, v, Vinf, eta1, a1] + [beta, rp/rV, eta2, a2] + ... + [T] - retval_T = _pk.utils.alpha2direct(x[5::4], x[-1]) + retval_T = _pk.alpha2direct(x[5::4], x[-1]) elif self._tof_encoding == "direct": # decision vector is [t0] + [u, v, Vinf, eta1, T1] + [beta, rp/rV, eta2, T2] + ... retval_T = x[5::4] elif self._tof_encoding == "eta": # decision vector is [t0] + [u, v, Vinf, eta1, n1] + [beta, rp/rV, eta2, n2] + ... - retval_T = _pk.utils.eta2direct(x[5::4], self._tof) + retval_T = _pk.eta2direct(x[5::4], self._tof) # 2 - We decode the hyperbolic velocity at departure theta = 2 * pi * x[1] @@ -254,7 +254,7 @@ def alpha2direct(x): """ # decision vector is [t0] + [u, v, Vinf, eta1, a1] + [beta, rp/rV, eta2, a2] + ... + [T] retval = deepcopy(x) - retval[5::4] = _pk.utils.alpha2direct(x[5::4], x[-1]) + retval[5::4] = _pk.alpha2direct(x[5::4], x[-1]) retval = _np.delete(retval, -1) return retval @@ -270,7 +270,7 @@ def direct2alpha(x): """ # decision vector is [t0] + [u, v, Vinf, eta1, T1] + [beta, rp/rV, eta2, T2] + ... retval = deepcopy(x) - retval[5::4], T = _pk.utils.direct2alpha(x[5::4]) + retval[5::4], T = _pk.direct2alpha(x[5::4]) retval = _np.append(retval,T) return retval @@ -286,7 +286,7 @@ def eta2direct(x, max_tof): """ # decision vector is [t0] + [u, v, Vinf, eta1, n1] + [beta, rp/rV, eta2, n2] + ... retval = deepcopy(x) - retval[5::4] = _pk.utils.eta2direct(x[5::4], max_tof) + retval[5::4] = _pk.eta2direct(x[5::4], max_tof) return retval @staticmethod @@ -300,7 +300,7 @@ def direct2eta(x, max_tof): :class:`numpy.ndarray`: a chromosome encoding the MGA trajectory using the eta encoding """ retval = deepcopy(x) - retval[5::4] = _pk.utils.direct2eta(x[5::4], max_tof) + retval[5::4] = _pk.direct2eta(x[5::4], max_tof) return retval def _compute_dvs(self, x: List[float]) -> Tuple[ diff --git a/pykep/utils/__init__.py b/pykep/utils/__init__.py index b8a6ddd6..6c39ab2f 100644 --- a/pykep/utils/__init__.py +++ b/pykep/utils/__init__.py @@ -8,4 +8,4 @@ from ._planet_to_keplerian import planet_to_keplerian -from ._encoding_conversions import direct2alpha, alpha2direct, eta2direct, direct2eta, uvV2cartesian, cartesian2uvV \ No newline at end of file +from ._encoding_conversions import uvV2cartesian, cartesian2uvV \ No newline at end of file diff --git a/pykep/utils/_encoding_conversions.py b/pykep/utils/_encoding_conversions.py index ec695265..c19928d8 100644 --- a/pykep/utils/_encoding_conversions.py +++ b/pykep/utils/_encoding_conversions.py @@ -1,8 +1,8 @@ from copy import deepcopy as _deepcopy from math import log, exp, cos, acos, sin, pi, sqrt, atan2, asin -def alpha2direct(alphas, T): - """alpha2direct(x) +def alpha2direct_py(alphas, T): + """alpha2direct_py(x) Args: *alphas* (``array-like``): a sequence of transfer times encoded using the alpha encoding. @@ -17,7 +17,7 @@ def alpha2direct(alphas, T): return retval -def direct2alpha(x): +def direct2alpha_py(x): """direct2alpha(x) Args: @@ -31,7 +31,7 @@ def direct2alpha(x): return retval, T -def eta2direct(x, max_tof): +def eta2direct_py(x, max_tof): """eta2direct(x) Args: @@ -51,7 +51,7 @@ def eta2direct(x, max_tof): return T -def direct2eta(x, max_tof): +def direct2eta_py(x, max_tof): """direct2eta(x) Args: @@ -68,7 +68,6 @@ def direct2eta(x, max_tof): retval[i] = x[i] / (max_tof - sum(x[:i])) return retval - def uvV2cartesian(uvV): """This function converts the uvV encoding of a vector to cartesian coordinates diff --git a/src/core_astro/encodings.cpp b/src/core_astro/encodings.cpp new file mode 100644 index 00000000..43a73c5a --- /dev/null +++ b/src/core_astro/encodings.cpp @@ -0,0 +1,61 @@ +// Copyright 2023, 2024 Dario Izzo (dario.izzo@gmail.com), Francesco Biscani +// (bluescarni@gmail.com) +// +// This file is part of the kep3 library. +// +// 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 http://mozilla.org/MPL/2.0/. + +#include +#include +#include + +#include + +namespace kep3 +{ + +std::vector alpha2direct(const std::vector &alphas, double tof) +{ + std::vector log_alphas(alphas.size()); + std::transform(alphas.begin(), alphas.end(), log_alphas.begin(), [](double x) { return std::log(x); }); + double sum = std::accumulate(log_alphas.begin(), log_alphas.end(), 0.); + std::transform(log_alphas.begin(), log_alphas.end(), log_alphas.begin(), + [sum, tof](double x) { return x * tof / sum; }); + return log_alphas; +} + +std::pair, double> direct2alpha(const std::vector &tofs) +{ + std::vector retval(tofs.size()); + double T = std::accumulate(tofs.begin(), tofs.end(), 0.); + std::transform(tofs.begin(), tofs.end(), retval.begin(), [T](double x) { return std::exp(-x / T); }); + return {retval, T}; +} + +std::vector eta2direct(const std::vector &etas, double max_tof) +{ + std::vector tofs(etas.size(), 0.); + tofs[0] = max_tof * etas[0]; + double cumulative_T = tofs[0]; + for (decltype(etas.size()) i = 1u; i < etas.size(); ++i) { + tofs[i] = (max_tof - cumulative_T) * etas[i]; + cumulative_T += tofs[i]; + } + return tofs; +} + +std::vector direct2eta(const std::vector &tofs, double max_tof) +{ + auto retval = tofs; + retval[0] = tofs[0] / max_tof; + double cumulative_tofs = tofs[0]; + for (decltype(tofs.size()) i = 1u; i < tofs.size(); ++i) { + retval[i] = tofs[i] / (max_tof - cumulative_tofs); + cumulative_tofs += tofs[i]; + } + return retval; +} + +} // namespace kep3 \ No newline at end of file diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 14d3ed78..afb7c012 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -9,7 +9,6 @@ target_compile_options(kep3_test PRIVATE find_package(Pagmo REQUIRED) - function(ADD_kep3_TESTCASE arg1) add_executable(${arg1} ${arg1}.cpp) target_link_libraries(${arg1} PRIVATE kep3_test kep3 xtensor xtensor-blas Boost::boost Pagmo::pagmo) @@ -45,3 +44,5 @@ ADD_kep3_TESTCASE(leg_sims_flanagan_hf_test) ADD_kep3_TESTCASE(ta_stark_test) ADD_kep3_TESTCASE(ta_cr3bp_test) ADD_kep3_TESTCASE(flyby_test) +ADD_kep3_TESTCASE(encodings_test) + diff --git a/test/convert_anomalies_test.cpp b/test/convert_anomalies_test.cpp index 7cf3afcf..ca834f83 100644 --- a/test/convert_anomalies_test.cpp +++ b/test/convert_anomalies_test.cpp @@ -8,11 +8,9 @@ // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. #include -#include #include #include -#include #include "catch.hpp" diff --git a/test/encodings_test.cpp b/test/encodings_test.cpp new file mode 100644 index 00000000..65d8a307 --- /dev/null +++ b/test/encodings_test.cpp @@ -0,0 +1,21 @@ +// Copyright 2023, 2024 Dario Izzo (dario.izzo@gmail.com), Francesco Biscani +// (bluescarni@gmail.com) +// +// This file is part of the kep3 library. +// +// 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 http://mozilla.org/MPL/2.0/. + +#include + +#include "catch.hpp" + +TEST_CASE("encodings") +{ + // We only call these here: their correctness is tested in python + kep3::alpha2direct({0.1,0.2,0.3}, 21.2); + kep3::direct2alpha({0.1,0.2,0.3}); + kep3::eta2direct({0.1,0.2,0.3}, 21.2); + kep3::direct2eta({0.1,0.2,0.3}, 21.2); +} \ No newline at end of file From 4c42e31794a1b2a505c736b7d225b4f4542a6604 Mon Sep 17 00:00:00 2001 From: Dario Izzo Date: Tue, 28 Jan 2025 23:39:50 +0100 Subject: [PATCH 2/3] Primer Vector Method added to pl2pl --- doc/notebooks/primer_vector.ipynb | 68 ++++++++++++------ doc/notebooks/udp_pl2pl_N_impulses.ipynb | 91 +++++++++++++++++++----- pykep/trajopt/_pl2pl_N_impulses.py | 91 +++++++++++++++++++++++- 3 files changed, 210 insertions(+), 40 deletions(-) diff --git a/doc/notebooks/primer_vector.ipynb b/doc/notebooks/primer_vector.ipynb index ed979405..d18db47f 100644 --- a/doc/notebooks/primer_vector.ipynb +++ b/doc/notebooks/primer_vector.ipynb @@ -4,10 +4,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Revisiting the Primer Vector\n", + "# Primer Vector\n", "\n", "In this notebook we revisit the primer vector theory from Lawden from the lens of first order variations. We then construct manually, for a specific test case, the state transition matrices needed to call {func}`pykep.trajopt.primer_vector` and show\n", - "its use.\n", + "its use. The same plot can also be obtained, without having to go through the math intensive developments, using the {func}`pykep.trajopt.pl2pl_N_impulses.plot_primer_vector` method of the Multiple Impulse Transfer UDP `pykep.trajopt.pl2pl_N_impulses`\n", + "\n", + "Classically, the result of the primer vector is derived using Pontryagin maximum principle, here we present an original derivation building on the work from Bauregard et al. {cite:p}`beauregard`, which allows also to extend the primer vector to new, previously untreated, cases (see the notebook [A primer vector surrogate](<./primer_vector_surrogate.ipynb>)).\n", "\n", ":::{note}\n", " The developments are here shown in details as they can be extended to more generic cases that use different dynamics and number of impulses. The user must in that case provide the state ransition matrices and DVs on a time grid as constructed below.\n", @@ -136,9 +138,7 @@ "\n", " which is of fundamental importance in space flight mechanics and is called **primer vector**. \n", "\n", - " From the expression of $\\delta J$ it appears clear that if we want to be able to decrease the overall $\\Delta V$ adding in $k$ one impulse it is necessary for the norm of the primer vector (computed in $k$) to be larger than 1.\n", - "\n", - " Classically the result of the primer vector is derived starting from Pontryagin maximum principle, here we have presented an original derivation building on the work from Bauregard et al. {cite:p}`beauregard`, which allows to extend the primer vector to new, previously untreated, cases (see the notebook [A primer vector surrogate](<./primer_vector_surrogate.ipynb>))." + " From the expression of $\\delta J$ it appears clear that if we want to be able to decrease the overall $\\Delta V$ adding in $k$ one impulse it is necessary for the norm of the primer vector (computed in $k$) to be larger than 1." ] }, { @@ -242,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -272,7 +272,38 @@ "for item in retval2:\n", " stms.append(item[1] @ Mmn @ Mn0)\n", " posvels.append(item[0])\n", - "posvels[-1][1] = [a + b for a, b in zip(posvels[-1][1], DV3)]\n" + "#posvels[-1][1] = [a + b for a, b in zip(posvels[-1][1], DV3)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.12807793e+01, 1.80447033e+01, 6.65907703e-03,\n", + " -9.08505426e+07, 5.95064147e+07, 1.92133860e+06],\n", + " [-1.28990875e+00, -1.31576055e+00, -3.66387114e-02,\n", + " 1.15887081e+07, -5.09339048e+06, 2.07784246e+05],\n", + " [-3.36261520e-01, -3.88616536e-01, 6.55461044e-01,\n", + " 2.34553875e+06, -9.85626328e+05, 1.43519303e+06],\n", + " [ 3.35679528e-07, 8.01570626e-07, -1.32855560e-08,\n", + " -2.43465805e+00, 2.52926261e+00, 2.17349840e-01],\n", + " [ 3.32734693e-06, 5.70909432e-06, -6.71155865e-09,\n", + " -2.83015440e+01, 1.97666678e+01, 5.07564715e-01],\n", + " [ 2.55788135e-08, 2.62452949e-08, -1.13916259e-07,\n", + " -2.42108745e-01, 9.65279820e-02, 1.26130568e+00]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stms[-1]" ] }, { @@ -284,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -328,21 +359,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We are ready to vompute the primer vector." + "We are ready to compute the primer vector." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "res = []\n", "# The gridpoints where the impulses are applied have idxs: 0 (DV0), 103 (DV1), 153 (DV2), 175 (DV3)\n", "idx_i = 0\n", - "idx_j = 153\n", + "idx_j = 175\n", "DVi = DV0\n", - "DVj = DV2\n", + "DVj = DV3\n", "for idx_k, _ in enumerate(tgrid):\n", " Mji = stms[idx_j] @ np.linalg.inv(stms[idx_i])\n", " Mjk = stms[idx_j] @ np.linalg.inv(stms[idx_k])\n", @@ -358,22 +389,22 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -400,11 +431,6 @@ "Note also how at each impulse, except the starting and ending ones, the deriative of the primer vector magnitude flattens.\n", "The fact this is not the case at the starting and ending conditions, hints to the suboptimality of the transfer time (e.g. extrapolating the primer vecotr before and/or after the set grid, its magnitude would be larger than one!)." ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": { diff --git a/doc/notebooks/udp_pl2pl_N_impulses.ipynb b/doc/notebooks/udp_pl2pl_N_impulses.ipynb index f870fea4..f21b1423 100644 --- a/doc/notebooks/udp_pl2pl_N_impulses.ipynb +++ b/doc/notebooks/udp_pl2pl_N_impulses.ipynb @@ -76,7 +76,7 @@ "output_type": "stream", "text": [ "Multi-start:\n", - "19 5986.3894642652765\n", + "19 6312.5821298412195\n", "The best solution found has a DV of 5.98639e+00 km/s\n" ] } @@ -121,7 +121,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -177,10 +177,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total DV (m/s): 5986.389457982905\n", - "Dvs (m/s): [219.52008646422854, 2899.3365788308042, 2867.532792687872]\n", - "Total DV (m/s): 360.00000000000006\n", - "Tofs (days): [205.94359053771774, 154.05640946228232]\n" + "Total DV (m/s): 5986.389457396789\n", + "Dvs (m/s): [219.5201622093484, 2899.3388627999943, 2867.5304323874466]\n", + "Total DT (m/s): 360.0\n", + "Tofs (days): [205.9435135734575, 154.0564864265425]\n" ] } ], @@ -193,14 +193,40 @@ "metadata": {}, "source": [ "# Are more impulses needed?\n", - "In the previous design we allowed maximum 3 impulses, but would more impulse be needed? We can quickly answer this question for this speci\n", - "fic case by repeating the optimization allowing more impulses." + "In the previous design we allowed maximum 3 impulses, but would more impulse be needed? We can quickly answer this question for this specific case by looking at the primer vector." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (grid, p) = udp3.plot_primer_vector(best_x_3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... the primer vector goes above one this trajevtory IS NOT OPTIMAL. We need more impulses. Lets add one." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, "outputs": [], "source": [ "udp4 = pk.trajopt.pl2pl_N_impulses(\n", @@ -217,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -225,7 +251,7 @@ "output_type": "stream", "text": [ "Multi-start:\n", - "19 6306.174013339038\n", + "19 5986.389456287089\n", "The best solution found has a DV of 5.93793e+00 km/s\n" ] } @@ -236,12 +262,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -256,17 +282,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Total DV (m/s): 5937.927390874737\n", - "Dvs (m/s): [197.6511836438095, 2732.3481744646388, 231.03876966271096, 2776.8892631035783]\n", - "Total DV (m/s): 360.0\n", - "Tofs (days): [209.66471833695857, 102.5265381278393, 47.80874353520212]\n" + "Total DV (m/s): 5937.927390088956\n", + "Dvs (m/s): [197.65765144324607, 2732.3258592198454, 231.02221674962183, 2776.9216626762422]\n", + "Total DT (m/s): 360.0\n", + "Tofs (days): [209.66400763089803, 102.52543608353949, 47.810556285562484]\n" ] } ], @@ -280,7 +306,36 @@ "source": [ "We found a better solution! Four impulses are better than 4 in this case! This is quite rare and interesting as a case and its here found as the optimization problem was defined to have a fixed duration and starting date. Typically, when freeing these degrees of freedom, three impulses are enough.\n", "\n", - "Try to find other interesting cases where the number of impulses matter, and do not be fooled by artefacts. Some times impulses with zero $\\Delta V$ are added to move around the starting date outside of the bounds. Whats the maximum number of impulses you can find to be optimal?" + "Try to find other interesting cases where the number of impulses matter, and do not be fooled by artefacts. Some times impulses with zero $\\Delta V$ are added to move around the starting date outside of the bounds. Whats the maximum number of impulses you can find to be optimal?\n", + "\n", + "We conclude showing the primer vector for this case:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (grid, p) = udp4.plot_primer_vector(best_x_4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The very same trajectory is also studied in [the notebook dedicated to the primer vector](<./primer_vector.ipynb>) where the whole theory is also developed and coded as to show its inner workings." ] } ], diff --git a/pykep/trajopt/_pl2pl_N_impulses.py b/pykep/trajopt/_pl2pl_N_impulses.py index 84af9644..5eed0f09 100644 --- a/pykep/trajopt/_pl2pl_N_impulses.py +++ b/pykep/trajopt/_pl2pl_N_impulses.py @@ -1,5 +1,6 @@ import pykep as _pk import numpy as _np +import matplotlib.pyplot as _plt from math import pi, cos, sin, log, acos, sqrt @@ -129,7 +130,7 @@ def decode(self, x): """ retval = [] # 1 We decode the tofs - T = _pk.utils.alpha2direct(x[2::4], x[1]) + T = _pk.alpha2direct(x[2::4], x[1]) # 2 - We compute the starting and ending position r_start, v_start = self.start.eph(_pk.epoch(x[0])) @@ -268,3 +269,91 @@ def pretty(self, x): print( "Tofs (days): ", [float(it) for it in T[:-1]] ) # last node has a zero TOF by convention + + def plot_primer_vector(self, x, N=200, ax=None): + """Plots the primer vector magnitude along the trajectory encoded in *x*. + + Args: + *x* (:class:`list`): The decision vector in the correct tof encoding. + + *N* (:class:`int`, optional): The number of points to use when plotting the primer vector. Defaults to 200. + + *ax* (:class:`matplotlib.axes.Axes`, optional): The axis to plot on. Defaults to None. + + Returns: + :class:`matplotlib.axes.Axes`: The axis where the primer vector was plotted. + :class:`tuple`: A tuple containing the grid and the primer vector magnitude. + """ + # We start by decoding the chromosome into the structure [[r,v], DV, DT] + decoded = self.decode(x) + + # We explicitly extract the encoded information + dts = [it[2] * _pk.DAY2SEC for it in decoded] + DVs = [it[1] for it in decoded] + posvels = [it[0] for it in decoded] + + # We create one grid er segment (e.g. part of the trajectory between two impulses) + # (this is not guaranteed to have the requested size N, nor has uniform spacing, since all impulses + # must belong to the grid points) + N = N + len(DVs) # heuristic to make sure we are close to the requested number of points + tgrids = [ + _np.linspace( + sum(dts[:i]), + sum(dts[: i + 1]), + max(int(dts[i] // (sum(dts) / (N - 1))), 5), # we force a minimum 5 points per segment + ) + for i in range(len(dts) - 1) + ] + # We assemble all the grids into one single final_grid + final_grid = _np.array([0]) + for i in range(len(dts) - 1): + final_grid = _np.concatenate((final_grid, tgrids[i][1:])) + + # These are the indices of the final_grid where the impulses are given. + idxs = [0] + [len(tgrids[0]) - 1] + for grid in tgrids[1:]: + idxs += [idxs[-1] + len(grid) - 1] + + # We now compute the various STMs. + retvals = [] + for posvel, DV, tgrid in zip(posvels, DVs, tgrids): + ic = [posvel[0], [a + b for a, b in zip(posvel[1], DV)]] + retvals.append( + _pk.propagate_lagrangian_grid(ic, tgrid, mu=_pk.MU_SUN, stm=True) + ) + + # And now assemble them in correspondance to the final_grid and in the Mn0 form. + posvels = [item[0] for item in retvals[0]] + stms = [item[1] for item in retvals[0]] + + M = stms[-1] + for retval in retvals[1:]: + posvels = posvels + [item[0] for item in retval[1:]] + stms = stms + [item[1] @ M for item in retval[1:]] + M = stms[-1] + + res = [] + # When computing the primer vector we must choose which impulses to use. + # We choose the first and last impulse. But we could choose any pair of impulses, + # and if the trajectory is optimal (locally) the primer vector would not change. + idx_i = idxs[0] + idx_j = idxs[-1] + DVi = DVs[0] + DVj = DVs[-1] + for idx_k, _ in enumerate(final_grid): + Mji = stms[idx_j] @ _np.linalg.inv(stms[idx_i]) + Mjk = stms[idx_j] @ _np.linalg.inv(stms[idx_k]) + res.append( + _np.linalg.norm(_pk.trajopt.primer_vector(DVi, DVj, Mji, Mjk)[0]) + ) + + if ax is None: + ax = _plt.figure().add_subplot() + ax.plot(res, label="primer vector magnitude") + ax.vlines(0, 0.8, 1.2, "k", linestyles="dashed", label="impulse") + for idx in idxs: + ax.vlines(idx, 0.8, 1.2, "k", linestyles="dashed") + + ax.hlines(1, 0, len(final_grid), "r") + ax.legend(loc="lower right") + return ax, (final_grid, res) From 4ea8e5787b61967d699d41fdede77d166e87ab1c Mon Sep 17 00:00:00 2001 From: Dario Izzo Date: Wed, 29 Jan 2025 10:58:53 +0100 Subject: [PATCH 3/3] forgotten header --- src/core_astro/encodings.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/core_astro/encodings.cpp b/src/core_astro/encodings.cpp index 43a73c5a..ee79ce5b 100644 --- a/src/core_astro/encodings.cpp +++ b/src/core_astro/encodings.cpp @@ -8,6 +8,7 @@ // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. #include +#include #include #include