{ "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).to_epoch()\n", "simulation_end_epoch = DateTime(2024, 9, 5).to_epoch()\n", "observation_start_epoch_1 = DateTime(2024, 8, 30).to_epoch()\n", "observation_end_epoch_1 = DateTime(2024, 9, 1).to_epoch()\n", "observation_start_epoch_2 = DateTime(2024, 9, 3).to_epoch()\n", "observation_end_epoch_2 = DateTime(2024, 9, 4).to_epoch()\n", "\n", "observation_start_epoch_3 = DateTime(2024, 8, 29).to_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_setup.ephemeris.sgp4(\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_setup.create_body_ephemeris(Starlink_tle, \"Starlink-32101\")\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`, `propagate_formal_errors`, 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", "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" ] } ], "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(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(\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(list(propagated_formal_errors.keys()))\n", " formal_errors = np.array(list(propagated_formal_errors.values()))\n", " formal_errors_list.append(formal_errors)\n", "\n", "# 6 - Append Results\n", " \n", " covariances = np.array(list(propagated_covariances.values()))\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", "# 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.sqrt(converted_formal_errors_matrix_list[j, :, 1, 1]), label=f\"Along-Track\", alpha=0.5)\n", " axs3[j].plot(times_plot, np.sqrt(converted_formal_errors_matrix_list[j, :, 2, 2]), label=f\"Cross-Track\", alpha=0.6)\n", " axs3[j].plot(times_plot, np.sqrt(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": "tudatpy_10", "language": "python", "name": "tudatpy_10" }, "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 }