{ "cells": [ { "cell_type": "markdown", "id": "96e8172d-4502-44af-93e0-14d5905e9a09", "metadata": {}, "source": [ "# JUICE Flybys of Jovian Moons\n", "## Objectives\n", " \n", "This examples shows how to use **TUDAT functionalities** to:\n", "1) retrieve **JUICE's position with respect to a given flyby moon** from their SPICE ephemerides, at a given time;\n", "2) propagate from the **midpoint of an arc** (both backwards and forwards);\n", "3) propagate using a **variable time step**\n" ] }, { "cell_type": "markdown", "id": "9f1f7eae-367d-404c-972e-33e37c4d43d9", "metadata": {}, "source": [ "## Import Statements\n", "To start off, we import all the relevant modules." ] }, { "cell_type": "code", "id": "dab16a0f-ac15-4c01-8188-fb055a53538c", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:42:49.878961Z", "iopub.status.busy": "2025-09-16T07:42:49.878868Z", "iopub.status.idle": "2025-09-16T07:42:50.267717Z", "shell.execute_reply": "2025-09-16T07:42:50.267345Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:34.738732Z", "start_time": "2025-09-17T09:55:34.190997Z" } }, "source": [ "import sys\n", "# Load required standard modules\n", "import os\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", "\n", "# Load required tudatpy modules\n", "from tudatpy import constants\n", "from tudatpy.interface import spice\n", "from tudatpy import dynamics\n", "from tudatpy.dynamics import environment, environment_setup\n", "from tudatpy.dynamics import propagation, propagation_setup, simulator\n", "from tudatpy.astro.time_representation import DateTime\n", "from tudatpy.astro import element_conversion\n", "from tudatpy.util import result2array" ], "outputs": [], "execution_count": 1 }, { "cell_type": "markdown", "id": "b3bdcb5c-427a-459b-80a8-7cb79e60118a", "metadata": {}, "source": [ "# Auxiliary Functions\n", "We define **two auxiliary functions** to be used throughout the code:\n", "1) `get_juice_position_wrt_moon`\n", "\n", " This function takes a time instant as input, and gives the **cartesian position of JUICE (body -28) with respect to the flyby moon**, in the J2000 reference frame as output. It is just a call to the [`spice.get_body_cartesian_position_at_epoch`](https://py.api.tudat.space/en/latest/spice.html#tudatpy.interface.spice.get_body_cartesian_position_at_epoch). \n", "\n", "3) `find_closest_approaches`\n", "This function takes as inputs:\n", "\n", "\n", "- lower time bound\n", "- upper time bound\n", "- closest distance threshold\n", "\n", "and it **returns a list of times of closest approaches** occurring within the specified time bounds. Only events where the closest distance is lower or equal than the closest distance threshold are stored in the list.\n", "\n", "The **closest approaches** are found iteratively, evaluating the **derivative (and more specifically, its sign) of JUICE's position relative to the flyby moon**: whenever a **minimum of the relative position** is found, a possible closest approach time is **checked against the distance threshold**." ] }, { "cell_type": "code", "id": "0d7fad25-ada0-4d65-8e3d-651ff6386825", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:42:50.269130Z", "iopub.status.busy": "2025-09-16T07:42:50.268968Z", "iopub.status.idle": "2025-09-16T07:42:50.274103Z", "shell.execute_reply": "2025-09-16T07:42:50.273810Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:34.752048Z", "start_time": "2025-09-17T09:55:34.744622Z" } }, "source": [ "# Function retrieving JUICE's position wrt the flyby moon from their SPICE ephemerides, at a given time.\n", "def get_juice_position_wrt_moon(time):\n", " return spice.get_body_cartesian_position_at_epoch(\n", " \"-28\", flyby_moon, \"J2000\", aberration_corrections=\"none\", ephemeris_time=time)\n", "\n", "# Function identifying JUICE's closest approaches wrt the flyby moon occurring within the specified time bounds, based on their SPICE trajectories.\n", "# Only events where the closest distance meets the threshold are selected.\n", "\n", "def find_closest_approaches(lower_time_bound, upper_time_bound, threshold):\n", " \n", " flyby_times = [] #initialize list of closest approach events\n", "\n", " tolerance = 1.0 \n", " step = 100.0\n", "\n", " lower_time = lower_time_bound\n", " mid_time = lower_time_bound + step\n", " upper_time = lower_time_bound + 2.0 * step\n", "\n", " while upper_time <= upper_time_bound:\n", " upper_value = np.linalg.norm(get_juice_position_wrt_moon(upper_time)) \n", " mid_value = np.linalg.norm(get_juice_position_wrt_moon(mid_time))\n", " lower_value = np.linalg.norm(get_juice_position_wrt_moon(lower_time))\n", "\n", " if (upper_value - mid_value) > 0 and (mid_value - lower_value) < 0:\n", "\n", " current_lower_time = lower_time\n", " current_upper_time = upper_time\n", " current_mid_time = (current_lower_time + current_upper_time) / 2.0\n", " current_test_time = current_mid_time\n", " counter = 0\n", "\n", " while np.abs(current_mid_time - current_test_time) > tolerance:\n", "\n", " current_test_time = current_mid_time\n", "\n", " current_lower_distance = np.linalg.norm(get_juice_position_wrt_moon(current_lower_time))\n", " current_upper_distance = np.linalg.norm(get_juice_position_wrt_moon(current_upper_time))\n", " current_test_distance = np.linalg.norm(get_juice_position_wrt_moon(current_test_time))\n", "\n", " sign_upper_derivative = np.sign((current_upper_distance - np.linalg.norm(\n", " get_juice_position_wrt_moon(current_upper_time - tolerance))) / tolerance)\n", " sign_lower_derivative = np.sign((current_lower_distance - np.linalg.norm(\n", " get_juice_position_wrt_moon(current_lower_time - tolerance))) / tolerance)\n", " sign_test_derivative = np.sign((current_test_distance - np.linalg.norm(\n", " get_juice_position_wrt_moon(current_test_time - tolerance))) / tolerance)\n", "\n", " if sign_upper_derivative > 0 and sign_test_derivative < 0:\n", " current_mid_time = (current_upper_time + current_test_time) / 2.0\n", " current_lower_time = current_test_time\n", " elif sign_lower_derivative < 0 and sign_test_derivative > 0:\n", " current_mid_time = (current_test_time + current_lower_time) / 2.0\n", " current_upper_bound = current_test_time\n", "\n", " counter += 1\n", " if counter > 1000:\n", " raise Exception(\"No Minimum Identified\")\n", "\n", " possible_time = current_mid_time\n", "\n", " if np.linalg.norm(get_juice_position_wrt_moon(possible_time)) <= threshold:\n", " flyby_times.append(possible_time)\n", "\n", " lower_time = lower_time + step\n", " mid_time = mid_time + step\n", " upper_time = upper_time + step\n", "\n", " return flyby_times" ], "outputs": [], "execution_count": 2 }, { "cell_type": "markdown", "id": "92c7c959-6979-4923-b5ef-8577bed40e0b", "metadata": {}, "source": [ "## Moon Selection and Loading of Spice Kernels\n", "We first need to specify which moon is to be considered for our analysis (it can be Europa, Ganymede, or Callisto).\n", "Then, Ephemeris Kernels are loaded for both JUICE and its Moons. They are found in the `../kernels/` folder." ] }, { "cell_type": "code", "id": "32973510-1ca6-4bd5-b56d-fcc0c81b356f", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:42:50.275102Z", "iopub.status.busy": "2025-09-16T07:42:50.274997Z", "iopub.status.idle": "2025-09-16T07:42:50.299974Z", "shell.execute_reply": "2025-09-16T07:42:50.299719Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:34.824548Z", "start_time": "2025-09-17T09:55:34.790434Z" } }, "source": [ "# Specify which moon is to be considered for the JUICE flybys (can be set to Europa, Ganymede, or Callisto)\n", "flyby_moon = \"Ganymede\"\n", "if flyby_moon != \"Europa\" and flyby_moon != \"Ganymede\" and flyby_moon != \"Callisto\":\n", " raise NameError('flyby_moon should be set to Europa, Ganymede, or Callisto.')\n", "\n", "# Load spice kernels\n", "path = os.path.abspath('../')\n", "kernels = [path+'/kernels/kernel_juice.bsp',path+'/kernels/kernel_noe.bsp']\n", "spice.load_standard_kernels(kernels)" ], "outputs": [], "execution_count": 3 }, { "cell_type": "markdown", "id": "84e090c8-ed7c-4e57-bac3-7e6e82b9477e", "metadata": {}, "source": [ "## Environment Setup\n", "### Set Epochs and Define Default Bodies Settings\n", "According to the JUICE's mission timeline, the moon flybys will take place from **2032 to mid 2034**. Multiplying by `constants.JULIAN_YEAR` is a way to express a given epoch in julian seconds.\n", "\n", "As for our framework, we need to create bodies for: Europa, Ganymede, Callisto, Io Jupiter and the Sun.\n", "We will select Jupiter as origin of our global frame, and orient it according to the J2000. Next, the defualt body settings can be defined." ] }, { "cell_type": "code", "id": "58602568-bf0b-4079-9653-623cab9b7726", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:42:50.301167Z", "iopub.status.busy": "2025-09-16T07:42:50.301067Z", "iopub.status.idle": "2025-09-16T07:42:50.303087Z", "shell.execute_reply": "2025-09-16T07:42:50.302840Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:34.872299Z", "start_time": "2025-09-17T09:55:34.869010Z" } }, "source": [ "# Set simulation start and end epochs according to JUICE mission timeline\n", "start_epoch = 32.0 * constants.JULIAN_YEAR \n", "end_epoch = 34.5 * constants.JULIAN_YEAR\n", "\n", "# Define default body settings\n", "bodies_to_create = [\"Europa\", \"Ganymede\", \"Callisto\", \"Io\", \"Jupiter\", \"Sun\"]\n", "global_frame_origin = \"Jupiter\"\n", "global_frame_orientation = \"J2000\"\n", "body_settings = environment_setup.get_default_body_settings(bodies_to_create, global_frame_origin,\n", " global_frame_orientation)" ], "outputs": [], "execution_count": 4 }, { "cell_type": "markdown", "id": "c5f5ca01-060c-46f8-8aa4-e58830daf2d3", "metadata": {}, "source": [ "### Define Additional Body Settings\n", "We hereby define **additional body settings**. These include:\n", "1) the flyby moon's **rotational model** (which we set as synchronus using:[`environment_setup.rotation_model.synchronous`](https://py.api.tudat.space/en/latest/rotation_model.html#tudatpy.dynamics.environment_setup.rotation_model.synchronous);\n", "2) the **JUICE ephemeris**, via: [`environment_setup.ephemeris.tabulated`](https://py.api.tudat.space/en/latest/ephemeris.html#tudatpy.dynamics.environment_setup.ephemeris.tabulated)." ] }, { "cell_type": "code", "id": "38da9869-0b6b-4f76-bc2d-e03c3243c155", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:42:50.304160Z", "iopub.status.busy": "2025-09-16T07:42:50.304067Z", "iopub.status.idle": "2025-09-16T07:42:50.306184Z", "shell.execute_reply": "2025-09-16T07:42:50.305944Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:34.919948Z", "start_time": "2025-09-17T09:55:34.916827Z" } }, "source": [ "# Set rotation of flyby moon to synchronous\n", "body_settings.get(flyby_moon).rotation_model_settings = environment_setup.rotation_model.synchronous(\n", " \"Jupiter\", global_frame_orientation, \"IAU_\" + flyby_moon)\n", "\n", "# Create empty settings for JUICE spacecraft\n", "body_settings.add_empty_settings(\"JUICE\")\n", "\n", "# Add JUICE mass to body settings\n", "body_settings.get(\"JUICE\").constant_mass = 5.0e3 #kg\n", "\n", "# Set empty ephemeris for JUICE\n", "empty_ephemeris_dict = dict()\n", "juice_ephemeris = environment_setup.ephemeris.tabulated(\n", " empty_ephemeris_dict,\n", " global_frame_origin,\n", " global_frame_orientation)\n", "body_settings.get(\"JUICE\").ephemeris_settings = juice_ephemeris" ], "outputs": [], "execution_count": 5 }, { "cell_type": "markdown", "id": "e4bbd34f-46da-4887-86cf-89ced282986f", "metadata": {}, "source": [ "### Define Acceleration Model Settings\n", "The **forces (accelerations)** acting on JUICE have to be defined.\n", "In this case, they consist in the followings:\n", "\n", "- **Gravitational acceleration of the Europa, Callisto, Ganymede modeled as Spherical Harmonics**, taken up to degree 2 and order 2;\n", "- **Gravitational acceleration of Io, modeled as a Point Mass**;\n", "- **Gravitational acceleration of Jupiter modeled as Spherical Harmonics**, taken up to degree 8;\n", "- **Gravitational acceleration of the Sun modeled as a Point Mass**;\n", "- **Radiation pressure acceleration caused by the Sun** \n", "\n", "The acceleration settings defined are then applied to JUICE in a dictionary, which is finally input to the propagation setup to create the **acceleration models**." ] }, { "cell_type": "code", "id": "2b19cfa8-e12d-4011-8759-be045c02c652", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:42:50.307522Z", "iopub.status.busy": "2025-09-16T07:42:50.307427Z", "iopub.status.idle": "2025-09-16T07:43:06.737801Z", "shell.execute_reply": "2025-09-16T07:43:06.737115Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:55.389718Z", "start_time": "2025-09-17T09:55:34.963033Z" } }, "source": [ "# Create radiation pressure settings\n", "reference_area = 100.0\n", "radiation_pressure_coefficient = 1.2\n", "occulting_bodies = {\"Sun\": [flyby_moon]}\n", "juice_radiation_pressure_settings = environment_setup.radiation_pressure.cannonball_radiation_target(\n", " reference_area, radiation_pressure_coefficient, occulting_bodies)\n", "\n", "# Add the radiation pressure interface to the body settings\n", "body_settings.get(\"JUICE\").radiation_pressure_target_settings = juice_radiation_pressure_settings\n", "\n", "# Create system of bodies\n", "bodies = environment_setup.create_system_of_bodies(body_settings)\n", "\n", "# Find all JUICE flybys around the specified flyby moon.\n", "# This finding algorithm identifies all closest approaches of the JUICE spacecraft with respect to the flyby moon,\n", "# based on the JUICE's SPICE trajectory. Only those with a closest distance smaller or equal to 2.0e7 m are kept.\n", "closest_approaches_juice = find_closest_approaches(start_epoch, end_epoch, 2.0e7)\n", "\n", "# Extract number of JUICE flybys\n", "number_of_flybys = len(closest_approaches_juice)\n", "print(f'Number of Flybys: {number_of_flybys}')\n", "\n", "# Define accelerations acting on JUICE\n", "accelerations_settings_juice = dict(\n", " Europa=[\n", " propagation_setup.acceleration.spherical_harmonic_gravity(2, 2),\n", " ],\n", " Ganymede=[\n", " propagation_setup.acceleration.spherical_harmonic_gravity(2, 2),\n", " ],\n", " Callisto=[\n", " propagation_setup.acceleration.spherical_harmonic_gravity(2, 2),\n", " ],\n", " Io=[\n", " propagation_setup.acceleration.point_mass_gravity(),\n", " ],\n", " Jupiter=[\n", " propagation_setup.acceleration.spherical_harmonic_gravity(8, 0)\n", " ],\n", " Sun=[\n", " propagation_setup.acceleration.radiation_pressure(),\n", " propagation_setup.acceleration.point_mass_gravity()\n", " ])\n", "\n", "acceleration_settings = {\"JUICE\": accelerations_settings_juice}\n", "\n", "body_to_propagate = [\"JUICE\"]\n", "central_body = [flyby_moon]\n", "\n", "acceleration_models = propagation_setup.create_acceleration_models(\n", " bodies, acceleration_settings, body_to_propagate, central_body)" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of Flybys: 7\n" ] } ], "execution_count": 6 }, { "cell_type": "markdown", "id": "498aceef-0864-4144-9a4a-11af71f28754", "metadata": {}, "source": [ "## Propagation Setup\n", "### Create the integrator settings\n", "At this stage, the integrator (propagator) is set up. First, we define the integrator settings. \n", "\n", "The integrator settings are defined using a RK78 integrator with a **variable step size** with 200 seconds initial step, 1E-12 **absolute and relative tolerances**, and **position/velocity block-wise tolerances**. \n", "\n", "You can find more information about the functionalities used in the following cell by simply clicking on their names in this markdown: \n", "- [`step_size_control_custom_blockwise_scalar_tolerance`](https://py.api.tudat.space/en/latest/integrator.html#tudatpy.dynamics.propagation_setup.integrator.step_size_control_blockwise_scalar_tolerance),\n", "- [`standard_cartesian_state_element_blocks`](https://py.api.tudat.space/en/latest/integrator.html#tudatpy.dynamics.propagation_setup.integrator.standard_cartesian_state_element_blocks),\n", "- [`step_size_validation`](https://py.api.tudat.space/en/latest/integrator.html#tudatpy.dynamics.propagation_setup.integrator.step_size_validation),\n", "- [`runge_kutta_variable_step`](https://py.api.tudat.space/en/latest/integrator.html#tudatpy.dynamics.propagation_setup.integrator.runge_kutta_variable_step)\n", "- [`rkf_78`](https://py.api.tudat.space/en/latest/integrator.html#tudatpy.dynamics.propagation_setup.integrator.CoefficientSets)\n", "\n", "or manually in the [Tudatpy API reference](https://py.api.tudat.space/en/latest/integrator.html#). " ] }, { "cell_type": "code", "id": "1bb01852-7c5d-444f-8f1f-0bf7d1202b72", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:43:06.739448Z", "iopub.status.busy": "2025-09-16T07:43:06.739304Z", "iopub.status.idle": "2025-09-16T07:43:06.741608Z", "shell.execute_reply": "2025-09-16T07:43:06.741311Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:55.455213Z", "start_time": "2025-09-17T09:55:55.451715Z" } }, "source": [ "# Define integrator settings \n", "control_settings = propagation_setup.integrator.step_size_control_custom_blockwise_scalar_tolerance(\n", " propagation_setup.integrator.standard_cartesian_state_element_blocks,\n", " 1.0E-12, 1.0E-12)\n", "\n", "validation_settings = propagation_setup.integrator.step_size_validation(0.001, 1000.0)\n", "\n", "integrator_settings = propagation_setup.integrator.runge_kutta_variable_step(\n", " initial_time_step = 200.0,\n", " coefficient_set = propagation_setup.integrator.CoefficientSets.rkf_78,\n", " step_size_control_settings = control_settings,\n", " step_size_validation_settings = validation_settings )" ], "outputs": [], "execution_count": 7 }, { "cell_type": "markdown", "id": "c07fc3d5-d8f7-4054-b7c6-5c0d52d3dc0e", "metadata": {}, "source": [ "### Dependent Variables\n", "**Dependent variables** such as **latitude, longitude and altitude** of JUICE with respect to the flyby moon are saved along the propagation (these will be used later in the plots).\n", "\n", "### Midpoint Backward and Forward Propagation\n", "The initial time of the propagation is set at the time of closest approach, and JUICE is propagated 1 hour backwards and forwards from that point, using the [`time_termination`](https://py.api.tudat.space/en/latest/propagator.html#tudatpy.dynamics.propagation_setup.propagator.time_termination) settings. **This is done for each found closest approach epoch**. At each iteration, the **flyby altitude is printed out**.\n", "\n", "The **dynamics is finally propagated** based on the acceleration settings defined above." ] }, { "cell_type": "code", "id": "736c2ad3-3199-4ccf-b2e6-38688d5013db", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:43:06.742798Z", "iopub.status.busy": "2025-09-16T07:43:06.742678Z", "iopub.status.idle": "2025-09-16T07:43:06.856835Z", "shell.execute_reply": "2025-09-16T07:43:06.856456Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:55.632498Z", "start_time": "2025-09-17T09:55:55.499942Z" } }, "source": [ "# Define dependent variables\n", "dependent_variables_names = [\n", " propagation_setup.dependent_variable.latitude(\"JUICE\", flyby_moon),\n", " propagation_setup.dependent_variable.longitude(\"JUICE\", flyby_moon),\n", " propagation_setup.dependent_variable.altitude(\"JUICE\", flyby_moon)\n", "]\n", "\n", "# Define propagator settings for each arc (i.e., each flyby)\n", "propagator_settings_list = []\n", "for k in range(number_of_flybys):\n", " # The initial time of the propagation is set at the time of closest approach (obtained from SPICE), and the JUICE spacecraft is then\n", " # propagated backwards and forwards from that point.\n", " flyby_time = closest_approaches_juice[k]\n", "\n", " # Get initial state of JUICE wrt the flyby moon from SPICE (JUICE's SPICE ID: -28)\n", " initial_state = spice.get_body_cartesian_state_at_epoch(\"-28\", flyby_moon, \"J2000\", \"None\", flyby_time)\n", " print('flyby altitude ',\n", " (np.linalg.norm(initial_state[:3]) - bodies.get(flyby_moon).shape_model.average_radius) / 1e3, 'km')\n", "\n", " # Create termination settings (propagate between 1 hour before and after closest approach)\n", " time_around_closest_approach = 3600.0\n", " termination_condition = propagation_setup.propagator.non_sequential_termination(\n", " propagation_setup.propagator.time_termination(flyby_time + time_around_closest_approach),\n", " propagation_setup.propagator.time_termination(flyby_time - time_around_closest_approach))\n", "\n", " # Define arc-wise propagator settings\n", " propagator_settings_list.append(propagation_setup.propagator.translational(\n", " central_body, acceleration_models, body_to_propagate, initial_state, flyby_time, integrator_settings,\n", " termination_condition,\n", " propagation_setup.propagator.cowell, dependent_variables_names))\n", "\n", "# Concatenate all arc-wise propagator settings into multi-arc propagator settings\n", "propagator_settings = propagation_setup.propagator.multi_arc(propagator_settings_list)\n", "\n", "# Propagate dynamics\n", "dynamics_simulator = simulator.create_dynamics_simulator(bodies, propagator_settings)\n", "propagation_results = dynamics_simulator.propagation_results.single_arc_results" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "flyby altitude 409.83211238424667 km\n", "flyby altitude 515.654384087557 km\n", "flyby altitude 5636.725442163613 km\n", "flyby altitude 2365.041538042541 km\n", "flyby altitude 867.2090550605934 km\n", "flyby altitude 3171.9132044050166 km\n", "flyby altitude 3351.7306764599844 km\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Warning, time-derivative of synchronous rotation matrix not yet implemented (using zero matrix)\n" ] } ], "execution_count": 8 }, { "cell_type": "markdown", "id": "3a7bd654-0567-4556-a132-2cdc497df2ef", "metadata": {}, "source": [ "## Flyby Visualization\n", "Having propagated the dynamics and saved the Latitude, Longitude and Altitude of JUICE with respect to the flyby moon, we can finally produce a **ground track plot** of our spacecraft. A map of Ganymede is added to the plot, just to make it even ✨ **cooler!** ✨" ] }, { "cell_type": "code", "id": "3fad6413-4442-49c1-961e-bd70f2673ca9", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:43:06.858269Z", "iopub.status.busy": "2025-09-16T07:43:06.858156Z", "iopub.status.idle": "2025-09-16T07:43:07.075983Z", "shell.execute_reply": "2025-09-16T07:43:07.075438Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:55.941850Z", "start_time": "2025-09-17T09:55:55.678867Z" } }, "source": [ "# Plot flybys\n", "moon_map = flyby_moon.lower() + '_map.jpg'\n", "img = plt.imread(moon_map)\n", "\n", "fig, ax = plt.subplots()\n", "ax.imshow(img, extent=[0, 360, -90, 90])\n", "for k in range(number_of_flybys):\n", " dependent_variables = result2array(propagation_results[k].dependent_variable_history)\n", "\n", " # Resolve 2pi ambiguity for longitude\n", " for i in range(len(dependent_variables)):\n", " if dependent_variables[i, 2] < 0:\n", " dependent_variables[i, 2] = dependent_variables[i, 2] + 2.0 * np.pi\n", "\n", " plot = ax.scatter(dependent_variables[:, 2] * 180 / np.pi, dependent_variables[:, 1] * 180 / np.pi, s=2,\n", " c=dependent_variables[:, 3] / 1e3, cmap='rainbow_r', vmin=0, vmax=5000)\n", "cb = plt.colorbar(plot)\n", "\n", "plt.xlabel('Longitude [deg]')\n", "plt.ylabel('Latitude [deg]')\n", "plt.xticks(np.arange(0, 361, 40))\n", "plt.yticks(np.arange(-90, 91, 30))\n", "cb.set_label('Altitude [km]')\n", "plt.title('JUICE flybys at ' + flyby_moon)\n", "plt.show()" ], "outputs": [ { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } } ], "execution_count": 9 }, { "cell_type": "markdown", "id": "adf268cf-c61a-47d0-8bf6-fca6abeb2b1d", "metadata": {}, "source": [ "## Time Step Evolution \n", "\n", "As we made use of a **variable time step** for our integration, it is instructive to check its **time evolution**.\n", "The `propagation_results` list defined earlier is a list of [`SingleArcSimulationResults`](https://py.api.tudat.space/en/latest/propagation.html#tudatpy.dynamics.propagation.SingleArcSimulationResults) objects (dictionaries) whose keys represent the computation time in seconds. **Taking the difference between the *(i)-th* and the *(i+1)-th* key will give the time step** used during the integration. Adding a vertical red line to the plot corresponding to each flyby's epoch, clearly highlights how **the time step value goes down around the epoch of closest approach with the moon**." ] }, { "cell_type": "code", "id": "93b0ddeb-0fd8-4d6e-9e01-98423579b2fa", "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:43:07.076898Z", "iopub.status.busy": "2025-09-16T07:43:07.076791Z", "iopub.status.idle": "2025-09-16T07:43:07.589554Z", "shell.execute_reply": "2025-09-16T07:43:07.589140Z" }, "ExecuteTime": { "end_time": "2025-09-17T09:55:56.577007Z", "start_time": "2025-09-17T09:55:55.950599Z" } }, "source": [ "num_plots = len(propagation_results)\n", "# Calculate the number of rows needed for two columns\n", "num_rows = (num_plots + 1) // 2 # This ensures enough rows for odd numbers of plots\n", "# Create a figure with subplots arranged in two columns\n", "fig, axes = plt.subplots(num_rows, 2, figsize=(10, 10))\n", "# Flatten axes array for easy indexing, in case num_plots is odd\n", "axes = axes.flatten()\n", "\n", "for i in range(num_plots):\n", " time_steps = np.diff(list(propagation_results[i].dependent_variable_history))\n", " times = list(propagation_results[i].dependent_variable_history)\n", " flyby_time = closest_approaches_juice[i]\n", " \n", " ax = axes[i]\n", " ax.plot(times[:-1], time_steps, label='Step Size')\n", " ax.axvline(flyby_time, color='r', linestyle='--', label='Flyby Time')\n", " ax.set_title(f\"Step Size Evolution, {flyby_moon} Flyby n.{i+1}\")\n", " ax.set_xlabel(\"Cumulative Computation Time (s)\")\n", " ax.set_ylabel(\"Step Size\")\n", " ax.legend()\n", "\n", "# Hide any unused subplots if num_plots is odd\n", "for j in range(num_plots, len(axes)):\n", " fig.delaxes(axes[j])\n", "\n", "# Adjust layout and show the figure with subplots\n", "plt.tight_layout()\n", "plt.show()" ], "outputs": [ { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } } ], "execution_count": 10 } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.13" } }, "nbformat": 4, "nbformat_minor": 5 }