{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic thrust model for satellite engines\n",
    "\n",
    "Copyright (c) 2010-2022, Delft University of Technology. All rights reserved. This file is part of the Tudat. Redistribution and use in source and binary forms, with or without modification, are permitted exclusively under the terms of the Modified BSD license. You should have received a copy of the license with this file. If not, please visit: http://tudat.tudelft.nl/LICENSE."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objectives\n",
    "\n",
    "This example demonstrates the application of a basic custom class to model the thrust of a satellite. \n",
    "\n",
    "Consider the orbit of JUICE with respect to Ganymede. The goal will be to increase the inclination of the orbit, while keeping the nodes constant. Theoretically speaking, the easiest way to do this is by one or more impulsive maneuvers at the nodes of the orbit. Naturally, in reality this thrust will not be impulsive, but the thrust will be applied over a finite duration.\n",
    "\n",
    "In this example, thrust is implemented to be provided when the true longitude of the spacecraft is within 2 degrees of one of the nodes. Note that parametrizing the thrust as a function of the true longitude is likely not an optimal choice, but it will suffice for this example. The maximum thrust magnitude $T_{max}$ is used when the thrust is on. Introducing such a discontinuity in the dynamical model is again likely not an optimal choice, but will suffice.\n",
    "In addition to the acceleration from the thrust, a basic model is set up, consisting of the following accelerations:\n",
    "\n",
    "- Spherical harmonic gravity accelerations from Ganymede and Jupiter. Their gravity fields will be expanded to D/O 2/2 and 4/0 respectively.\n",
    "- Third body forces will include those of the Sun, Saturn, Europa, Io and Callisto. \n",
    "\n",
    "The mass of the vehicle is propagated using a mass rate model consistent with the engine thrust used.\n",
    "\n",
    "How to set up dependent variables to save the mass and altitude of the vehicle over time is demonstrated.\n",
    "\n",
    "Finally, some post-processing is performed to analyze the retrieved results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import statements\n",
    "\n",
    "The required import statements are made here at the beginning of the code.\n",
    "\n",
    "Some standard modules are first loaded: `numpy` and `matplotlib.pyplot`.\n",
    "\n",
    "The different modules of `tudatpy` that will be used are then imported. We include here the loading of the standard spice kernels as well as the JUICE spice kernel. This is not a standard kernel included in SPICE, and hence an associated file will need to be provided as input, containing the relevant data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:04.640301Z",
     "iopub.status.busy": "2025-09-16T07:42:04.640195Z",
     "iopub.status.idle": "2025-09-16T07:42:05.087971Z",
     "shell.execute_reply": "2025-09-16T07:42:05.087466Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from tudatpy.util import result2array\n",
    "from tudatpy import constants\n",
    "from tudatpy.interface import spice\n",
    "from tudatpy import dynamics\n",
    "from tudatpy.dynamics import environment, environment_setup, propagation_setup, simulator\n",
    "from tudatpy.astro import element_conversion, time_representation\n",
    "\n",
    "# Load spice kernels.\n",
    "spice.load_standard_kernels()\n",
    "spice.load_kernel(\"input/juice_mat_crema_5_1_150lb_v01.bsp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment setup\n",
    "\n",
    "Let’s create the environment for our simulation. This setup covers the creation of (celestial) bodies, vehicle(s), and environment interfaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the bodies\n",
    "\n",
    "The required bodies will first be created. Note that this involves creation of a simple atmosphere for Ganymede as well as including the radiation pressure settings for JUICE. Please refer to the [Environment Models](https://docs.tudat.space/en/latest/_src_user_guide/state_propagation/environment_setup/environment_models.html) in the user guide for more details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.089544Z",
     "iopub.status.busy": "2025-09-16T07:42:05.089382Z",
     "iopub.status.idle": "2025-09-16T07:42:05.092550Z",
     "shell.execute_reply": "2025-09-16T07:42:05.092271Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create settings for celestial bodies\n",
    "bodies_to_create = [\"Ganymede\", \"Sun\", \"Jupiter\", \"Saturn\", \"Europa\", \"Io\", \"Callisto\"]\n",
    "global_frame_origin = 'Ganymede'\n",
    "global_frame_orientation = 'ECLIPJ2000'\n",
    "body_settings = environment_setup.get_default_body_settings(\n",
    "    bodies_to_create, global_frame_origin, global_frame_orientation)\n",
    "\n",
    "# Add empty body settings for the spacecraft\n",
    "body_settings.add_empty_settings(\"JUICE\")\n",
    "\n",
    "# Add mass property to spacecraft\n",
    "body_settings.get(\"JUICE\").constant_mass = 2E3\n",
    "\n",
    "\n",
    "# Create radiation pressure target model for spacecraft\n",
    "reference_area_radiation = 100.0\n",
    "radiation_pressure_coefficient = 1.2\n",
    "occulting_bodies_dict = dict()\n",
    "occulting_bodies_dict[\"Sun\"] = [\"Ganymede\"]\n",
    "body_settings.get(\"JUICE\").radiation_pressure_target_settings = environment_setup.radiation_pressure.cannonball_radiation_target(\n",
    "    reference_area_radiation, radiation_pressure_coefficient, occulting_bodies_dict )\n",
    "\n",
    "# Create environment\n",
    "bodies = environment_setup.create_system_of_bodies(body_settings)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the thrust guidance settings\n",
    "\n",
    "Let's now define the aspects of the body related to thrust: its orientation and its engine. This is done by defining a `ThrustGuidance` class that will contain functions that will calculate the thrust magnitude and thrust direction at any point in time.\n",
    "\n",
    "The class takes as input `maximum_thrust`, which defines what the constant value of the thrust will be when turned on in Newtons; `true_longitude_threshold`, which defines the range in degrees within which the thrust will be turned on, as measured from either of the nodes; `bodies` is the list of bodies created of type `SystemOfBodies`. Note that, in this class the thrust direction and magnitude are computed entirely independently (despite the fact that some computations are then done twice) to reduce the complexity of the example.\n",
    "\n",
    "Then, the `rotation_model_settings` and `thrust_magnitude_settings` are set up, which complete the thrust model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.093769Z",
     "iopub.status.busy": "2025-09-16T07:42:05.093651Z",
     "iopub.status.idle": "2025-09-16T07:42:05.099308Z",
     "shell.execute_reply": "2025-09-16T07:42:05.098922Z"
    }
   },
   "outputs": [],
   "source": [
    "class ThrustGuidance:\n",
    "\n",
    "    def __init__(self,\n",
    "                 maximum_thrust: float,\n",
    "                 true_longitude_threshold: float,\n",
    "                 bodies: environment.SystemOfBodies):\n",
    "        self.maximum_thrust = maximum_thrust\n",
    "        self.true_longitude_threshold = true_longitude_threshold\n",
    "        self.bodies = bodies\n",
    "\n",
    "    def compute_thrust_direction(self, current_time: float):\n",
    "        # Check if computation is to be done (if current_time is NaN, this signals the start of a new time step)\n",
    "        if (current_time == current_time):\n",
    "\n",
    "            # Retrieve current JUICE (keplerian) state w.r.t. Ganymede from environment\n",
    "            current_cartesian_state = self.bodies.get_body('JUICE').state - self.bodies.get_body('Ganymede').state\n",
    "            gravitational_parameter = self.bodies.get_body('Ganymede').gravitational_parameter\n",
    "            current_keplerian_state = element_conversion.cartesian_to_keplerian(current_cartesian_state,\n",
    "                                                                                gravitational_parameter)\n",
    "            true_anomaly = current_keplerian_state[5]\n",
    "            argument_of_pereapsis = current_keplerian_state[3]\n",
    "\n",
    "            # Check if JUICE is within the threshold of being 'close' to one of the nodes.\n",
    "            if (-self.true_longitude_threshold * np.pi / 180 <= (\n",
    "                    np.pi - argument_of_pereapsis - true_anomaly) <= self.true_longitude_threshold * np.pi / 180):\n",
    "                ang_momentum = np.cross(current_cartesian_state[:3], current_cartesian_state[3:])\n",
    "                normalized_ang_momentum = ang_momentum / np.linalg.norm(ang_momentum)\n",
    "\n",
    "                # Compute and return current thrust direction (3x1 vector): along orbital angular momentum vector\n",
    "                thrust_direction = -normalized_ang_momentum\n",
    "\n",
    "            elif (-self.true_longitude_threshold * np.pi / 180 <= (\n",
    "                    2 * np.pi - argument_of_pereapsis - true_anomaly) <= self.true_longitude_threshold * np.pi / 180):\n",
    "                ang_momentum = np.cross(current_cartesian_state[:3], current_cartesian_state[3:])\n",
    "                normalized_ang_momentum = ang_momentum / np.linalg.norm(ang_momentum)\n",
    "\n",
    "                # Compute and return current thrust direction (3x1 vector): along orbital angular momentum vector\n",
    "                thrust_direction = normalized_ang_momentum\n",
    "\n",
    "            else:\n",
    "                thrust_direction = np.zeros([3, 1])\n",
    "\n",
    "            return thrust_direction\n",
    "\n",
    "        # If no computation is to be done, return zeros\n",
    "        else:\n",
    "            return np.zeros([3, 1])\n",
    "\n",
    "    def compute_thrust_magnitude(self, current_time: float):\n",
    "        # Check if computation is to be done\n",
    "        if (current_time == current_time):\n",
    "\n",
    "            # Retrieve current JUICE (keplerian) state w.r.t. Ganymede from environment\n",
    "            current_cartesian_state = self.bodies.get_body('JUICE').state - self.bodies.get_body('Ganymede').state\n",
    "            gravitational_parameter = self.bodies.get_body('Ganymede').gravitational_parameter\n",
    "            current_keplerian_state = element_conversion.cartesian_to_keplerian(current_cartesian_state,\n",
    "                                                                                gravitational_parameter)\n",
    "\n",
    "            argument_of_pereapsis = current_keplerian_state[3]\n",
    "            true_anomaly = current_keplerian_state[5]\n",
    "\n",
    "            # Check if JUICE is within the threshold of being 'close' to one of the nodes and enable thrust if so\n",
    "            if (-self.true_longitude_threshold * np.pi / 180 <= (\n",
    "                    np.pi - argument_of_pereapsis - true_anomaly) <= self.true_longitude_threshold * np.pi / 180) or (\n",
    "                    -self.true_longitude_threshold * np.pi / 180 <= (\n",
    "                    2 * np.pi - argument_of_pereapsis - true_anomaly) <= self.true_longitude_threshold * np.pi / 180):\n",
    "                thrust_magnitude = self.maximum_thrust\n",
    "\n",
    "            else:\n",
    "                thrust_magnitude = 0.0\n",
    "\n",
    "            return thrust_magnitude\n",
    "        # If no computation is to be done, return zeros\n",
    "        else:\n",
    "            return 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.100450Z",
     "iopub.status.busy": "2025-09-16T07:42:05.100310Z",
     "iopub.status.idle": "2025-09-16T07:42:05.103443Z",
     "shell.execute_reply": "2025-09-16T07:42:05.103004Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create thrust guidance object (e.g. object that calculates direction/magnitude of thrust)\n",
    "thrust_magnitude = 1  # N\n",
    "true_longitude_threshold = 2  # degrees\n",
    "thrust_guidance_object = ThrustGuidance(thrust_magnitude, true_longitude_threshold, bodies)\n",
    "\n",
    "# Create engine model (default JUICE-fixed pointing direction) with custom thrust magnitude calculation\n",
    "constant_specific_impulse = 300  # s\n",
    "thrust_magnitude_settings = (\n",
    "    propagation_setup.thrust.custom_thrust_magnitude_fixed_isp(\n",
    "        thrust_guidance_object.compute_thrust_magnitude,\n",
    "        constant_specific_impulse))\n",
    "environment_setup.add_engine_model(\n",
    "    'JUICE', 'MainEngine', thrust_magnitude_settings, bodies)\n",
    "\n",
    "# Create vehicle rotation model such that thrust points in required direction in inertial frame\n",
    "thrust_direction_function = thrust_guidance_object.compute_thrust_direction\n",
    "rotation_model_settings = environment_setup.rotation_model.custom_inertial_direction_based(\n",
    "    thrust_direction_function,\n",
    "    \"JUICE-fixed\",\n",
    "    \"ECLIPJ2000\")\n",
    "environment_setup.add_rotation_model(bodies, \"JUICE\", rotation_model_settings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Propagation setup\n",
    "\n",
    "Now that the environment is created, the propagation setup is defined.\n",
    "\n",
    "First, the bodies to be propagated and the central bodies will be defined.\n",
    "Central bodies are the bodies with respect to which the state of the respective propagated bodies is defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.104512Z",
     "iopub.status.busy": "2025-09-16T07:42:05.104402Z",
     "iopub.status.idle": "2025-09-16T07:42:05.106152Z",
     "shell.execute_reply": "2025-09-16T07:42:05.105873Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define bodies that are propagated\n",
    "bodies_to_propagate = [\"JUICE\"]\n",
    "\n",
    "# Define central bodies of propagation\n",
    "central_bodies = [\"Ganymede\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the acceleration model\n",
    "\n",
    "First off, the acceleration settings that act on the JUICE are to be defined, which consists of the accelerations previously mentioned.\n",
    "\n",
    "The defined acceleration settings are then applied to JUICE in a dictionary.\n",
    "\n",
    "Finally, this dictionary is input to the propagation setup to create the acceleration models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.107057Z",
     "iopub.status.busy": "2025-09-16T07:42:05.106950Z",
     "iopub.status.idle": "2025-09-16T07:42:05.109783Z",
     "shell.execute_reply": "2025-09-16T07:42:05.109507Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define accelerations acting on vehicle.\n",
    "\n",
    "acceleration_settings_on_vehicle = dict(\n",
    "    JUICE=[\n",
    "        # Define the thrust acceleration from its direction and magnitude\n",
    "        propagation_setup.acceleration.thrust_from_engine('MainEngine')\n",
    "    ],\n",
    "    Ganymede=\n",
    "    [\n",
    "        propagation_setup.acceleration.spherical_harmonic_gravity(2, 2)\n",
    "    ],\n",
    "    Jupiter=\n",
    "    [\n",
    "        propagation_setup.acceleration.spherical_harmonic_gravity(4, 0)\n",
    "    ],\n",
    "    Sun=\n",
    "    [\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ],\n",
    "    Saturn=\n",
    "    [\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ],\n",
    "    Europa=\n",
    "    [\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ],\n",
    "    Io=\n",
    "    [\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ],\n",
    "    Callisto=\n",
    "    [\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Create global accelerations dictionary.\n",
    "acceleration_settings = {'JUICE': acceleration_settings_on_vehicle}\n",
    "\n",
    "# Create acceleration models.\n",
    "acceleration_models = propagation_setup.create_acceleration_models(\n",
    "    bodies, acceleration_settings, bodies_to_propagate, central_bodies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the initial state\n",
    "\n",
    "The initial state of JUICE that will be propagated is now defined. \n",
    "\n",
    "In this example, the initial state is retrieved from the JUICE spice kernel for a certain epoch, as defined at the start of the script. The final epoch is also given, making the propagation last a little over two weeks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.110742Z",
     "iopub.status.busy": "2025-09-16T07:42:05.110629Z",
     "iopub.status.idle": "2025-09-16T07:42:05.113230Z",
     "shell.execute_reply": "2025-09-16T07:42:05.112969Z"
    }
   },
   "outputs": [],
   "source": [
    "simulation_start_date = time_representation.DateTime(2035,7,28,14,24)\n",
    "simulation_start_epoch = simulation_start_date.epoch()\n",
    "simulation_end_epoch = simulation_start_epoch + 344.0 * constants.JULIAN_DAY / 24.0\n",
    "\n",
    "# Define initial state (retrieve from SPICE).\n",
    "system_initial_state = spice.get_body_cartesian_state_at_epoch(\n",
    "    target_body_name='JUICE',\n",
    "    observer_body_name='Ganymede',\n",
    "    reference_frame_name='ECLIPJ2000',\n",
    "    aberration_corrections='NONE',\n",
    "    ephemeris_time=simulation_start_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define dependent variables to save\n",
    "\n",
    "In this example, we are interested in saving not only the propagated state of the satellite over time, but also a set of so-called dependent variables that are to be computed (or extracted and saved) at each integration step.\n",
    "\n",
    "[This page](https://py.api.tudat.space/en/latest/dependent_variable.html) of the tudatpy API website provides a detailed explanation of all the dependent variables that are available.\n",
    "\n",
    "We will save the keplerian state of JUICE with respect to Ganymede, to verify whether we really do raise the inclination of the orbit. We will also save the mass of JUICE over time to ensure our mass propagation is also correctly performed. Lastly, we save norm of the thrust acceleration to verify whether the thrust we have set is indeed equal to 1N."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.114113Z",
     "iopub.status.busy": "2025-09-16T07:42:05.114015Z",
     "iopub.status.idle": "2025-09-16T07:42:05.115833Z",
     "shell.execute_reply": "2025-09-16T07:42:05.115569Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define required outputs\n",
    "dependent_variables_to_save = [\n",
    "    propagation_setup.dependent_variable.keplerian_state(\"JUICE\", \"Ganymede\"),\n",
    "    propagation_setup.dependent_variable.body_mass(\"JUICE\"),\n",
    "    propagation_setup.dependent_variable.single_acceleration_norm(\n",
    "        propagation_setup.acceleration.thrust_acceleration_type, \"JUICE\", \"JUICE\"\n",
    "    )\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the termination settings\n",
    "\n",
    "Let's now define a set of termination settings. In this setup, we only define a single termination setting:\n",
    "- Stop when JUICE reaches the specified end epoch (after a little over 14 days).\n",
    "\n",
    "In a more realistic scenario, you may want to set multiple termination settings; next to terminating on time you can also choose to terminate at a certain mass (e.g. when you run out of propellant) or a certain altitude. For simplicity, we simply let the propagation run its full course and we will analyse the results after."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.116674Z",
     "iopub.status.busy": "2025-09-16T07:42:05.116586Z",
     "iopub.status.idle": "2025-09-16T07:42:05.118157Z",
     "shell.execute_reply": "2025-09-16T07:42:05.117911Z"
    }
   },
   "outputs": [],
   "source": [
    "termination_settings = propagation_setup.propagator.time_termination(simulation_end_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the integrator settings\n",
    "\n",
    "The last step before starting the simulation is to set up the integrator that will be used.\n",
    "\n",
    "In this case, an RK4 fixed step size integrator is used, with a given step size of 10 s. This is one of the most simple and reliable integrators available, and usually works good enough for a wide number of applications, provided there are relatively stable dynamics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.118984Z",
     "iopub.status.busy": "2025-09-16T07:42:05.118902Z",
     "iopub.status.idle": "2025-09-16T07:42:05.120509Z",
     "shell.execute_reply": "2025-09-16T07:42:05.120282Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create numerical integrator settings.\n",
    "fixed_step_size = 10.0\n",
    "integrator_settings = propagation_setup.integrator.runge_kutta_fixed_step(\n",
    "    fixed_step_size, coefficient_set=propagation_setup.integrator.CoefficientSets.rk_4\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the propagator settings\n",
    "\n",
    "The propagator settings are now defined.\n",
    "\n",
    "As usual, translational propagation settings are defined, using a Cowell propagator.\n",
    "\n",
    "Next, mass propagation settings are also defined. The mass rate from the vehicle is set up to be consistent with the thrust used. The vehicle then loses mass as it loses propellant.\n",
    "\n",
    "Finally, a multitype propagator is defined, encompassing both the translational and the mass propagators.\n",
    "\n",
    "## Coupled dynamics\n",
    "If you have used Tudat before, you are most probably familiar with what _translational propagators_ are. Possibly, you are also familiar with combined translational-mass propagations. These are just an example of a **multi-type propagation**. The way Tudat deals with these multi-type propagations is by creating the appropriate \"single-type\" propagation settings for each type of dynamics, and then putting them all together at then end in the _multi-type propagator settings_. Thus, we will follow the same process here. For more details, see [multi-type propagation documentation](https://docs.tudat.space/en/latest/_src_user_guide/state_propagation/propagation_setup/multi_type.html).\n",
    "\n",
    "As you will see in the code below - and can be deduced comparing the APIs for the [translational](https://py.api.tudat.space/en/latest/propagator.html#tudatpy.dynamics.propagation_setup.propagator.translational), [mass](https://py.api.tudat.space/en/latest/propagator.html#tudatpy.dynamics.propagation_setup.propagator.mass) and [multi-type](https://py.api.tudat.space/en/latest/propagator.html#tudatpy.dynamics.propagation_setup.propagator.multitype) propagators - some of the inputs (namely the integrator settings, the initial time, the termination settings and the output variables) are identical between all three propagators - the two single-type and the one multi-type. In these overlaps, tudat will only read the \"top level\" arguments, i.e. those passed to the multi-type propagator and will ignore the rest. This means that these inputs can be left empty (`0`, `NaN` or `None`) for the single-type propagators. However, it is good practice to be self-consistent and pass the same inputs to all propagators. This facilitates the use of the single-type propagators for the simulation of only one type of dynamics while being consistent with the inputs of the multi-type simulation.\n",
    "\n",
    "Below, we will begin by creating these common inputs and will then move on to the propagator-specific inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.121512Z",
     "iopub.status.busy": "2025-09-16T07:42:05.121413Z",
     "iopub.status.idle": "2025-09-16T07:42:05.124214Z",
     "shell.execute_reply": "2025-09-16T07:42:05.123799Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create propagation settings.\n",
    "translational_propagator_settings = propagation_setup.propagator.translational(\n",
    "    central_bodies,\n",
    "    acceleration_models,\n",
    "    bodies_to_propagate,\n",
    "    system_initial_state,\n",
    "    simulation_start_epoch,\n",
    "    integrator_settings,\n",
    "    termination_settings,\n",
    "    output_variables=dependent_variables_to_save\n",
    ")\n",
    "\n",
    "# Create a mass rate model so that the vehicle loses mass according to how much thrust acts on it\n",
    "mass_rate_settings = dict(JUICE=[propagation_setup.mass_rate.from_thrust()])\n",
    "mass_rate_models = propagation_setup.create_mass_rate_models(\n",
    "    bodies,\n",
    "    mass_rate_settings,\n",
    "    acceleration_models\n",
    ")\n",
    "\n",
    "# Create the mass propagation settings\n",
    "mass_propagator_settings = propagation_setup.propagator.mass(\n",
    "    bodies_to_propagate,\n",
    "    mass_rate_models,\n",
    "    [bodies.get(\"JUICE\").mass],  # initial vehicle mass\n",
    "    simulation_start_epoch,\n",
    "    integrator_settings,\n",
    "    termination_settings)\n",
    "\n",
    "# Combine the translational and mass propagator settings\n",
    "propagator_settings = propagation_setup.propagator.multitype(\n",
    "    [translational_propagator_settings, mass_propagator_settings],\n",
    "    integrator_settings,\n",
    "    simulation_start_epoch,\n",
    "    termination_settings,\n",
    "    output_variables=dependent_variables_to_save)\n",
    "\n",
    "# This prints the initial and final state to ensure that the propagation is ran successfully, and has not terminated earlier.\n",
    "propagator_settings.print_settings.print_initial_and_final_conditions = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Propagate the orbit\n",
    "\n",
    "The orbit of JUICE around Ganymede is now ready to be propagated.\n",
    "\n",
    "This is done by calling the `create_dynamics_simulator()` function of the `dynamics, simulator module`.\n",
    "This function requires the `system_of_bodies` and `propagator_settings` that have all been defined earlier.\n",
    "\n",
    "After this, the history of the propagated state over time, containing both the position and velocity history, is extracted.\n",
    "This history, taking the form of a dictionary, is then converted to an array containing 7 columns:\n",
    "- Column 0: Time history, in seconds since J2000.\n",
    "- Columns 1 to 3: Position history, in meters, in the frame that was specified in the `body_settings`.\n",
    "- Columns 4 to 6: Velocity history, in meters per second, in the frame that was specified in the `body_settings`.\n",
    "\n",
    "The same is done with the dependent variable history. The column indexes corresponding to a given dependent variable in the `dependent_variables_to_save` variable are printed when the simulation is run, when `create_dynamics_simulator()` is called.\n",
    "Do pay attention that converting to an `ndarray` using the `result2array()` utility will shift these indexes because the first column (index 0) will then be the times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:05.125168Z",
     "iopub.status.busy": "2025-09-16T07:42:05.125069Z",
     "iopub.status.idle": "2025-09-16T07:42:33.313895Z",
     "shell.execute_reply": "2025-09-16T07:42:33.313544Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============  STARTING SINGLE-ARC PROPAGATION  ===============\n",
      "\n",
      "PRINTING INITIAL CONDITIONS\n",
      "   Initial epoch: (311810, 1440) \n",
      "   Initial state (transpose): \n",
      "     -451153       523495 -3.06983e+06     -435.986       1673.8      352.034         2000\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PRINTING FINAL CONDITIONS\n",
      "   Clock time since propagation start: 27.8795\n",
      "   Final epoch: (312154, 1440) \n",
      "   Final state (transpose): \n",
      "    187161     438605 3.0517e+06    562.567   -1694.34    214.963    1990.65\n",
      "\n",
      "PROPAGATION FINISHED.\n",
      "\n",
      "=================================================================\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Create simulation object and propagate dynamics.\n",
    "dynamics_simulator = simulator.create_dynamics_simulator(\n",
    "    bodies, propagator_settings)\n",
    "\n",
    "# Retrieve all data produced by simulation\n",
    "propagation_results = dynamics_simulator.propagation_results\n",
    "\n",
    "# Extract numerical solution for states and dependent variables\n",
    "state_history = propagation_results.state_history\n",
    "dependent_variable_history = propagation_results.dependent_variable_history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's look at plots\n",
    "\n",
    "We are now ready to do some post-processing, and look at our results! As mentioned before, we are interested in validating whether our maneuver was performed successfully, and whether the mass propagation has accurately kept track of the mass of JUICE over time.\n",
    "\n",
    "As such, we'll plot the inclination, the mass of JUICE over time and add several plots to gain some confidence in the correct implementation of the thrust direction and magnitude, such as a plot of the magnitude as a function of the true longitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-09-16T07:42:33.338178Z",
     "iopub.status.busy": "2025-09-16T07:42:33.338037Z",
     "iopub.status.idle": "2025-09-16T07:42:33.771521Z",
     "shell.execute_reply": "2025-09-16T07:42:33.771084Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## PLOTS\n",
    "\n",
    "# INDEX:      1,   2,   3,   4,     5,    6,     7,  8\n",
    "# STATE:      x,   y,   z,   vx,    vy,   vz\n",
    "# DEPENDENTS: a,   e,   i,   omega, RAAN, theta, mass, thrust_acceleration\n",
    "\n",
    "states_array = result2array(state_history)\n",
    "dependents_array = result2array(dependent_variable_history)\n",
    "epochs = (states_array[:, 0] - states_array[0,0]) / 86400.0\n",
    "time_label = 'Time [days]'\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(epochs[:1000], np.degrees(dependents_array[:1000,3]), label = r'$i$')\n",
    "plt.grid()\n",
    "plt.xlabel(time_label)\n",
    "plt.ylabel('Inclination [deg]')\n",
    "plt.title('Inclination of JUICE as a function of time')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(epochs[:1000], dependents_array[:1000,7], label = r'$m$')\n",
    "plt.grid()\n",
    "plt.xlabel(time_label)\n",
    "plt.ylabel('Mass [kg]')\n",
    "plt.title('Mass of JUICE as a function of time')\n",
    "\n",
    "f, (ax, ax2) = plt.subplots(1, 2, sharey=True)\n",
    "\n",
    "# plot the thrust magnitude (the thrust acceleration times the mass) as a function of the true longitude. Note that these slices are taken by first having looked at a full plot, and realizing that\n",
    "# it's quite hard to validate anything since the full plot is not detailed enough.\n",
    "ax.scatter(np.rad2deg((dependents_array[:,6][230:260] + dependents_array[:,4][230:260])), dependents_array[:,7][230:260]*dependents_array[:,8][230:260])\n",
    "ax2.scatter(np.rad2deg((dependents_array[:,6][770:800] + dependents_array[:,4][770:800])), dependents_array[:,7][770:800]*dependents_array[:,8][770:800])\n",
    "\n",
    "# Limit our view of the mean anomaly to be within 4 degrees of the two nodes; they are our areas of interest.\n",
    "ax.set_xlim(356, 364)  # outliers only\n",
    "ax.grid()\n",
    "ax2.set_xlim(176, 184)  # most of the data\n",
    "ax2.grid()\n",
    "\n",
    "# hide the spines between ax and ax2\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax2.spines['left'].set_visible(False)\n",
    "ax.xaxis.tick_bottom()\n",
    "ax.tick_params(labeltop=False)  # don't put tick labels at the top\n",
    "ax2.xaxis.tick_bottom()\n",
    "\n",
    "d = .015  # how big to make the diagonal lines in axes coordinates\n",
    "# arguments to pass to plot, just so we don't keep repeating them\n",
    "kwargs = dict(transform=ax.transAxes, color='k', clip_on=False)\n",
    "ax.plot((1-d, 1+d), (1-d, 1+d), **kwargs)        # top-left diagonal\n",
    "ax.plot((1 - d, 1 + d), (-d, +d), **kwargs)  # top-right diagonal\n",
    "\n",
    "kwargs.update(transform=ax2.transAxes)  # switch to the bottom axes\n",
    "ax2.plot((-d, +d), (1 - d, 1 + d), **kwargs)  # bottom-left diagonal\n",
    "ax2.plot((- d,  + d), ( - d,  + d), **kwargs)  # bottom-right diagonal\n",
    "\n",
    "f.text(0.5, 0.92, 'Thrust force magnitude against the true longitude of JUICE for the first two node crossings.', ha='center', fontsize = 12)\n",
    "f.text(0.5, 0.01, 'true longitude [deg]', ha='center')\n",
    "f.text(0.01, 0.5, 'thrust force magnitude [N]', va='center', rotation='vertical')\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the plots created, we can verify (and further analyze) a couple of things. First of all, note that the mass of the vehicle behaves as we would expect: save for some periods of time where the thrust is turned on, it remains constant. For the times where the thrust is turned on, the mass decreases linearly. From this point, we could also analyze whether the mass decrease is what we would expect from the thrust force the engine produces to gain further confidence in the results.\n",
    "\n",
    "Note that the inclination also behaves as expected: at specific times, the inclination sharply increases, likely due to the applied thrust from the vehicle's engine. In order to gain more confidence in this assumption, two things can be done: First, the times at which the inclination rapidly increases can be compared with the times at which the mass decreases. From a visual analysis, they seem to match up. Second, it is useful to run two propagations, one where the engine's thrust acceleration is takes into account, and one where the engine's thrust acceleration is left out. The difference in kepler elements, and more specifically in our case, the inclination, should be (almost) entirely caused by the applied thrust. Since this model is an approximation of instantenously applied thrust, it is likely there will also be small variations in the other kepler elements. This is useful to realize when creating such a model.\n",
    "\n",
    "Lastly, it's also useful to verify whether the thrust is applied at the correct times; within two degrees of either of the nodes. We can do this by plotting the thrust magnitude against the true longitude, defined as the sum of the true anomaly and the argument of pereapsis. From the last figure, we can conclude that, indeed, the thrust is non-zero within two degrees of either of the nodes, and zero everywhere else in the orbit.\n",
    "\n",
    "Of course, this analysis can be extended to validate, for example, the direction of the applied thrust and, as said before, the other kepler elements. They can give deeper insights on how exactly thrust models influence the propagations."
   ]
  }
 ],
 "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": 4
}