{ "cells": [ { "cell_type": "markdown", "id": "94a73835-01f4-4c72-887f-074e59444ff3", "metadata": {}, "source": [ "# Covariance Propagation Using `Starlink-32101`\n", "\n", "## Objectives\n", "This example will show you how to **propagate the covariance**. We will simulate a series of **one-way** open loop observing sessions of the ``Starlink-32101`` satellite, and we will see simulating a different number of observations affects the evolution of the **formal errors** over time. This example builds up on the [Starlink-32101 Covariance Analysis example](covariance_estimated_parameters.ipynb), so go check that out if you haven't already! " ] }, { "cell_type": "markdown", "id": "e99cbeda", "metadata": {}, "source": [ "## Import statements\n", "Typically - in the most pythonic way - all required modules are imported at the very beginning.\n", "\n", "Some standard modules are first loaded: `numpy` and `matplotlib.pyplot`.\n", "\n", "Then, the different modules of `tudatpy` that will be used are imported. Most notably, the `estimation`, `estimation_setup`, and `observations` modules will be used and demonstrated within this example." ] }, { "cell_type": "code", "execution_count": 1, "id": "b71677c3", "metadata": {}, "outputs": [], "source": [ "# Load required standard modules\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_setup, parameters_setup, simulator\n", "from tudatpy import estimation\n", "from tudatpy.estimation import observable_models_setup, observable_models, observations_setup, observations, estimation_analysis\n", "from tudatpy.astro.time_representation import DateTime\n", "from tudatpy.astro import element_conversion\n", "from tudatpy.astro import frame_conversion" ] }, { "cell_type": "markdown", "id": "707bd319", "metadata": {}, "source": [ "## Configuration\n", "First, NAIF's `SPICE` kernels are loaded, to make the positions of various bodies such as the Earth, the Sun, or the Moon known to `tudatpy`. \n", "Subsequently, the start and end epoch of the simulation are defined, as well as the observation epochs.\n", "As already mentioned, within this example we want to show how to propagate the covariance, while also highlighting the role that different observations have on the formal errors propagation. In particular, we will set our `simulation_start_epoch` and end `simulation_end_epoch` to be August 8, 2024 and September 5, 2024 respectively. We will then consider the three following observation scenarios:\n", "\n", "* **Single observation session**: from August 30, 2024 to September 1, 2024, with a cadence of 60 seconds.\n", "* **Double observation session**:\n", " First Session: from August 30, 2024 to September 1, 2024, with a cadence of 60 seconds.\n", " Second Session: from September 3, 2024, to September 4, 2024, with a cadence of 60 seconds.\n", "* **Single observation session**: from August 29, 2024 to `simulation_end_epoch`\n", "\n", "Please note that, in general, the satellite might not be visible during a full osbervation session. \n", "For more information on J2000 and the conversion between different temporal reference frames, please refer to the [API documentation](https://py.api.tudat.space/en/latest/time_representation.html) of the `time_representation` module." ] }, { "cell_type": "code", "execution_count": 2, "id": "e336516b", "metadata": {}, "outputs": [], "source": [ "# Load spice kernels\n", "spice.load_standard_kernels()\n", "\n", "# Set simulation start and end epochs\n", "simulation_start_epoch = DateTime(2024, 8, 28).epoch()\n", "simulation_end_epoch = DateTime(2024, 9, 5).epoch()\n", "observation_start_epoch_1 = DateTime(2024, 8, 30).epoch()\n", "observation_end_epoch_1 = DateTime(2024, 9, 1).epoch()\n", "observation_start_epoch_2 = DateTime(2024, 9, 3).epoch()\n", "observation_end_epoch_2 = DateTime(2024, 9, 4).epoch()\n", "\n", "observation_start_epoch_3 = DateTime(2024, 8, 29).epoch()\n", "observation_end_epoch_3 = simulation_end_epoch" ] }, { "cell_type": "markdown", "id": "dd2cea53", "metadata": {}, "source": [ "## Set up the environment\n", "We will now create and define the settings for the environment of our simulation. In particular, this covers the creation of (celestial) bodies, vehicle(s), and environment interfaces.\n", "\n", "### Create the main bodies\n", "To create the systems of bodies for the simulation, one first has to define a list of strings of all bodies that are to be included. Note that the default body settings (such as atmosphere, body shape, rotation model) are taken from the `SPICE` kernel.\n", "\n", "These settings, however, can be adjusted. Please refer to the [Available Environment Models](https://docs.tudat.space/en/latest/_src_user_guide/state_propagation/environment_setup/environment_models.html#available-model-types) in the user guide for more details." ] }, { "cell_type": "code", "execution_count": 3, "id": "4563c7d1", "metadata": {}, "outputs": [], "source": [ "# Create default body settings for \"Sun\", \"Earth\", \"Moon\", \"Mars\", and \"Venus\"\n", "bodies_to_create = [\"Sun\", \"Earth\", \"Moon\", \"Mars\", \"Venus\"]\n", "\n", "# Create default body settings for bodies_to_create, with \"Earth\"/\"J2000\" as the global frame origin and orientation\n", "global_frame_origin = \"Earth\"\n", "global_frame_orientation = \"J2000\"\n", "body_settings = environment_setup.get_default_body_settings(\n", " bodies_to_create, global_frame_origin, global_frame_orientation)\n", "\n", "# Create system of bodies\n", "bodies = environment_setup.create_system_of_bodies(body_settings)" ] }, { "cell_type": "markdown", "id": "f1b002c1", "metadata": {}, "source": [ "### Create the vehicle and its environment interface\n", "We will now create the satellite - called `Starlink-32101` - for which an orbit will be simulated. Using an `empty_body` as a blank canvas for the satellite, we define mass of 260kg, a reference area (used both for aerodynamic and radiation pressure) of 20m$^2$, and a aerodynamic drag coefficient of 1.2. Idem for the radiation pressure coefficient. Finally, when setting up the radiation pressure interface, the Earth is set as a body that can occult the radiation emitted by the Sun." ] }, { "cell_type": "code", "execution_count": 4, "id": "1585b93e", "metadata": {}, "outputs": [], "source": [ "# Create vehicle objects.\n", "body_settings.add_empty_settings(\"Starlink-32101\")\n", "body_settings.get(\"Starlink-32101\").constant_mass = 260\n", "\n", "# Create aerodynamic coefficient interface settings\n", "reference_area = 20 # Average projection area of a 3U CubeSat\n", "drag_coefficient = 1.2\n", "aero_coefficient_settings = environment_setup.aerodynamic_coefficients.constant(\n", " reference_area, [drag_coefficient, 0.0, 0.0]\n", ")\n", "# Add the aerodynamic interface to the environment\n", "body_settings.get(\"Starlink-32101\").aerodynamic_coefficient_settings = aero_coefficient_settings\n", "\n", "# Create radiation pressure settings\n", "reference_area_radiation = 20 # Average projection area of a 3U CubeSat\n", "radiation_pressure_coefficient = 1.2\n", "occulting_bodies = dict()\n", "occulting_bodies[\"Sun\"] = [\"Earth\"]\n", "radiation_pressure_settings = environment_setup.radiation_pressure.cannonball_radiation_target(\n", " reference_area_radiation, radiation_pressure_coefficient, occulting_bodies)\n", "\n", "# Add the radiation pressure interface to the environment\n", "body_settings.get(\"Starlink-32101\").radiation_pressure_target_settings = radiation_pressure_settings\n", "\n", "# Create system of bodies\n", "bodies = environment_setup.create_system_of_bodies(body_settings)" ] }, { "cell_type": "markdown", "id": "8bc428bc", "metadata": {}, "source": [ "## Set up the Satellite Propagation\n", "Having the environment created, we will define the settings for the propagation of the spacecraft. First, we have to define the body to be propagated - here, the spacecraft - and the central body - here, Earth - with respect to which the state of the propagated body is defined." ] }, { "cell_type": "code", "execution_count": 5, "id": "f4c79591", "metadata": {}, "outputs": [], "source": [ "# Define bodies that are propagated\n", "bodies_to_propagate = [\"Starlink-32101\"]\n", "\n", "# Define central bodies of propagation\n", "central_bodies = [\"Earth\"]" ] }, { "cell_type": "markdown", "id": "a615dbcd", "metadata": {}, "source": [ "### Create the acceleration model\n", "Subsequently, all accelerations (and there settings) that act on ``Starlink-32101`` have to be defined. In particular, we will consider:\n", "\n", "* Gravitational acceleration using a spherical harmonic approximation up to 8th degree and order for Earth.\n", "* Aerodynamic acceleration for Earth.\n", "* Gravitational acceleration using a simple point mass model for:\n", "\n", " - The Sun\n", " - The Moon\n", " - Mars\n", "\n", "* Radiation pressure experienced by the spacecraft - shape-wise approximated as a spherical cannonball - due to the Sun.\n", "\n", "The defined acceleration settings are then applied to ``Starlink-32101`` by means of a dictionary, which is finally used as input to the propagation setup to create the acceleration models." ] }, { "cell_type": "code", "execution_count": 6, "id": "ae320f6d", "metadata": {}, "outputs": [], "source": [ "# Define the accelerations acting on `Starlink-32101`\n", "accelerations_settings_Starlink_32101 = dict(\n", " Sun=[\n", " propagation_setup.acceleration.radiation_pressure(),\n", " propagation_setup.acceleration.point_mass_gravity()\n", " ],\n", " Mars=[\n", " propagation_setup.acceleration.point_mass_gravity()\n", " ],\n", " Moon=[\n", " propagation_setup.acceleration.point_mass_gravity()\n", " ],\n", " Earth=[\n", " propagation_setup.acceleration.spherical_harmonic_gravity(8, 8),\n", " propagation_setup.acceleration.aerodynamic()\n", " ])\n", "\n", "# Create global accelerations dictionary\n", "acceleration_settings = {\"Starlink-32101\": accelerations_settings_Starlink_32101}\n", "\n", "# Create acceleration models\n", "acceleration_models = propagation_setup.create_acceleration_models(\n", " bodies,\n", " acceleration_settings,\n", " bodies_to_propagate,\n", " central_bodies)" ] }, { "cell_type": "markdown", "id": "f4a73dba", "metadata": {}, "source": [ "### Define the initial state\n", "Realise that the initial state of the spacecraft always has to be provided as a cartesian state - i.e. in the form of a list with the first three elements representing the initial position, and the three remaining elements representing the initial velocity.\n", "\n", "Within this example, we will retrieve the initial state of `Starlink-32101` using its Two-Line-Elements (TLE) the date of its launch (April the 28th, 2008). The TLE strings are obtained from [www.n2yo.com](https://www.n2yo.com/satellite/?s=60447)." ] }, { "cell_type": "code", "execution_count": 7, "id": "12458abf", "metadata": {}, "outputs": [], "source": [ "# Retrieve the initial state of `Starlink-32101` using Two-Line-Elements (TLEs)\n", "Starlink_tle = environment.Tle(\n", " \"1 60447U 24144Y 24239.91667824 -.00652022 00000-0 -25508-2 0 9990\",\n", " \"2 60447 53.1498 303.6008 0000548 88.4809 23.6264 15.87779028 3478\",\n", ")\n", "Starlink_ephemeris = environment.TleEphemeris(\"Earth\", \"J2000\", Starlink_tle, False)\n", "initial_state = Starlink_ephemeris.cartesian_state( simulation_start_epoch )" ] }, { "cell_type": "markdown", "id": "cd8e2587", "metadata": {}, "source": [ "### Create the integrator settings\n", "For the problem at hand, we will use an RKF78 integrator with a fixed step-size of 60 seconds. This can be achieved by tweaking the implemented RKF78 integrator with variable step-size such that both the minimum and maximum step-size is equal to 60 seconds and a tolerance of 1.0" ] }, { "cell_type": "code", "execution_count": 8, "id": "44edeb70", "metadata": {}, "outputs": [], "source": [ "# Create numerical integrator settings\n", "integrator_settings = propagation_setup.integrator.\\\n", " runge_kutta_fixed_step_size(initial_time_step=60.0,\n", " coefficient_set=propagation_setup.integrator.CoefficientSets.rkdp_87)" ] }, { "cell_type": "markdown", "id": "890fda75", "metadata": {}, "source": [ "### Create the propagator settings\n", "By combining all of the above-defined settings we can define the settings for the propagator to simulate the orbit of ``Starlink-32101`` around Earth. A termination condition needs to be defined so that the propagation stops as soon as the specified end epoch is reached. Finally, the translational propagator's settings are created." ] }, { "cell_type": "code", "execution_count": 9, "id": "facb90c1", "metadata": {}, "outputs": [], "source": [ "# Create termination settings\n", "termination_condition = propagation_setup.propagator.time_termination(simulation_end_epoch)\n", "\n", "# Create propagation settings\n", "propagator_settings = propagation_setup.propagator.translational(\n", " central_bodies,\n", " acceleration_models,\n", " bodies_to_propagate,\n", " initial_state,\n", " simulation_start_epoch,\n", " integrator_settings,\n", " termination_condition\n", ")" ] }, { "cell_type": "markdown", "id": "956c9ebe", "metadata": {}, "source": [ "## Set up the observations\n", "Having set the underlying dynamical model of the simulated orbit, we can define the observational model. Generally, this entails the addition all required ground stations, the definition of the observation links and types, as well as the precise simulation settings.\n", "\n", "### Add a ground station\n", "Trivially, the simulation of observations requires the extension of the current environment by at least one observer - a ground station. For this example, we will model a single ground station located in Delft, Netherlands, at an altitude of 0m, 52.00667°N, 4.35556°E.\n", "\n", "More information on how to use the `add_ground_station()` function can be found in the respective [API documentation](https://py.api.tudat.space/en/latest/environment_setup.html#tudatpy.dynamics.environment_setup.add_ground_station)." ] }, { "cell_type": "code", "execution_count": 10, "id": "4eebd846", "metadata": {}, "outputs": [], "source": [ "# Define the position of the ground station on Earth\n", "station_altitude = 0.0\n", "delft_latitude = np.deg2rad(52.00667)\n", "delft_longitude = np.deg2rad(4.35556)\n", "\n", "# Add the ground station to the environment\n", "environment_setup.add_ground_station(\n", " bodies.get_body(\"Earth\"),\n", " \"TrackingStation\",\n", " [station_altitude, delft_latitude, delft_longitude],\n", " element_conversion.geodetic_position_type)" ] }, { "cell_type": "markdown", "id": "451a76c7", "metadata": {}, "source": [ "### Define Observation Links and Types\n", "To establish the links between our ground station and ``Starlink-32101``, we will make use of the [observation module](https://py.api.tudat.space/en/latest/observation.html#observation) of tudat. In particular, we choose a one-way doppler observation mode, which means that the spacecraft effectively acts as a transmitter, while the antenna is the receiver. As already done in the [Starlink-32101 Covariance Analysis example](covariance_estimated_parameters.ipynb), we will select an Earth Tracking Station located in Delft as a receiver. \n", "\n", "To fully define an observation model for a given link, we have to create a list of the observation model settings of all desired observable types and their associated links. This list will later be used as input to the actual estimator object.\n", "\n", "Each observable type has its own function for creating observation model settings - in this example we will use the `one_way_doppler_instantaneous()` function to model a series of one-way open-loop (i.e. instantaneous) Doppler observations. " ] }, { "cell_type": "code", "execution_count": 11, "id": "8a19c012", "metadata": {}, "outputs": [], "source": [ "# Define the uplink link ends for one-way observable\n", "link_ends = dict()\n", "link_ends[observable_models_setup.links.receiver] = observable_models_setup.links.body_reference_point_link_end_id(\"Earth\", \"TrackingStation\")\n", "link_ends[observable_models_setup.links.transmitter] = observable_models_setup.links.body_origin_link_end_id(\"Starlink-32101\")\n", "\n", "# Create observation settings for each link/observable\n", "link_definition = observable_models_setup.links.LinkDefinition(link_ends)\n", "observation_settings_list = [observable_models_setup.model_settings.one_way_doppler_instantaneous(link_definition)]" ] }, { "cell_type": "markdown", "id": "f9b8518a", "metadata": {}, "source": [ "### Finally: Covariance Propagation\n", "In order to propagate the covariance, we need to define the **observation settings**, **the parameters to estimate**. We also need to select an **input covariance**. \n", "The set up of the estimation process and the covariance propagation is outlined below. Note that we will iterate this procedure over the three observation scenarios, using a **for loop**. \n", "\n", "#### 1 - Define Observation Simulation Settings\n", "The observation simulation settings:\n", "\n", "1) allows for setting up of the **time intervals** at which observations are simulated (keep in mind the **three different observation scenarios** we want to simulate!);\n", "2) allows for the definition of a noise level to simulate noisy observations\n", "3) allows for the definition of the **viability criteria** and noise of the observation (we will set a minimum required elevation angle of **15 degrees**)\n", "\n", "#### 2 - Define the Parameters to Estimate\n", "For this example estimation, we decided to estimate the initial state of `Starlink-32101`, its drag coefficient, and the gravitational parameter of Earth. A comprehensive list of parameters available for estimation is provided at [this link (TudatPy API Reference)](https://py.api.tudat.space/en/latest/parameter.html).\n", "\n", "#### 3 - Perform the observations simulation\n", "Using the created `Estimator` object, we can perform the simulation of observations by calling its `simulate_observations()` method, see the [API reference](https://py.api.tudat.space/en/latest/estimation/observations_setup/observations_wrapper.html#tudatpy.estimation.observations_setup.observations_wrapper.simulate_observations). Note that to know about the time settings for the individual types of observations, this function makes use of the earlier defined observation simulation settings.\n", "\n", "#### 4 - Define the Input Covariance\n", "We collect all relevant inputs in the form of a covariance input, with the variance represented by the noise levels we chose earlier. This will be given as an input to the estimation process, to obtain `covariance_output = estimator.compute_covariance(covariance_input)`. The `covariance_output` will then become the initial covariance to be propagated by subsequent applications of the **state transition matrix**, initialized by the function `state_transition_interface` of the `estimator` object. \n", "\n", "#### 5 - Propagate the Covariances and the Formal Errors\n", "Covariances and Formal Errors are propagated at the `output_times = simulation_times`, using the functions `propagate_covariance_split_output`, `propagate_formal_errors_split_output` (or `propagate_covariance`, `propagate_formal_errors`) of the estimation class, and through the above-defined state transition matrix. Please note that, in principle, one does not need to propagate the **formal errors** if the **propagated covariance** is already available. This is because the formal errors constitute the diagonal elements (**variances**) of the covariance matrix (to learn more about this, also check the [Starlink-32101 Parameter Estimation example](full_estimation_example.ipynb).)\n", "\n", "#### 6 - Append Results\n", "We append the formal errors and the covariance obtained for each scenario to the respective lists: `formal_errors_list`, `covariances_list`." ] }, { "cell_type": "code", "execution_count": 12, "id": "48d30336", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Scenario n. 1\n", "\n", "Setting up Estimation and Propagating Covariance ...\n", "\n", "Calculating residuals and partials 27\n", "... Done.\n", "\n", "Scenario n. 2\n", "\n", "Setting up Estimation and Propagating Covariance ...\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Warning, function setConstantPerObservableWeightsMatrix is deprecated, weights should preferably be defined at the observation collection level.Warning, function setConstantPerObservableWeightsMatrix is deprecated, weights should preferably be defined at the observation collection level." ] }, { "name": "stdout", "output_type": "stream", "text": [ "Calculating residuals and partials 37\n", "... Done.\n", "\n", "Scenario n. 3\n", "\n", "Setting up Estimation and Propagating Covariance ...\n", "\n", "Calculating residuals and partials 89\n", "... Done.\n", "\n", "All Done.\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Warning, function setConstantPerObservableWeightsMatrix is deprecated, weights should preferably be defined at the observation collection level." ] } ], "source": [ "# 1 - Define Observation Simulation Settings\n", "\n", "simulation_times = np.arange(simulation_start_epoch, simulation_end_epoch, 60.0)\n", "\n", "observation_times_1 = np.arange(observation_start_epoch_1, observation_end_epoch_1, 60.0)\n", "observation_times_2 = np.arange(observation_start_epoch_2, observation_end_epoch_2, 60.0)\n", "observation_times_3 = np.arange(observation_start_epoch_3, observation_end_epoch_3, 60.0)\n", "\n", "output_times = simulation_times\n", "covariance_output_list = []\n", "formal_errors_list = []\n", "covariances_list = []\n", "\n", "for n_scenario in [1,2,3]:\n", " print(f'Scenario n. {n_scenario}\\n')\n", " print(f'Setting up Estimation and Propagating Covariance ...\\n')\n", " if n_scenario == 1:\n", " observation_times = observation_times_1\n", " elif n_scenario == 2:\n", " observation_times = np.concatenate((observation_times_1, observation_times_2))\n", " else:\n", " observation_times = observation_times_3\n", "\n", " observation_simulation_settings = observations_setup.observations_simulation_settings.tabulated_simulation_settings(\n", " observable_models_setup.model_settings.one_way_instantaneous_doppler_type,\n", " link_definition,\n", " observation_times\n", " )\n", "\n", " # Add noise levels of roughly 1.0E-3 [m/s] and add this as Gaussian noise to the observation\n", " noise_level = 1.0E-3\n", " observations_setup.random_noise.add_gaussian_noise_to_observable(\n", " [observation_simulation_settings],\n", " noise_level,\n", " observable_models_setup.model_settings.one_way_instantaneous_doppler_type\n", " )\n", "\n", " # Create viability settings\n", " viability_setting = observations_setup.viability.elevation_angle_viability([\"Earth\", \"TrackingStation\"], np.deg2rad(15))\n", " observations_setup.viability.add_viability_check_to_all(\n", " [observation_simulation_settings],\n", " [viability_setting]\n", " )\n", "\n", "\n", "# 2 - Define the Parameters to Estimate\n", " \n", " # Setup parameters settings to propagate the state transition matrix\n", " parameter_settings = parameters_setup.initial_states(propagator_settings, bodies)\n", " \n", " # Add estimated parameters to the sensitivity matrix that will be propagated\n", " parameter_settings.append(parameters_setup.gravitational_parameter(\"Earth\"))\n", " parameter_settings.append(parameters_setup.constant_drag_coefficient(\"Starlink-32101\"))\n", " \n", " # Create the parameters that will be estimated\n", " parameters_to_estimate = parameters_setup.create_parameter_set(parameter_settings, bodies)\n", " \n", " # Create the estimator\n", " estimator = estimation_analysis.Estimator(\n", " bodies,\n", " parameters_to_estimate,\n", " observation_settings_list,\n", " propagator_settings)\n", "\n", "# 3 - Perform the observations simulation\n", " \n", " # Simulate required observations\n", " simulated_observations = observations_setup.observations_wrapper.simulate_observations(\n", " [observation_simulation_settings],\n", " estimator.observation_simulators,\n", " bodies)\n", "\n", "# 4 - Define the Input Covariance\n", " \n", " # Define weighting of the observations in the inversion\n", " weights_per_observable = {observations.observations_processing.observation_parser(\n", " observable_models_setup.model_settings.one_way_instantaneous_doppler_type ): noise_level ** -2}\n", " simulated_observations.set_constant_weight_per_observation_parser( weights_per_observable )\n", "\n", " # Create input object for covariance analysis\n", " covariance_input = estimation_analysis.CovarianceAnalysisInput(\n", " simulated_observations)\n", " \n", " # Set methodological options\n", " covariance_input.define_covariance_settings(\n", " reintegrate_variational_equations=False)\n", "\n", " # Perform the covariance analysis\n", " covariance_output = estimator.compute_covariance(covariance_input)\n", " covariance_output_list.append(covariance_output)\n", "\n", " initial_covariance = covariance_output.covariance\n", " state_transition_interface = estimator.state_transition_interface\n", "\n", "# 5 - Propagate the Covariances and the Formal Errors\n", " \n", " #Propagate the covariancees and the formal errors\n", " propagated_covariances = estimation_analysis.propagate_covariance_split_output(initial_covariance,state_transition_interface,output_times)\n", " # Propagate formal errors over the course of the orbit\n", " propagated_formal_errors = estimation_analysis.propagate_formal_errors_split_output(\n", " initial_covariance=initial_covariance,\n", " state_transition_interface=state_transition_interface,\n", " output_times=output_times)\n", " # Split tuple into epochs and formal errors\n", " epochs = np.array(propagated_formal_errors[0])\n", " formal_errors = np.array(propagated_formal_errors[1])\n", " formal_errors_list.append(formal_errors)\n", "\n", "# 6 - Append Results\n", " \n", " covariances = np.array(propagated_covariances[1])\n", " covariances_list.append(covariances)\n", " print('... Done.\\n')\n", "\n", "print('All Done.\\n')\n", " " ] }, { "cell_type": "markdown", "id": "7de49dd4-e2f4-4e02-82db-248c7bc32270", "metadata": {}, "source": [ "## Results post-processing: Correlations and Formal Errors Time Evolution\n", "\n", "### Cartesian Coordinates\n", "Let's visualize the obtained propagated **cartesian** formal errors for each selected observation scenario. " ] }, { "cell_type": "code", "execution_count": 13, "id": "7d1256d3-0526-4773-a4e0-99fa4df47878", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig2, axs2 = plt.subplots(1, 3, figsize=(15, 5))\n", "times_plot = output_times / (24*3600)\n", "\n", "# Create the heatmaps and add colorbars\n", "axs2[0].plot(times_plot, formal_errors_list[0][:, 1], label=r\"$y$\", alpha = 0.6)\n", "axs2[0].plot(times_plot, formal_errors_list[0][:, 2], label=r\"$z$\", alpha = 0.5)\n", "axs2[0].plot(times_plot, formal_errors_list[0][:, 0], label=r\"$x$\", alpha = 1)\n", "axs2[0].axvline(observation_start_epoch_1/(24*3600), color = 'b', label = '1st Obs. Window', linestyle = '--')\n", "axs2[0].axvline(observation_end_epoch_1/(24*3600), color = 'b', linestyle = '--')\n", "axs2[0].set_title('Scenario 1')\n", "\n", "axs2[1].plot(times_plot, formal_errors_list[1][:, 1], label=r\"$y$\", alpha = 0.6)\n", "axs2[1].plot(times_plot, formal_errors_list[1][:, 2], label=r\"$z$\", alpha = 0.5)\n", "axs2[1].plot(times_plot, formal_errors_list[1][:, 0], label=r\"$x$\", alpha = 1)\n", "\n", "\n", "# Plot observation vertical lines\n", "axs2[1].axvline(observation_start_epoch_1/(24*3600), color = 'b', label = '1st Obs. Window', linestyle = '--')\n", "axs2[1].axvline(observation_end_epoch_1/(24*3600), color = 'b', linestyle = '--')\n", "axs2[1].axvline(observation_start_epoch_2/(24*3600), color = 'k', label = '2nd Obs. Window', linestyle = '--')\n", "axs2[1].axvline(observation_end_epoch_2/(24*3600), color = 'k', linestyle = '--')\n", "axs2[1].set_title('Scenario 2')\n", "\n", "axs2[2].plot(times_plot, formal_errors_list[2][:, 1], label=r\"$y$\", alpha = 0.6)\n", "axs2[2].plot(times_plot, formal_errors_list[2][:, 2], label=r\"$z$\", alpha = 0.5)\n", "axs2[2].plot(times_plot, formal_errors_list[2][:, 0], label=r\"$x$\",alpha = 1 )\n", "axs2[2].axvline(simulation_start_epoch/(24*3600), color = 'b', label = 'Full Obs. Window', linestyle = '--')\n", "axs2[2].axvline(simulation_end_epoch/(24*3600), color = 'b', linestyle = '--')\n", "axs2[2].set_title('Scenario 3')\n", "\n", "for ax in axs2.flat:\n", " ax.set(xlabel='Time [Days]', ylabel='Formal Errors in Cartesian Coordinates [m]')\n", " ax.legend(loc = 'upper right', fontsize = 9)\n", "# Hide x labels and tick labels for top plots and y ticks for right plots.\n", "for ax in axs2.flat:\n", " ax.set_aspect('auto')\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "57b8043f-f781-40fa-9a69-11ea4f00b44e", "metadata": {}, "source": [ "### RSW Coordinates\n", "Making use of the cool Tudat `frame_conversion` class, we are also able to express these results in the **RSW** coordinates.\n", "In order to do this, we need to retrieve the estimated cartesian states for `Starlink-32101` and rotate these into a the RSW reference frame, for each time. The retrieved (instantaneous) rotation matrix is then used to retrieve the covariance matrix in the new reference system. As above, this is done for each observation scenario. " ] }, { "cell_type": "code", "execution_count": 14, "id": "fa338460-f014-4490-8df1-e80c1fb2add1", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "estimation_states = []\n", "rot_matrix_list = []\n", "\n", "\n", "# Assuming estimation_states, rot_matrix_list, output_times, and converted_formal_errors_matrix_list are defined as provided\n", "\n", "# Initialize the converted formal errors matrix list\n", "converted_formal_errors_matrix_list = np.zeros([3, len(output_times), 6, 6])\n", "\n", "# Iterate through the scenarios and time steps\n", "for j in [0, 1, 2]:\n", " for i, time in enumerate(output_times):\n", " state_est = bodies.get('Starlink-32101').ephemeris.cartesian_state(time)\n", " rot_matrix = frame_conversion.inertial_to_rsw_rotation_matrix(state_est)\n", " full_rot_matrix = np.block([[rot_matrix, np.zeros([3,3])], [np.zeros([3,3]), rot_matrix]])\n", " cov = np.matrix(covariances_list[j][i])\n", " converted_formal_errors_matrix = full_rot_matrix @ cov @ full_rot_matrix.T\n", " converted_formal_errors_matrix_list[j, i] = converted_formal_errors_matrix\n", " \n", "# Plotting the (0, 0) element for each scenario\n", "fig3, axs3 = plt.subplots(1, 3, figsize=(15, 5))\n", "\n", "for j in range(3):\n", " axs3[j].plot(times_plot, np.abs(converted_formal_errors_matrix_list[j, :, 1, 1]), label=f\"Along-Track\", alpha=0.5)\n", " axs3[j].plot(times_plot, np.abs(converted_formal_errors_matrix_list[j, :, 2, 2]), label=f\"Cross-Track\", alpha=0.6)\n", " axs3[j].plot(times_plot, np.abs(converted_formal_errors_matrix_list[j, :, 0, 0]), label=f\"Radial\", alpha=0.8)\n", " axs3[j].set_xlabel('Time (years)')\n", " axs3[j].set_ylabel('Formal Errors in RSW')\n", " axs3[j].legend()\n", "\n", "# Plot observation vertical lines\n", "axs3[0].axvline(observation_start_epoch_1/(24*3600), color = 'b', label = 'Obs. Window', linestyle = '--')\n", "axs3[0].axvline(observation_end_epoch_1/(24*3600), color = 'b', linestyle = '--')\n", "axs3[0].set_title('Scenario 1')\n", "\n", "axs3[1].axvline(observation_start_epoch_1/(24*3600), color = 'b', label = '1st Obs. Window', linestyle = '--')\n", "axs3[1].axvline(observation_end_epoch_1/(24*3600), color = 'b', linestyle = '--')\n", "axs3[1].axvline(observation_start_epoch_2/(24*3600), color = 'k', label = '2nd Obs. Window', linestyle = '--')\n", "axs3[1].axvline(observation_end_epoch_2/(24*3600), color = 'k', linestyle = '--')\n", "axs3[1].set_title('Scenario 2')\n", "\n", "axs3[2].axvline(simulation_start_epoch/(24*3600), color = 'b', label = 'Obs. Window', linestyle = '--')\n", "axs3[2].axvline(simulation_end_epoch/(24*3600), color = 'b', linestyle = '--')\n", "axs3[2].set_title('Scenario 3')\n", "\n", "\n", "for ax in axs3.flat:\n", " ax.set(xlabel='Time [Days]', ylabel='Formal Errors in RSW Coordinates [m]')\n", " ax.legend(loc = 'upper right', fontsize = 9)\n", "# Hide x labels and tick labels for top plots and y ticks for right plots.\n", "for ax in axs3.flat:\n", " ax.set_aspect('auto')\n", " \n", "plt.tight_layout()\n", "plt.show()" ] } ], "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 }