{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Initial state estimation From Real MPC Observations\n", "\n", "## Objectives\n", "This example highlights a **simple orbit estimation routine** using **real angular observation data** from the [Minor Planet Center](https://www.minorplanetcenter.net/) (MPC). \n", "\n", "In the [DELFI-C3 - Parameter Estimation Example](full_estimation_example.ipynb), we saw how to set up and run an **orbit estimation routine**, and we did so by using **simulated observational data**. While simulating observational data is certainly useful for a variety of purposes, in real life we want to estimate an orbit starting from **real data** coming from radio or optical observations.\n", "\n", "We will estimate the initial state of [Eros](https://en.wikipedia.org/wiki/433_Eros), a near-Earth asteroid also visited by the NEAR Shoemaker probe in 1998. We will use the `Tudat BatchMPC` interface to retrieve and process the data. For a more in depth explanation of this interface we recommend first checking out the [Retrieving observation data from the Minor Planet Centre](retrieving_mpc_observation_data.ipynb) example. We will also briefly use the SBDBquery class which interfaces JPL's [Small Body DataBase (SBDB)](https://ssd.jpl.nasa.gov/tools/sbdb_lookup.html)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Import statements\n", "Let's start with importing the required modules. Most - if not all - of them (spice, dynamics, environment, propagation) are used quite extensively in pretty much all tudatpy examples.They will soon become your friends (if they haven't already!)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Tudat imports for propagation and estimation\n", "from tudatpy.interface import spice\n", "from tudatpy import dynamics\n", "from tudatpy.dynamics import 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", "\n", "# import MPC interface\n", "from tudatpy.data.mpc import BatchMPC\n", "\n", "# import SBDB interface\n", "from tudatpy.data.sbdb import SBDBquery\n", "\n", "# other useful modules\n", "import numpy as np\n", "import datetime\n", "\n", "import matplotlib.pyplot as plt\n", "from matplotlib.lines import Line2D\n", "import matplotlib.cm as cm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Preparing the environment and observations\n", "\n", "### Loading Spice Kernels.\n", "We use SPICE kernels to retrieve the ephemerides the planets as well as to verify our results for Eros. The ephemerides for Eros and other asteroids are loaded in with the `codes_300ast_20100725.bsp` kernel included with Tudat's standard kernels." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# SPICE KERNELS\n", "spice.load_standard_kernels()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Setting some constants\n", "Let's setup some constants that are used throughout the tutorial. The **MPC code** for Eros is 433. We also set a start and end date for our observations, the number of iterations for our estimation, a timestep for our integrator and a 1 month buffer to avoid interpolation errors in our analysis.\n", "\n", "We use a spice kernel to get a guess for our initial state and to check our estimation afterwards. The default spice kernel `codes_300ast_20100725.bsp` contains many popular asteroids, however they are not all identified by name (433 Eros is `\"Eros\"` but 16 Psyche is `\"2000016\"` etc.). To ensure this example works dynamically, for any single MPC code as input we use the SDBD to retrieve the name and SPK-ID used for the spice kernel.\n", "\n", "For our frame origin we use the Solar System Barycenter. The data from MPC is presented in the J2000 reference frame, currently BatchMPC does not support conversion to other reference frames and as such we match it in our environment. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Direct inputs:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "target_mpc_code = 433\n", "\n", "observations_start = datetime.datetime(2018, 1, 1)\n", "observations_end = datetime.datetime(2023, 7, 1)\n", "\n", "# number of iterations for our estimation\n", "number_of_pod_iterations = 6\n", "\n", "# timestep of 20 hours for our estimation\n", "timestep_global = 20 * 3600.0\n", "\n", "# 1 month time buffer used to avoid interpolation errors:\n", "time_buffer = 1 * 31 * 86400.0\n", "\n", "# define the frame origin and orientation.\n", "global_frame_origin = \"SSB\"\n", "global_frame_orientation = \"J2000\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Derived inputs:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SPK ID for 433 Eros is: Eros\n" ] } ], "source": [ "target_sbdb = SBDBquery(target_mpc_code)\n", "\n", "mpc_codes = [target_mpc_code] # the BatchMPC interface requires a list.\n", "target_spkid = target_sbdb.codes_300_spkid # the ID used by the\n", "target_name = target_sbdb.shortname # the ID used by the\n", "\n", "print(f\"SPK ID for {target_name} is: {target_spkid}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Retrieving the observations\n", "We retrieve the observation data using the `BatchMPC` interface. By default, all observation data is retrieved (even the first observations from Witt in 1898!). We filter to only include data between our start and end dates. The command `batch.summary()` gives us a nice summary of the observations we just retrieved. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", " Batch Summary:\n", "1. Batch includes 1 minor planets:\n", " ['433']\n", "2. Batch includes 3111 observations, including 1735 observations from space telescopes\n", "3. The observations range from 2018-05-01 03:22:18.336012 to 2023-06-27 00:37:43.680017\n", " In seconds TDB since J2000: 578417007.5214744 to 741098332.8642726\n", " In Julian Days: 2458239.64049 to 2460122.5262\n", "4. The batch contains observations from 54 observatories, including 4 space telescopes\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/lars/miniconda3/envs/tudatpy10/lib/python3.11/site-packages/tudatpy/data/mpc/mpc.py:866: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise in a future error of pandas. Value '['433' '433' '433' ... '433' '433' '433']' has dtype incompatible with int64, please explicitly cast to a compatible dtype first.\n", " obs.loc[:, \"number\"] = obs.number.astype(str)\n" ] } ], "source": [ "batch = BatchMPC()\n", "batch.get_observations(mpc_codes)\n", "batch.filter(\n", " epoch_start=observations_start,\n", " epoch_end=observations_end,\n", ")\n", "\n", "batch.summary()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Other than **Earth-based telescopes**, our batch also includes observations from **space telescopes**.\n", "Let's check that out. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Summary of space telescopes in batch:\n", " Code Name count\n", "274 275 Non-geocentric Occultation Observation 2.0\n", "1232 C51 WISE 111.0\n", "1238 C57 TESS 1620.0\n", "1240 C59 Yangwang-1 2.0\n" ] } ], "source": [ "print(\"Summary of space telescopes in batch:\")\n", "print(batch.observatories_table(only_space_telescopes=True))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can see, observations by WISE, TESS and Yangwang, as well as some non-geocentric Occulation Observations are found. We can exemplary plot the initial and final observations of both TESS and WISE." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Initial and Final Observations by WISE:\n", " number epochUTC RA DEC\n", "10833 433 2018-07-25 00:09:44.063981 0.468337 0.388395\n", "13848 433 2023-05-15 12:31:37.344004 5.690128 -0.311711\n" ] } ], "source": [ "obs_by_WISE = (\n", " batch.table.query(\"observatory == 'C51'\")\n", " .loc[:, [\"number\", \"epochUTC\", \"RA\", \"DEC\"]]\n", " .iloc[[0, -1]]\n", ")\n", "\n", "print(\"\\nInitial and Final Observations by WISE:\")\n", "print(obs_by_WISE)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While the observations from space telescopes appear to be useful, including them requires setting up the dynamics for the spacecraft, which is too advanced for this tutorial. Space-based observations will therefore be excluded later on in this example. \n", "\n", "Also note that if, for any reason, you would like to filter out some other observations, you can do so by excluding the observatories with the `.filter()` method, specifying their codes (for instance, use `.filter('C59')` will filter out observations from Yangwang-1). Note that all observations give Right Ascension (RA) and Declination (DEC) in **radians**." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set up the environment\n", "We now set up the environment, including the bodies to use, the reference frame and frame origin. The ephemerides for all major planets as well as the Earth's Moon are retrieved using spice. \n", "\n", "BatchMPC will automatically generate the body object for Eros, but we still need to specify the bodies to propagate and their central bodies. We can retrieve the list from the BatchMPC object." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# List the bodies for our environment\n", "bodies_to_create = [\n", " \"Sun\",\n", " \"Mercury\",\n", " \"Venus\",\n", " \"Earth\",\n", " \"Moon\",\n", " \"Mars\",\n", " \"Jupiter\",\n", " \"Saturn\",\n", " \"Uranus\",\n", " \"Neptune\",\n", "]\n", "\n", "# Create system of bodies\n", "body_settings = environment_setup.get_default_body_settings(\n", " bodies_to_create, global_frame_origin, global_frame_orientation\n", ")\n", "\n", "bodies = environment_setup.create_system_of_bodies(body_settings)\n", "\n", "# Retrieve Eros' body name from BatchMPC and set its centre to enable its propagation\n", "bodies_to_propagate = batch.MPC_objects\n", "central_bodies = [global_frame_origin]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Convert the observations to Tudat\n", "Now that our system of bodies is ready, we can retrieve the observation collection from the observations batch using the `to_tudat()` method. By setting the `included_satellites` to `None`, we filter out all space-based observations. From the **observation collection** we can also retrieve **observation links**. As you already know from [Covariance estimation example](covariance_estimated_parameters.ipynb), we use the links to define our **observations settings**. This is also where you would add the **bias settings**. For the purpose of this example, we will use the plain **angular position observation settings**, which can process observations with Right Ascension and Declination. We can also retrieve the times for the first and final observations from the batch object in seconds since J2000 TDB, which is what tudat uses internally. We here add our buffer, set previously, to avoid interpolation errors down the line." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/lars/miniconda3/envs/tudatpy10/lib/python3.11/site-packages/tudatpy/data/mpc/mpc.py:147: FutureWarning: The previous implementation of stack is deprecated and will be removed in a future version of pandas. See the What's New notes for pandas 2.1.0 for details. Specify future_stack=True to adopt the new implementation and silence this warning.\n", " bias_dataframe = bias_dataframe.stack(level=0)\n" ] } ], "source": [ "# Transform the MPC observations into a tudat compatible format.\n", "# note that we explicitly exclude all satellite observations in this step by setting included satellites to None.\n", "observation_collection = batch.to_tudat(bodies=bodies, included_satellites=None)\n", "\n", "# set create angular_position settings for each link in the list.\n", "observation_settings_list = list()\n", "link_list = list(\n", " observation_collection.get_link_definitions_for_observables(\n", " observable_type=observable_models_setup.model_settings.angular_position_type\n", " )\n", ")\n", "\n", "for link in link_list:\n", " # add optional bias settings here\n", " observation_settings_list.append(\n", " observable_models_setup.model_settings.angular_position(link, bias_settings=None)\n", " )\n", "# Retrieve the first and final observation epochs and add the buffer\n", "epoch_start_nobuffer = batch.epoch_start\n", "epoch_end_nobuffer = batch.epoch_end\n", "\n", "epoch_start_buffer = epoch_start_nobuffer - time_buffer\n", "epoch_end_buffer = epoch_end_nobuffer + time_buffer" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating the acceleration settings\n", "In order to estimate the orbit of Eros, we need to **propagate its initial state**. The propagation can only be performed upon definition of a **dynamical model**. Thus, we need to define the settings of the forces acting on Eros, which will determine its trajectory. We will include:\n", "\n", "* **point mass gravity accelerations** for each of the bodies defined before,\n", "* Schwarzschild **relativistic corrections** for the Sun.\n", "\n", "With these accelerations we can generate our **acceleration model for the propagation**. A more realistic acceleration model will yield better results but this is outside the scope of this example. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Define accelerations\n", "accelerations = {\n", " \"Sun\": [\n", " propagation_setup.acceleration.point_mass_gravity(),\n", " propagation_setup.acceleration.relativistic_correction(use_schwarzschild=True),\n", " ],\n", " \"Mercury\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Venus\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Earth\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Moon\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Mars\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Jupiter\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Saturn\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Uranus\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Neptune\": [propagation_setup.acceleration.point_mass_gravity()],\n", "}\n", "\n", "# Set up the accelerations settings for each body, in this case only Eros\n", "acceleration_settings = {}\n", "for body in batch.MPC_objects:\n", " acceleration_settings[str(body)] = accelerations\n", "\n", "# create the acceleration models.\n", "acceleration_models = propagation_setup.create_acceleration_models(\n", " bodies, acceleration_settings, bodies_to_propagate, central_bodies\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Retrieving an initial guess for Eros' position\n", "As we mentioned above, we need to propagate an initial state. We use the `SPICE` ephemeris to retrieve a 'benchmark' initial state for Eros at the epoch at the propagation start epoch. We can also use this initial state to set our **initial guess for the estimation**. To define the initial guess, we add a **random uniform offset** of +/- 1 million kilometers for the position and 100 m/s for the velocity. Adding this random offset to the `SPICE` initial state should not have a strong influence on the final results, and it is added in order to keep the tutorial representative (in real-world cases we might not have such a good initial guess!)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Error between the real initial state and our initial guess:\n", "[ 2.36432494e+07 9.00927393e+08 -7.11680775e+08 8.97298894e+01\n", " -3.76337096e+01 -1.53347102e+01]\n" ] } ], "source": [ "# benchmark state for later comparison retrieved from SPICE\n", "initial_states = spice.get_body_cartesian_state_at_epoch(\n", " target_spkid,\n", " global_frame_origin,\n", " global_frame_orientation,\n", " \"NONE\",\n", " epoch_start_buffer,\n", ")\n", "\n", "# Add random offset for initial guess\n", "rng = np.random.default_rng(seed=1)\n", "\n", "initial_position_offset = 1e6 * 1000\n", "initial_velocity_offset = 100\n", "\n", "initial_guess = initial_states.copy()\n", "initial_guess[0:3] += (2 * rng.random(3) - 1) * initial_position_offset\n", "initial_guess[3:6] += (2 * rng.random(3) - 1) * initial_velocity_offset\n", "\n", "print(\"Error between the real initial state and our initial guess:\")\n", "print(initial_guess - initial_states)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Finalising the propagation setup\n", "For the integrator we use the fixed timestep RKF-7(8) setting our initial time to the time of the batch's final observation - buffer. We then set the termination to stop at the time of the batch's oldest observation plus buffer. These two settings are then the final pieces to create our propagation settings. " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Create numerical integrator settings\n", "integrator_settings = propagation_setup.integrator.runge_kutta_variable_step_size(\n", " epoch_start_buffer,\n", " timestep_global,\n", " propagation_setup.integrator.CoefficientSets.rkf_78,\n", " timestep_global,\n", " timestep_global,\n", " 1.0,\n", " 1.0,\n", ")\n", "\n", "# Terminate at the time of oldest observation\n", "termination_condition = propagation_setup.propagator.time_termination(epoch_end_buffer)\n", "\n", "\n", "# Create propagation settings\n", "propagator_settings = propagation_setup.propagator.translational(\n", " central_bodies=central_bodies,\n", " acceleration_models=acceleration_models,\n", " bodies_to_integrate=bodies_to_propagate,\n", " initial_states=initial_guess,\n", " initial_time=epoch_start_buffer,\n", " integrator_settings=integrator_settings,\n", " termination_settings=termination_condition,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setting Up the estimation\n", "With the observation collection, the environment and propagations settings ready we can now begin setting up our estimation. \n", "In this example **we will simply estimate the position of Eros** and as such only include an **initial states parameter**." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Setup parameters settings to propagate the state transition matrix\n", "parameter_settings = parameters_setup.initial_states(\n", " propagator_settings, bodies\n", ")\n", "\n", "# Create the parameters that will be estimated\n", "parameters_to_estimate = parameters_setup.create_parameter_set(\n", " parameter_settings, bodies, propagator_settings\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `Estimator` object collects the environment, observation settings and propagation settings. We also create an `EstimationInput` object and provide it our observation collection retrieved from `.to_tudat()`. Our maximum iterations steps was set to 6." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Set up the estimator\n", "estimator = estimation_analysis.Estimator(\n", " bodies=bodies,\n", " estimated_parameters=parameters_to_estimate,\n", " observation_settings=observation_settings_list,\n", " propagator_settings=propagator_settings,\n", " integrate_on_creation=True,\n", ")\n", "\n", "# provide the observation collection as input, and limit number of iterations for estimation.\n", "pod_input = estimation_analysis.EstimationInput(\n", " observations_and_times=observation_collection,\n", " convergence_checker=estimation.estimation_analysis.estimation_convergence_checker(\n", " maximum_iterations=number_of_pod_iterations,\n", " ),\n", ")\n", "\n", "# Set methodological options\n", "pod_input.define_estimation_settings(reintegrate_variational_equations=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Performing the estimation\n", "\n", "With everything set up, we can now perform the estimation. " ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calculating residuals and partials 2752\n", "Current residual: 0.0366227\n", "Parameter update-1.05483e+08 -9.97326e+08 8.52018e+08 -88.1483 42.5672 13.0772\n", "Calculating residuals and partials 2752\n", "Current residual: 0.00240795\n", "Parameter update 8.16842e+07 9.60257e+07 -1.39888e+08 -1.56848 -4.9121 2.2151\n", "Calculating residuals and partials 2752\n", "Current residual: 6.74622e-06\n", "Parameter update 157111 389328 -476329 -0.0128165 -0.0216721 0.0434679\n", "Calculating residuals and partials 2752\n", "Current residual: 1.73663e-06\n", "Parameter update -4.9632 -1.9658 -1.30628 3.15265e-07 -4.28622e-07 -1.5675e-07\n", "Calculating residuals and partials 2752\n", "Current residual: 1.73663e-06\n", "Parameter update 0.00981148 -0.000558773 0.00136084 -8.53343e-10 4.94558e-10 9.13372e-11\n", "Calculating residuals and partials 2752\n", "Current residual: 1.73663e-06\n", "Maximum number of iterations reached\n", "Parameter update-0.000216439 5.18828e-05 -0.000278331 5.0052e-11 -6.74538e-11 -1.69118e-11\n", "Final residual: 1.73663e-06\n" ] } ], "source": [ "# Perform the estimation\n", "pod_output = estimator.perform_estimation(pod_input)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Looking at the **residual values** after each iteration, the estimator appears to converge within ~4 steps. Lets check how close our **initial state guess** and the **final estimate for the initial state** are, compared to the benchmark initial state." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "433 Eros initial guess radial error to spice: 1148354.78 km\n", "433 Eros final radial error to spice: 32.24 km\n" ] } ], "source": [ "# retrieve the estimated initial state.\n", "results_final = pod_output.parameter_history[:, -1]\n", "\n", "vector_error_initial = (np.array(initial_guess) - initial_states)[0:3]\n", "error_magnitude_initial = np.sqrt(np.square(vector_error_initial).sum()) / 1000\n", "\n", "vector_error_final = (np.array(results_final) - initial_states)[0:3]\n", "error_magnitude_final = np.sqrt(np.square(vector_error_final).sum()) / 1000\n", "\n", "print(\n", " f\"{target_name} initial guess radial error to spice: {round(error_magnitude_initial, 2)} km\"\n", ")\n", "print(\n", " f\"{target_name} final radial error to spice: {round(error_magnitude_final, 2)} km\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualising the results\n", "\n", "### Change in residuals per iteration\n", "We want to visualise the residuals, splitting them between Right Ascension and Declination. Internally, `concatenated_observations` orders the observations alternating RA, DEC, RA, DEC,... This allows us to map the colors accordingly by taking every other item in the `residual_history`/`concatenated_observations`, i.e. by slicing [::2]." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "residual_history = pod_output.residual_history\n", "\n", "# Number of columns and rows for our plot\n", "number_of_columns = 2\n", "\n", "number_of_rows = (\n", " int(number_of_pod_iterations / number_of_columns)\n", " if number_of_pod_iterations % number_of_columns == 0\n", " else int((number_of_pod_iterations + 1) / number_of_columns)\n", ")\n", "\n", "fig, axs = plt.subplots(\n", " number_of_rows,\n", " number_of_columns,\n", " figsize=(9, 3.5 * number_of_rows),\n", " sharex=True,\n", " sharey=False,\n", ")\n", "\n", "# We cheat a little to get an approximate year out of our times (which are in seconds since J2000)\n", "residual_times = (\n", " np.array(observation_collection.concatenated_times) / (86400 * 365.25) + 2000\n", ")\n", "\n", "\n", "# plot the residuals, split between RA and DEC types\n", "for idx, ax in enumerate(fig.get_axes()):\n", " ax.grid()\n", " # we take every second\n", " ax.scatter(\n", " residual_times[::2],\n", " residual_history[\n", " ::2,\n", " idx,\n", " ],\n", " marker=\"+\",\n", " s=60,\n", " label=\"Right Ascension\",\n", " )\n", " ax.scatter(\n", " residual_times[1::2],\n", " residual_history[\n", " 1::2,\n", " idx,\n", " ],\n", " marker=\"+\",\n", " s=60,\n", " label=\"Declination\",\n", " )\n", " ax.set_ylabel(\"Observation Residual [rad]\")\n", " ax.set_title(\"Iteration \" + str(idx + 1))\n", "\n", "plt.tight_layout()\n", "\n", "# add the year label for the x-axis\n", "for col in range(number_of_columns):\n", " axs[int(number_of_rows - 1), col].set_xlabel(\"Year\")\n", "\n", "axs[0, 0].legend()\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Residuals Correlations Matrix\n", "Lets check out the correlation of the estimated parameters." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calculating residuals and partials 2752\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Correlation can be retrieved using the CovarianceAnalysisInput class:\n", "covariance_input = estimation_analysis.CovarianceAnalysisInput(observation_collection)\n", "covariance_output = estimator.compute_covariance(covariance_input)\n", "\n", "correlations = covariance_output.correlations\n", "estimated_param_names = [\"x\", \"y\", \"z\", \"vx\", \"vy\", \"vz\"]\n", "\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(9, 7))\n", "\n", "im = ax.imshow(correlations, cmap=cm.RdYlBu_r, vmin=-1, vmax=1)\n", "\n", "ax.set_xticks(np.arange(len(estimated_param_names)), labels=estimated_param_names)\n", "ax.set_yticks(np.arange(len(estimated_param_names)), labels=estimated_param_names)\n", "\n", "# add numbers to each of the boxes\n", "for i in range(len(estimated_param_names)):\n", " for j in range(len(estimated_param_names)):\n", " text = ax.text(\n", " j, i, round(correlations[i, j], 2), ha=\"center\", va=\"center\", color=\"w\"\n", " )\n", "\n", "cb = plt.colorbar(im)\n", "\n", "ax.set_xlabel(\"Estimated Parameter\")\n", "ax.set_ylabel(\"Estimated Parameter\")\n", "\n", "fig.suptitle(f\"Correlations for estimated parameters for {target_name}\")\n", "\n", "fig.set_tight_layout(True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Orbit error vs spice over time\n", "Next, lets take a look at the error of the orbit over time, using spice as a reference.\n", "\n", "We saw in the residuals graph that there are two large gaps in observations, for 2022 and around Jan 2020. Lets collect those gaps and overlay them on to our error plot." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Largest gap = 1.263 years\n", "[(2019.7692566946516, 2020.46532939287), (2021.9181437117866, 2023.1810429863324)]\n" ] } ], "source": [ "# lets get ranges for all gaps larger than 6 months:\n", "gap_in_months = 6\n", "\n", "gaps = np.abs(np.diff(sorted(residual_times)))\n", "num_gaps = (\n", " gaps > (gap_in_months / 12)\n", ").sum() # counts the number of gaps larger than 0.5 years\n", "indices_of_largest_gaps = np.argsort(gaps)[-num_gaps:]\n", "\n", "# (start, end) for each of the gaps\n", "gap_ranges = [\n", " (sorted(residual_times)[idx - 1], sorted(residual_times)[idx + 1])\n", " for idx in indices_of_largest_gaps\n", "]\n", "\n", "print(f\"Largest gap = {round(max(gaps), 3)} years\")\n", "print(gap_ranges)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Now lets plot the orbit error\n", "fig, ax = plt.subplots(1, 1, figsize=(9, 5))\n", "\n", "# show areas where there are no observations:\n", "for i, gap in enumerate(gap_ranges):\n", " ax.axvspan(\n", " xmin=gap[0],\n", " xmax=gap[1],\n", " color=\"red\",\n", " alpha=0.1,\n", " label=\"Large gap in observations\" if i == 0 else None,\n", " )\n", "\n", "spice_states = []\n", "estimation_states = []\n", "\n", "# retrieve the states for a list of times.\n", "times = np.linspace(epoch_start_nobuffer, epoch_end_nobuffer, 1000)\n", "times_plot = times / (86400 * 365.25) + 2000 # approximate\n", "for time in times:\n", " # from spice\n", " state_spice = spice.get_body_cartesian_state_at_epoch(\n", " target_spkid, central_bodies[0], global_frame_orientation, \"NONE\", time\n", " )\n", " spice_states.append(state_spice)\n", "\n", " # from estimation\n", " state_est = bodies.get(str(target_mpc_code)).ephemeris.cartesian_state(time)\n", " estimation_states.append(state_est)\n", "\n", "# Error in kilometers\n", "error = (np.array(spice_states) - np.array(estimation_states)) / 1000\n", "\n", "# plot\n", "ax.plot(times_plot, error[:, 0], label=\"x\")\n", "ax.plot(times_plot, error[:, 1], label=\"y\")\n", "ax.plot(times_plot, error[:, 2], label=\"z\")\n", "\n", "ax.grid()\n", "ax.legend(ncol=1)\n", "\n", "plt.tight_layout()\n", "\n", "ax.set_ylabel(\"Cartesian Error [km]\")\n", "ax.set_xlabel(\"Year\")\n", "\n", "fig.suptitle(f\"Error vs SPICE over time for {target_name}\")\n", "fig.set_tight_layout(True)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Please note that a lack of observations in an area of time does not necessarily result in a bad fit in that area. Lets look at the observatories next." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Final residuals highlighted per observatory\n", "This plot shows the final iteration of the residuals, highlighting the 10 observatories with the most observations." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# 10 observatories with most observations\n", "num_observatories = 10\n", "\n", "final_residuals = np.array(residual_history[:, -1])\n", "# if you would like to check the iteration 1 residuals, use:\n", "# final_residuals = np.array(residual_history[:, 0])" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# This piece of code collects the 10 largest observatories\n", "observatory_names = (\n", " batch.observatories_table(exclude_space_telescopes=True)\n", " .sort_values(\"count\", ascending=False)\n", " .iloc[0:num_observatories]\n", " .set_index(\"Code\")\n", ")\n", "top_observatories = observatory_names.index.tolist()\n", "\n", "# This piece of code creates a `concatenated_receiving_observatories` map\n", "# to identify the observatories by their MPC code instead of an internally used id\n", "residuals_observatories = observation_collection.concatenated_link_definition_ids\n", "unique_observatories = set(residuals_observatories)\n", "\n", "observatory_link_to_mpccode = {\n", " idx: observation_collection.link_definition_ids[idx][\n", " observable_models_setup.links.receiver\n", " ].reference_point\n", " for idx in unique_observatories\n", "}\n", "\n", "# the resulting map (MPC code for each item in the residuals_history):\n", "concatenated_receiving_observatories = np.array(\n", " [observatory_link_to_mpccode[idx] for idx in residuals_observatories]\n", ")\n", "\n", "# mask for the observatories not in top 10:\n", "mask_not_top = [\n", " (False if observatory in top_observatories else True)\n", " for observatory in concatenated_receiving_observatories\n", "]\n", "\n", "# get the number of observations by the other observatories\n", "# (divide by two because the observations are concatenated RA,DEC in this list)\n", "n_obs_not_top = int(sum(mask_not_top) / 2)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axs = plt.subplots(2, 1, figsize=(13, 9))\n", "\n", "# Plot remaining observatories first\n", "# RA\n", "axs[0].scatter(\n", " residual_times[mask_not_top][::2],\n", " final_residuals[mask_not_top][::2],\n", " marker=\".\",\n", " s=30,\n", " label=f\"{len(unique_observatories) - num_observatories} Other Observatories | {n_obs_not_top} obs\",\n", " color=\"lightgrey\",\n", ")\n", "# DEC\n", "axs[1].scatter(\n", " residual_times[mask_not_top][1::2],\n", " final_residuals[mask_not_top][1::2],\n", " marker=\".\",\n", " s=30,\n", " label=f\"{len(unique_observatories) - num_observatories} Other Observatories | {n_obs_not_top} obs\",\n", " color=\"lightgrey\",\n", ")\n", "\n", "# plots the highlighted top 10 observatories\n", "for observatory in top_observatories:\n", " name = f\"{observatory} | {observatory_names.loc[observatory].Name} | {int(observatory_names.loc[observatory]['count'])} obs\"\n", " axs[0].scatter(\n", " residual_times[concatenated_receiving_observatories == observatory][::2],\n", " final_residuals[concatenated_receiving_observatories == observatory][::2],\n", " marker=\".\",\n", " s=30,\n", " label=name,\n", " zorder=100,\n", " )\n", " axs[1].scatter(\n", " residual_times[concatenated_receiving_observatories == observatory][1::2],\n", " final_residuals[concatenated_receiving_observatories == observatory][1::2],\n", " marker=\".\",\n", " s=30,\n", " label=name,\n", " zorder=100,\n", " )\n", "\n", "\n", "axs[1].legend(ncols=3, loc=\"upper center\", bbox_to_anchor=(0.47, -0.15))\n", "\n", "for ax in fig.get_axes():\n", " ax.grid()\n", " ax.set_ylabel(\"Observation Residual [rad]\")\n", " ax.set_xlabel(\"Year\")\n", " # this step hides a few outliers (~3 observations)\n", " ax.set_ylim(-1.5e-5, 1.5e-5)\n", "\n", "axs[0].set_title(\"Right Ascension\")\n", "axs[1].set_title(\"Declination\")\n", "\n", "fig.suptitle(f\"Final Iteration residuals for {target_name}\")\n", "fig.set_tight_layout(True)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Residual Boxplots per observatory\n", "Let's visualise these residuals as boxplots as well, again splitting for right ascension and declination. Note that some low level Matplotlib is used for this plot. Consider using the simplified [seaborn boxplot](https://seaborn.pydata.org/generated/seaborn.boxplot.html) implementation if this format is relevant to your use case." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "num_observatories = 6\n", "\n", "data_per_observatory_list_RA = []\n", "data_per_observatory_list_DEC = []\n", "names = []\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(10, 1.2 * num_observatories))\n", "\n", "# we retrieve the observatory names again\n", "observatory_names_box = (\n", " batch.observatories_table(exclude_space_telescopes=True)\n", " .set_index(\"Code\")\n", " .sort_values(\"count\", ascending=False)\n", " .iloc[0:num_observatories]\n", ")\n", "\n", "top_observatories_box = observatory_names_box.index.tolist()\n", "\n", "# retrieve the data for RA and DEC separately\n", "for observatory in top_observatories_box[::-1]:\n", " name = f\"{observatory} | {observatory_names_box.loc[observatory].Name} | {int(observatory_names_box.loc[observatory]['count'])} obs\"\n", " names.append(name)\n", " data_per_observatory_list_RA.append(\n", " final_residuals[concatenated_receiving_observatories == observatory][::2]\n", " )\n", "\n", " data_per_observatory_list_DEC.append(\n", " final_residuals[concatenated_receiving_observatories == observatory][1::2]\n", " )\n", "\n", "# positioning the boxes\n", "pos = (np.arange(0, len(top_observatories_box)) + 1) * 10\n", "widths = 2.8\n", "offset = 1.6\n", "\n", "# box colors\n", "RA_color = \"tab:blue\"\n", "DEC_color = \"tab:orange\"\n", "\n", "# boxes for RA and DEC\n", "RAplots = ax.boxplot(\n", " x=data_per_observatory_list_RA,\n", " vert=False,\n", " positions=pos + offset,\n", " widths=widths,\n", " patch_artist=False,\n", " capprops=dict(color=RA_color),\n", " whiskerprops=dict(color=RA_color),\n", " flierprops=dict(color=RA_color, markeredgecolor=RA_color),\n", " medianprops=dict(color=RA_color),\n", ")\n", "DECplots = ax.boxplot(\n", " x=data_per_observatory_list_DEC,\n", " vert=False,\n", " positions=pos - offset,\n", " widths=widths,\n", " patch_artist=False,\n", " capprops=dict(color=DEC_color),\n", " whiskerprops=dict(color=DEC_color),\n", " flierprops=dict(color=DEC_color, markeredgecolor=DEC_color),\n", " medianprops=dict(color=DEC_color),\n", ")\n", "# custom ticks\n", "ax.set_yticks(ticks=pos, labels=names)\n", "\n", "# custom legend\n", "place_holder_lines = [\n", " Line2D([0], [0], color=RA_color, lw=4),\n", " Line2D([0], [0], color=DEC_color, lw=4),\n", "]\n", "ax.legend(place_holder_lines, [\"Right Ascension\", \"Declination\"])\n", "\n", "ax.grid()\n", "ax.set_xlabel(\"Observation Residual [rad]\")\n", "\n", "fig.suptitle(\n", " f\"Residual boxplots of the {num_observatories} observatories with the most observations for {target_name}\"\n", ")\n", "\n", "# reducing whitespace\n", "ax.set_ylim(10 - 4, int(len(top_observatories_box) * 10) + 4)\n", "\n", "fig.set_tight_layout(True)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Histograms per observatory\n", "Finally, lets get the residual histogram for the top 6 observatories, splitting again for right ascension and declination." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "num_observatories = 6\n", "nbins = 20\n", "number_of_columns = 2\n", "transparency = 0.6" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "number_of_rows = (\n", " int(num_observatories / number_of_columns)\n", " if num_observatories % number_of_columns == 0\n", " else int((num_observatories + 1) / number_of_columns)\n", ")\n", "\n", "# we retrieve the observatory names again\n", "observatory_names_hist = (\n", " batch.observatories_table(exclude_space_telescopes=True)\n", " .set_index(\"Code\")\n", " .sort_values(\"count\", ascending=False)\n", " .iloc[0:num_observatories]\n", ")\n", "\n", "top_observatories_hist = observatory_names_hist.index.tolist()\n", "\n", "\n", "fig, axs = plt.subplots(\n", " number_of_rows,\n", " number_of_columns,\n", " figsize=(4.5 * number_of_columns, 3 * number_of_rows),\n", ")\n", "\n", "axs = axs.flatten()\n", "\n", "for idx, observatory in enumerate(top_observatories_hist):\n", " name = f\"{observatory} | {observatory_names_hist.loc[observatory].Name} | {int(observatory_names_hist.loc[observatory]['count'])} obs\"\n", "\n", " axs[idx].hist(\n", " final_residuals[concatenated_receiving_observatories == observatory][0::2],\n", " bins=nbins,\n", " alpha=transparency + 0.05,\n", " label=\"Right Ascension\",\n", " )\n", " axs[idx].hist(\n", " final_residuals[concatenated_receiving_observatories == observatory][1::2],\n", " bins=nbins,\n", " alpha=transparency,\n", " label=\"Declination\",\n", " )\n", "\n", " axs[idx].grid()\n", " axs[idx].set_title(name)\n", " axs[idx].set_ylabel(\"Number of Observations\")\n", " axs[idx].set_xlabel(\"Observation Residual [rad]\")\n", "\n", "axs[0].legend()\n", "\n", "fig.suptitle(\n", " f\"Final residual histograms of the {num_observatories} observatories with the most observations for {target_name}\"\n", ")\n", "fig.set_tight_layout(True)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That's it for this tutorial! The final estimation result is quite close to spice at times, but there is clearly plenty of room for improvement in both the **dynamical model** and the **estimation settings**. Consider for example adding weights and biases on observations and links, as well as improved integrator settings and perturbations. \n", "\n", "If you wanna get more hands-on experience, consider rerunning the script for some other object by changing the `target_mpc_code` variable and seeing how the results change." ] } ], "metadata": { "kernelspec": { "display_name": "tudatpy10", "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 }