diff --git a/tudatpy/CMakeLists.txt b/tudatpy/CMakeLists.txt index 2fd05878..2693ce38 100644 --- a/tudatpy/CMakeLists.txt +++ b/tudatpy/CMakeLists.txt @@ -171,22 +171,46 @@ INSTALL_PURE_PYTHON_MODULE_DIR(bodies) INSTALL_PURE_PYTHON_MODULE_DIR(plotting) INSTALL_PURE_PYTHON_MODULE_DIR(util) INSTALL_PURE_PYTHON_MODULE_DIR(io) + +# Create hybrid C++/Python modules +macro(CREATE_HYBRID_CPP_PYTHON_MODULE module_dir_name) + install(DIRECTORY kernel_hybrid/${module_dir_name}/ DESTINATION "${TUDATPY_INSTALL_PATH}/${module_dir_name}") + file(COPY kernel_hybrid/${module_dir_name}/ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${module_dir_name}/) +endmacro() +# CREATE_HYBRID_CPP_PYTHON_MODULE(utils) +CREATE_HYBRID_CPP_PYTHON_MODULE(astro) +CREATE_HYBRID_CPP_PYTHON_MODULE(trajectory_design) +CREATE_HYBRID_CPP_PYTHON_MODULE(constants) +CREATE_HYBRID_CPP_PYTHON_MODULE(interface) +# CREATE_HYBRID_CPP_PYTHON_MODULE(io) +CREATE_HYBRID_CPP_PYTHON_MODULE(math) +CREATE_HYBRID_CPP_PYTHON_MODULE(numerical_simulation) + +# TODO: Automatic exposure of hybrid C++/Python modules +# This involves solving the dependencies which conda +# uses for the builds. The tudat-feedstock contains the +# recipes used to build tudatpy. +# To build tudatpy, conda creates first machine images +# in which to run the build: +# - Linux (Docker) +# - OSX +# - Windows +# When attempting to build tudatpy using the automatic +# kernel exposure below, the build processes fail with a +# `module not found: numpy` error. # -## Install the Python components of kernel modules -#macro(INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE module_dir_name) -# install(DIRECTORY kernel_hybrid/${module_dir_name}/ DESTINATION "${TUDATPY_INSTALL_PATH}/${module_dir_name}") -# file(COPY kernel_hybrid/${module_dir_name}/ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${module_dir_name}/) -#endmacro() -## INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(utils) -##INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(astro) -#INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(trajectory_design) -##INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(constants) -##INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(interface) -## INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(io) -##INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(math) -##INSTALL_PYTHON_COMPONENTS_OF_HYBRID_MODULE(numerical_simulation) +# The cause of this error is that the python interpreter +# called here (PYTHON_EXECUTABLE) is badly configured. +# This means somewhere along the build +# +# SOLUTIONS ATTEMPTED +# - build.sh +# - FAILED: Adding conda install statement before make # -## Expose hybrid C++/Python modules +# POSSIBLE SOLUTIONS: +# - meta.yaml +# - `requirements` may not be correctly set up +# ----------------------------------------------------- #file(COPY ${CMAKE_CURRENT_LIST_DIR}/setup_hybrid_modules.py DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/../) #macro(EXPOSE_HYBRID_MODULES) # foreach(module ${ARGN}) diff --git a/tudatpy/__init__.py b/tudatpy/__init__.py index 7d6e9a1d..00da3eac 100644 --- a/tudatpy/__init__.py +++ b/tudatpy/__init__.py @@ -1,4 +1,4 @@ -from ._version import * +from tudatpy._version import * from tudatpy.kernel import constants from tudatpy.kernel import astro from tudatpy.kernel import interface diff --git a/tudatpy/kernel_hybrid/astro/__init__.py b/tudatpy/kernel_hybrid/astro/__init__.py new file mode 100644 index 00000000..92f44942 --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro` kernel module directly from tudatpy: +# +# from tudatpy.astro import +# +# Without the statement below, importing the `astro` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/astro/element_conversion/__init__.py b/tudatpy/kernel_hybrid/astro/element_conversion/__init__.py new file mode 100644 index 00000000..3cb71293 --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/element_conversion/__init__.py @@ -0,0 +1,28 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro.element_conversion` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro/element_conversion`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro.element_conversion` kernel module directly from tudatpy: +# +# from tudatpy.astro.element_conversion import +# +# Without the statement below, importing the `astro.element_conversion` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro.element_conversion import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro.element_conversion import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/astro/frame_conversion/__init__.py b/tudatpy/kernel_hybrid/astro/frame_conversion/__init__.py new file mode 100644 index 00000000..b5166451 --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/frame_conversion/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro.frame_conversion` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro/frame_conversion`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro.frame_conversion` kernel module directly from tudatpy: +# +# from tudatpy.astro.frame_conversion import +# +# Without the statement below, importing the `astro.frame_conversion` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro.frame_conversion import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro.frame_conversion import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/astro/fundamentals/__init__.py b/tudatpy/kernel_hybrid/astro/fundamentals/__init__.py new file mode 100644 index 00000000..7f654e77 --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/fundamentals/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro.fundamentals` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro/fundamentals`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro.fundamentals` kernel module directly from tudatpy: +# +# from tudatpy.astro.fundamentals import +# +# Without the statement below, importing the `astro.fundamentals` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro.fundamentals import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro.fundamentals import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/astro/gravitation/__init__.py b/tudatpy/kernel_hybrid/astro/gravitation/__init__.py new file mode 100644 index 00000000..4dfc509a --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/gravitation/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro.gravitation` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro/gravitation`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro.gravitation` kernel module directly from tudatpy: +# +# from tudatpy.astro.gravitation import +# +# Without the statement below, importing the `astro.gravitation` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro.gravitation import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro.gravitation import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/astro/polyhedron_utilities/__init__.py b/tudatpy/kernel_hybrid/astro/polyhedron_utilities/__init__.py new file mode 100644 index 00000000..86ad1154 --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/polyhedron_utilities/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro.polyhedron_utilities` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro/polyhedron_utilities`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro.polyhedron_utilities` kernel module directly from tudatpy: +# +# from tudatpy.astro.polyhedron_utilities import +# +# Without the statement below, importing the `astro.polyhedron_utilities` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro.polyhedron_utilities import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro.polyhedron_utilities import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/astro/time_conversion/__init__.py b/tudatpy/kernel_hybrid/astro/time_conversion/__init__.py new file mode 100644 index 00000000..d20fb29a --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/time_conversion/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro.time_conversion` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro/time_conversion`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro.time_conversion` kernel module directly from tudatpy: +# +# from tudatpy.astro.time_conversion import +# +# Without the statement below, importing the `astro.time_conversion` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro.time_conversion import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro.time_conversion import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/astro/two_body_dynamics/__init__.py b/tudatpy/kernel_hybrid/astro/two_body_dynamics/__init__.py new file mode 100644 index 00000000..1c9f2446 --- /dev/null +++ b/tudatpy/kernel_hybrid/astro/two_body_dynamics/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.astro.two_body_dynamics` with +# its Python extensions defined in `tudatpy/kernel_hybrid/astro/two_body_dynamics`. +# +# This allows the import of all the C++ and Python submodules of the +# `astro.two_body_dynamics` kernel module directly from tudatpy: +# +# from tudatpy.astro.two_body_dynamics import +# +# Without the statement below, importing the `astro.two_body_dynamics` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.astro.two_body_dynamics import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.astro.two_body_dynamics import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/constants/__init__.py b/tudatpy/kernel_hybrid/constants/__init__.py new file mode 100644 index 00000000..6c1d09fa --- /dev/null +++ b/tudatpy/kernel_hybrid/constants/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.constants` with +# its Python extensions defined in `tudatpy/kernel_hybrid/constants`. +# +# This allows the import of all the C++ and Python submodules of the +# `constants` kernel module directly from tudatpy: +# +# from tudatpy.constants import +# +# Without the statement below, importing the `constants` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.constants import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.constants import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/interface/__init__.py b/tudatpy/kernel_hybrid/interface/__init__.py new file mode 100644 index 00000000..9a14703f --- /dev/null +++ b/tudatpy/kernel_hybrid/interface/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.interface` with +# its Python extensions defined in `tudatpy/kernel_hybrid/interface`. +# +# This allows the import of all the C++ and Python submodules of the +# `interface` kernel module directly from tudatpy: +# +# from tudatpy.interface import +# +# Without the statement below, importing the `interface` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.interface import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.interface import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/interface/spice/__init__.py b/tudatpy/kernel_hybrid/interface/spice/__init__.py new file mode 100644 index 00000000..dc969c89 --- /dev/null +++ b/tudatpy/kernel_hybrid/interface/spice/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.interface.spice` with +# its Python extensions defined in `tudatpy/kernel_hybrid/interface/spice`. +# +# This allows the import of all the C++ and Python submodules of the +# `interface.spice` kernel module directly from tudatpy: +# +# from tudatpy.interface.spice import +# +# Without the statement below, importing the `interface.spice` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.interface.spice import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.interface.spice import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/math/__init__.py b/tudatpy/kernel_hybrid/math/__init__.py new file mode 100644 index 00000000..4921da8b --- /dev/null +++ b/tudatpy/kernel_hybrid/math/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.math` with +# its Python extensions defined in `tudatpy/kernel_hybrid/math`. +# +# This allows the import of all the C++ and Python submodules of the +# `math` kernel module directly from tudatpy: +# +# from tudatpy.math import +# +# Without the statement below, importing the `math` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.math import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.math import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/math/geometry/__init__.py b/tudatpy/kernel_hybrid/math/geometry/__init__.py new file mode 100644 index 00000000..1f897e7e --- /dev/null +++ b/tudatpy/kernel_hybrid/math/geometry/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.math.geometry` with +# its Python extensions defined in `tudatpy/kernel_hybrid/math/geometry`. +# +# This allows the import of all the C++ and Python submodules of the +# `math.geometry` kernel module directly from tudatpy: +# +# from tudatpy.math.geometry import +# +# Without the statement below, importing the `math.geometry` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.math.geometry import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.math.geometry import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/math/interpolators/__init__.py b/tudatpy/kernel_hybrid/math/interpolators/__init__.py new file mode 100644 index 00000000..788ba083 --- /dev/null +++ b/tudatpy/kernel_hybrid/math/interpolators/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.math.interpolators` with +# its Python extensions defined in `tudatpy/kernel_hybrid/math/interpolators`. +# +# This allows the import of all the C++ and Python submodules of the +# `math.interpolators` kernel module directly from tudatpy: +# +# from tudatpy.math.interpolators import +# +# Without the statement below, importing the `math.interpolators` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.math.interpolators import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.math.interpolators import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/math/numerical_integrators/__init__.py b/tudatpy/kernel_hybrid/math/numerical_integrators/__init__.py new file mode 100644 index 00000000..546e04a2 --- /dev/null +++ b/tudatpy/kernel_hybrid/math/numerical_integrators/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.math.numerical_integrators` with +# its Python extensions defined in `tudatpy/kernel_hybrid/math/numerical_integrators`. +# +# This allows the import of all the C++ and Python submodules of the +# `math.numerical_integrators` kernel module directly from tudatpy: +# +# from tudatpy.math.numerical_integrators import +# +# Without the statement below, importing the `math.numerical_integrators` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.math.numerical_integrators import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.math.numerical_integrators import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/math/root_finders/__init__.py b/tudatpy/kernel_hybrid/math/root_finders/__init__.py new file mode 100644 index 00000000..3aae2afa --- /dev/null +++ b/tudatpy/kernel_hybrid/math/root_finders/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.math.root_finders` with +# its Python extensions defined in `tudatpy/kernel_hybrid/math/root_finders`. +# +# This allows the import of all the C++ and Python submodules of the +# `math.root_finders` kernel module directly from tudatpy: +# +# from tudatpy.math.root_finders import +# +# Without the statement below, importing the `math.root_finders` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.math.root_finders import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.math.root_finders import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/__init__.py new file mode 100644 index 00000000..7c2b0464 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation import +# +# Without the statement below, importing the `numerical_simulation` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment/__init__.py new file mode 100644 index 00000000..0744eee7 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment import +# +# Without the statement below, importing the `numerical_simulation.environment` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/__init__.py new file mode 100644 index 00000000..e25354fd --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup import +# +# Without the statement below, importing the `numerical_simulation.environment_setup` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/aerodynamic_coefficients/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/aerodynamic_coefficients/__init__.py new file mode 100644 index 00000000..2983b7f1 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/aerodynamic_coefficients/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.aerodynamic_coefficients` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/aerodynamic_coefficients`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.aerodynamic_coefficients` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.aerodynamic_coefficients import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.aerodynamic_coefficients` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.aerodynamic_coefficients import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.aerodynamic_coefficients import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/atmosphere/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/atmosphere/__init__.py new file mode 100644 index 00000000..76d8f635 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/atmosphere/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.atmosphere` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/atmosphere`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.atmosphere` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.atmosphere import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.atmosphere` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.atmosphere import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.atmosphere import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ephemeris/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ephemeris/__init__.py new file mode 100644 index 00000000..aaf8abd2 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ephemeris/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.ephemeris` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ephemeris`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.ephemeris` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.ephemeris import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.ephemeris` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.ephemeris import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.ephemeris import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field/__init__.py new file mode 100644 index 00000000..518679bf --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.gravity_field` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.gravity_field` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.gravity_field import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.gravity_field` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.gravity_field import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.gravity_field import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field_variation/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field_variation/__init__.py new file mode 100644 index 00000000..8d3e13c1 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field_variation/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/gravity_field_variation`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.gravity_field_variation` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.gravity_field_variation import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.gravity_field_variation` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ground_station/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ground_station/__init__.py new file mode 100644 index 00000000..8ec230d3 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ground_station/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.ground_station` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/ground_station`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.ground_station` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.ground_station import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.ground_station` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.ground_station import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.ground_station import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/radiation_pressure/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/radiation_pressure/__init__.py new file mode 100644 index 00000000..3c8971e8 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/radiation_pressure/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.radiation_pressure` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/radiation_pressure`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.radiation_pressure` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.radiation_pressure import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.radiation_pressure` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.radiation_pressure import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.radiation_pressure import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rigid_body/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rigid_body/__init__.py new file mode 100644 index 00000000..6cc64142 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rigid_body/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.rigid_body` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rigid_body`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.rigid_body` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.rigid_body import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.rigid_body` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.rigid_body import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.rigid_body import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rotation_model/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rotation_model/__init__.py new file mode 100644 index 00000000..2e7c45a8 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rotation_model/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.rotation_model` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/rotation_model`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.rotation_model` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.rotation_model import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.rotation_model` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.rotation_model import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.rotation_model import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape/__init__.py new file mode 100644 index 00000000..4f9d4507 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.shape` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.shape` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.shape import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.shape` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.shape import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.shape import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape_deformation/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape_deformation/__init__.py new file mode 100644 index 00000000..ef216f80 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape_deformation/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.environment_setup.shape_deformation` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/environment_setup/shape_deformation`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.environment_setup.shape_deformation` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.environment_setup.shape_deformation import +# +# Without the statement below, importing the `numerical_simulation.environment_setup.shape_deformation` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.environment_setup.shape_deformation import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.environment_setup.shape_deformation import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/estimation/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/estimation/__init__.py new file mode 100644 index 00000000..a3801175 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/estimation/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.estimation` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/estimation`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.estimation` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.estimation import +# +# Without the statement below, importing the `numerical_simulation.estimation` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.estimation import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.estimation import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/__init__.py new file mode 100644 index 00000000..d4fea2de --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.estimation_setup` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/estimation_setup`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.estimation_setup` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.estimation_setup import +# +# Without the statement below, importing the `numerical_simulation.estimation_setup` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.estimation_setup import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.estimation_setup import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/observation/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/observation/__init__.py new file mode 100644 index 00000000..0520d286 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/observation/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.estimation_setup.observation` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/observation`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.estimation_setup.observation` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.estimation_setup.observation import +# +# Without the statement below, importing the `numerical_simulation.estimation_setup.observation` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.estimation_setup.observation import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.estimation_setup.observation import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/parameter/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/parameter/__init__.py new file mode 100644 index 00000000..382c0d52 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/parameter/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.estimation_setup.parameter` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/estimation_setup/parameter`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.estimation_setup.parameter` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.estimation_setup.parameter import +# +# Without the statement below, importing the `numerical_simulation.estimation_setup.parameter` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.estimation_setup.parameter import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.estimation_setup.parameter import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation/__init__.py new file mode 100644 index 00000000..e0fd2dff --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation import +# +# Without the statement below, importing the `numerical_simulation.propagation` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/__init__.py new file mode 100644 index 00000000..597c34a4 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/acceleration/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/acceleration/__init__.py new file mode 100644 index 00000000..1dffbd1d --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/acceleration/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup.acceleration` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/acceleration`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup.acceleration` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup.acceleration import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup.acceleration` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup.acceleration import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup.acceleration import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/dependent_variable/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/dependent_variable/__init__.py new file mode 100644 index 00000000..28a76cc1 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/dependent_variable/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup.dependent_variable` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/dependent_variable`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup.dependent_variable` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup.dependent_variable import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup.dependent_variable` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup.dependent_variable import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup.dependent_variable import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/integrator/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/integrator/__init__.py new file mode 100644 index 00000000..5cec8cc7 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/integrator/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup.integrator` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/integrator`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup.integrator` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup.integrator import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup.integrator` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup.integrator import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup.integrator import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/mass_rate/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/mass_rate/__init__.py new file mode 100644 index 00000000..83921e90 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/mass_rate/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup.mass_rate` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/mass_rate`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup.mass_rate` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup.mass_rate import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup.mass_rate` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup.mass_rate import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup.mass_rate import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/propagator/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/propagator/__init__.py new file mode 100644 index 00000000..e23d2aa8 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/propagator/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup.propagator` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/propagator`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup.propagator` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup.propagator import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup.propagator` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup.propagator import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup.propagator import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/thrust/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/thrust/__init__.py new file mode 100644 index 00000000..bedc563c --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/thrust/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup.thrust` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/thrust`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup.thrust` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup.thrust import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup.thrust` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup.thrust import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup.thrust import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/torque/__init__.py b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/torque/__init__.py new file mode 100644 index 00000000..8b87aba1 --- /dev/null +++ b/tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/torque/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.numerical_simulation.propagation_setup.torque` with +# its Python extensions defined in `tudatpy/kernel_hybrid/numerical_simulation/propagation_setup/torque`. +# +# This allows the import of all the C++ and Python submodules of the +# `numerical_simulation.propagation_setup.torque` kernel module directly from tudatpy: +# +# from tudatpy.numerical_simulation.propagation_setup.torque import +# +# Without the statement below, importing the `numerical_simulation.propagation_setup.torque` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.numerical_simulation.propagation_setup.torque import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.numerical_simulation.propagation_setup.torque import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/trajectory_design/__init__.py b/tudatpy/kernel_hybrid/trajectory_design/__init__.py new file mode 100644 index 00000000..32426bb7 --- /dev/null +++ b/tudatpy/kernel_hybrid/trajectory_design/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.trajectory_design` with +# its Python extensions defined in `tudatpy/kernel_hybrid/trajectory_design`. +# +# This allows the import of all the C++ and Python submodules of the +# `trajectory_design` kernel module directly from tudatpy: +# +# from tudatpy.trajectory_design import +# +# Without the statement below, importing the `trajectory_design` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.trajectory_design import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.trajectory_design import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/trajectory_design/shape_based_thrust/__init__.py b/tudatpy/kernel_hybrid/trajectory_design/shape_based_thrust/__init__.py new file mode 100644 index 00000000..99ab52fa --- /dev/null +++ b/tudatpy/kernel_hybrid/trajectory_design/shape_based_thrust/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.trajectory_design.shape_based_thrust` with +# its Python extensions defined in `tudatpy/kernel_hybrid/trajectory_design/shape_based_thrust`. +# +# This allows the import of all the C++ and Python submodules of the +# `trajectory_design.shape_based_thrust` kernel module directly from tudatpy: +# +# from tudatpy.trajectory_design.shape_based_thrust import +# +# Without the statement below, importing the `trajectory_design.shape_based_thrust` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.trajectory_design.shape_based_thrust import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.trajectory_design.shape_based_thrust import * \ No newline at end of file diff --git a/tudatpy/kernel_hybrid/trajectory_design/transfer_trajectory/__init__.py b/tudatpy/kernel_hybrid/trajectory_design/transfer_trajectory/__init__.py new file mode 100644 index 00000000..8add2b8d --- /dev/null +++ b/tudatpy/kernel_hybrid/trajectory_design/transfer_trajectory/__init__.py @@ -0,0 +1,32 @@ +# This file, by virtue of the import statement below, merges +# the Tudat kernel module `tudatpy.kernel.trajectory_design.transfer_trajectory` with +# its Python extensions defined in `tudatpy/kernel_hybrid/trajectory_design/transfer_trajectory`. +# +# This allows the import of all the C++ and Python submodules of the +# `trajectory_design.transfer_trajectory` kernel module directly from tudatpy: +# +# from tudatpy.trajectory_design.transfer_trajectory import +# +# Without the statement below, importing the `trajectory_design.transfer_trajectory` kernel module +# would only be possible as follows, and hybrid Python/C++ modules would not +# be posible in tudatpy. +# +# from tudatpy.kernel.trajectory_design.transfer_trajectory import +# +# The reason why C++ kernel modules can only be imported as written above +# is an issue with the `def_submodule` function of pybind11. The issue is discussed +# [here](https://github.com/pybind/pybind11/issues/2639). +# +# We circumvent the issue by automatically creating an *empty* Python module for each +# kernel module and submodule, and exposing the kernel module or submodule from the +# Python module by adding the import statement below to the Python module's `__init__.py` (this file). +# This workaround was proposed in [this comment](https://github.com/pybind/pybind11/issues/2639#issuecomment-721238757). +# +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside the newly created Python +# module (at the same level as this file), which is not possible with the `def_submodule` +# function of pybind11. +# An added benefit of this method is that it makes it possible to write Python extensions +# and add them to the kernel modules simply by placing them inside this module! + +from tudatpy.kernel.trajectory_design.transfer_trajectory import * \ No newline at end of file