diff --git a/estimation/estimation_with_mpc.ipynb b/estimation/estimation_with_mpc.ipynb new file mode 100644 index 0000000..b9af7f6 --- /dev/null +++ b/estimation/estimation_with_mpc.ipynb @@ -0,0 +1,1250 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Initial state estimation with Minor Planet Center Observations\n", + "Copyright (c) 2010-2023, Delft University of Technology. All rights reserved. This file is part of the Tudat. Redistribution and use in source and binary forms, with or without modification, are permitted exclusively under the terms of the Modified BSD license. You should have received a copy of the license with this file. If not, please or visit: http://tudat.tudelft.nl/LICENSE.\n", + "\n", + "## Context\n", + "This example highlights a simple orbit estimation routine using real, angular observation data from the [Minor Planet Center](https://www.minorplanetcenter.net/) (MPC). We will estimate the initial state of [Eros](https://en.wikipedia.org/wiki/433_Eros) a near-Earth asteroid 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](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/retrieving_mpc_observation_data.html) 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" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Tudat imports for propagation and estimation\n", + "from tudatpy.kernel.interface import spice\n", + "from tudatpy.kernel import numerical_simulation\n", + "from tudatpy.kernel.numerical_simulation import environment_setup\n", + "from tudatpy.kernel.numerical_simulation import propagation_setup\n", + "from tudatpy.kernel.numerical_simulation import estimation, estimation_setup\n", + "from tudatpy.kernel.numerical_simulation.estimation_setup import observation\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": 3, + "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 Barycentre. 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": 4, + "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\n", + "\n", + "# 1 month time buffer used to avoid interpolation errors:\n", + "time_buffer = 1 * 31 * 86400\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": 5, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Batch Summary:\n", + "1. Batch includes 1 minor planets:\n", + " ['433']\n", + "2. Batch includes 3095 observations, including 1733 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 53 observatories, including 3 space telescopes\n", + "\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": [ + "Our batch includes many observations from space telescopes, lets take a closer look at that data." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary of space telescopes in batch:\n", + " Code Name count\n", + "1225 C51 WISE 111.0\n", + "1231 C57 TESS 1620.0\n", + "1232 C59 Yangwang-1 2.0\n", + "\n", + "Initial and Final Observations by WISE:\n", + " number epochUTC RA DEC\n", + "10523 433 2018-07-25 00:09:44.063981 0.468337 0.388395\n", + "13536 433 2023-05-15 12:31:37.344004 5.690128 -0.311711\n" + ] + } + ], + "source": [ + "print(\"Summary of space telescopes in batch:\")\n", + "print(batch.observatories_table(only_space_telescopes=True))\n", + "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 WISE appear to be useful, including them requires setting up the dynamics for the WISE spacecraft which is too advanced for this tutorial and its observations will be excluded later on in this example. The observations can also be filtered out explicitly by excluding the observatories with the .filter() method, specifying their codes (C57 etc.). Note that all the observations are given in an angular format, 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 epherides 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 propapgation\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. Note that by setting the included_satellites to `None`, space telescope observations are filtered out. From the observation collection we can also retrieve observation links. We use the links to define our observations settings this is where you would also add bias settings. For the purpose of this example, we will keep it simple and use the plain angular position 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": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Transform the MPC observations into a tudat compatible format.\n", + "# note that we explicitly exlude 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=observation.angular_position_type\n", + " )\n", + ")\n", + "\n", + "for link in link_list:\n", + " # add optional bias settings here\n", + " observation_settings_list.append(\n", + " observation.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", + "Eros will be propagated and as such we need to define the settings of the forces acting on it. We will include point mass gravity accelerations for each of the bodies defined before, as well as Schwarzschild relativistic corrections for the Sun. 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", + "We use the SPICE ephemeris to retrieve a 'benchmark' initial state for Eros at the first epoch. We can also use this initial state as our initial guess for the estimation. We add a random uniform offset of +/- 1 million kilometers for the position and 100 m/s for the velocity. Adding this random offset should not have a strong influence on the final results, it is added in 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", + "[ 8.67054018e+08 1.04436121e+08 6.08103526e+07 1.62748932e+01\n", + " -1.78045513e+01 3.71089295e+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", + "np.random.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 * np.random.rand(3) - 1) * initial_position_offset\n", + "initial_guess[3:6] += (2 * np.random.rand(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.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", + "\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": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Setup parameters settings to propagate the state transition matrix\n", + "parameter_settings = estimation_setup.parameter.initial_states(\n", + " propagator_settings, bodies\n", + ")\n", + "\n", + "# Create the parameters that will be estimated\n", + "parameters_to_estimate = estimation_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 previously set to 6." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up the estimator\n", + "estimator = numerical_simulation.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.EstimationInput(\n", + " observations_and_times=observation_collection,\n", + " convergence_checker=estimation.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 2724\n", + "Current residual: 0.0651006\n", + "Parameter update -1.1154e+09 -3.74729e+08 1.45194e+08 -13.3965 29.5008 -46.729\n", + "Calculating residuals and partials 2724\n", + "Current residual: 0.00715581\n", + "Parameter update 2.4508e+08 2.66846e+08 -2.02303e+08 -2.67251 -11.5244 9.24734\n", + "Calculating residuals and partials 2724\n", + "Current residual: 4.44001e-05\n", + "Parameter update 3.1942e+06 3.43325e+06 -3.74877e+06 -0.20159 -0.176217 0.373858\n", + "Calculating residuals and partials 2724\n", + "Current residual: 1.7896e-06\n", + "Parameter update -159.263 92.6263 20.9602 8.31021e-06 -1.414e-05 1.27868e-05\n", + "Calculating residuals and partials 2724\n", + "Current residual: 1.78958e-06\n", + "Parameter update 0.0013206 0.000991714 0.000487634 -8.67286e-11 -6.18817e-11 -3.71523e-11\n", + "Calculating residuals and partials 2724\n", + "Current residual: 1.78958e-06\n", + "Maximum number of iterations reached\n", + "Parameter update -0.00492639 -0.00117797 -0.0013421 3.7442e-10 -2.28395e-10 -8.29871e-11\n", + "Final residual: 1.78958e-06\n" + ] + } + ], + "source": [ + "# Perform the estimation\n", + "pod_output = estimator.perform_estimation(pod_input)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The estimator appears to converge within ~4 steps. Lets check how close our initial guess and final estimate 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: 875435.59 km\n", + "433 Eros final radial error to spice: 83.92 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, `concatentated_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`/`concatentated_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": [ + "As seen previously, the estimation converges around iteration 4." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Residuals Corellations Matrix\n", + "Lets check out the corellation of the estimated parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating residuals and partials 2724\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Corellation can be retrieved using the CovarianceAnalysisInput class:\n", + "covariance_input = estimation.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(\"Carthesian 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", + "finalresiduals = np.array(residual_history[:, -1])\n", + "# if you would like to check the iteration 1 residuals, use:\n", + "# finalresiduals = 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", + " observation.LinkEndType.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", + " finalresiduals[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", + " finalresiduals[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", + " finalresiduals[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", + " finalresiduals[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 seperately\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", + " finalresiduals[concatenated_receiving_observatories == observatory][::2]\n", + " )\n", + "\n", + " data_per_observatory_list_DEC.append(\n", + " finalresiduals[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", + " finalresiduals[concatenated_receiving_observatories == observatory][0::2],\n", + " bins=nbins,\n", + " alpha=transparency + 0.05,\n", + " label=\"Right Ascension\",\n", + " )\n", + " axs[idx].hist(\n", + " finalresiduals[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", + "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": "tudat-bundle", + "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.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/estimation/estimation_with_mpc.py b/estimation/estimation_with_mpc.py new file mode 100644 index 0000000..f29976b --- /dev/null +++ b/estimation/estimation_with_mpc.py @@ -0,0 +1,842 @@ +# %% [markdown] +# Initial state estimation with Minor Planet Center Observations +""" +Copyright (c) 2010-2023, Delft University of Technology. All rights reserved. This file is part of the Tudat. Redistribution and use in source and binary forms, with or without modification, are permitted exclusively under the terms of the Modified BSD license. You should have received a copy of the license with this file. If not, please or visit: http://tudat.tudelft.nl/LICENSE. +""" + + +## Context +""" +This example highlights a simple orbit estimation routine using real, angular observation data from the [Minor Planet Center](https://www.minorplanetcenter.net/) (MPC). We will estimate the initial state of [Eros](https://en.wikipedia.org/wiki/433_Eros) a near-Earth asteroid 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](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/retrieving_mpc_observation_data.html) 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). +""" + +# %% [markdown] +## Import statements +""" +""" + +# %% +# Tudat imports for propagation and estimation +from tudatpy.kernel.interface import spice +from tudatpy.kernel import numerical_simulation +from tudatpy.kernel.numerical_simulation import environment_setup +from tudatpy.kernel.numerical_simulation import propagation_setup +from tudatpy.kernel.numerical_simulation import estimation, estimation_setup +from tudatpy.kernel.numerical_simulation.estimation_setup import observation + +# import MPC interface +from tudatpy.data.mpc import BatchMPC + +# import SBDB interface +from tudatpy.data.sbdb import SBDBquery + +# other useful modules +import numpy as np +import datetime + +import matplotlib.pyplot as plt +from matplotlib.lines import Line2D +import matplotlib.cm as cm + +# %% [markdown] +## Preparing the environment and observations +""" +""" + + +### Loading Spice Kernels. +""" +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. +""" + +# %% +# SPICE KERNELS +spice.load_standard_kernels() + +# %% [markdown] +### Setting some constants +""" +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. + +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. + +For our frame origin we use the Solar System Barycentre. 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. +""" + +# %% [markdown] +# Direct inputs: + +# %% +target_mpc_code = 433 + +observations_start = datetime.datetime(2018, 1, 1) +observations_end = datetime.datetime(2023, 7, 1) + +# number of iterations for our estimation +number_of_pod_iterations = 6 + +# timestep of 20 hours for our estimation +timestep_global = 20 * 3600 + +# 1 month time buffer used to avoid interpolation errors: +time_buffer = 1 * 31 * 86400 + +# define the frame origin and orientation. +global_frame_origin = "SSB" +global_frame_orientation = "J2000" + +# %% [markdown] +# Derived inputs: + +# %% +target_sbdb = SBDBquery(target_mpc_code) + +mpc_codes = [target_mpc_code] # the BatchMPC interface requires a list. +target_spkid = target_sbdb.codes_300_spkid # the ID used by the +target_name = target_sbdb.shortname # the ID used by the + +print(f"SPK ID for {target_name} is: {target_spkid}") + +# %% [markdown] +### Retrieving the observations +""" +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. +""" + +# %% +batch = BatchMPC() +batch.get_observations(mpc_codes) +batch.filter( + epoch_start=observations_start, + epoch_end=observations_end, +) + +batch.summary() + +# %% [markdown] +# Our batch includes many observations from space telescopes, lets take a closer look at that data. + +# %% +print("Summary of space telescopes in batch:") +print(batch.observatories_table(only_space_telescopes=True)) +obs_by_WISE = ( + batch.table.query("observatory == 'C51'") + .loc[:, ["number", "epochUTC", "RA", "DEC"]] + .iloc[[0, -1]] +) + +print("\nInitial and Final Observations by WISE:") +print(obs_by_WISE) + +# %% [markdown] +# While the observations from WISE appear to be useful, including them requires setting up the dynamics for the WISE spacecraft which is too advanced for this tutorial and its observations will be excluded later on in this example. The observations can also be filtered out explicitly by excluding the observatories with the .filter() method, specifying their codes (C57 etc.). Note that all the observations are given in an angular format, Right Ascension (RA) and Declination (DEC) in radians. + +# %% [markdown] +### Set up the environment +""" +We now set up the environment, including the bodies to use, the reference frame and frame origin. The epherides for all major planets as well as the Earth's Moon are retrieved using spice. + +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. +""" + +# %% +# List the bodies for our environment +bodies_to_create = [ + "Sun", + "Mercury", + "Venus", + "Earth", + "Moon", + "Mars", + "Jupiter", + "Saturn", + "Uranus", + "Neptune", +] + +# Create system of bodies +body_settings = environment_setup.get_default_body_settings( + bodies_to_create, global_frame_origin, global_frame_orientation +) + +bodies = environment_setup.create_system_of_bodies(body_settings) + +# Retrieve Eros' body name from BatchMPC and set its centre to enable its propapgation +bodies_to_propagate = batch.MPC_objects +central_bodies = [global_frame_origin] + +# %% [markdown] +### Convert the observations to Tudat +""" +Now that our system of bodies is ready we can retrieve the observation collection from the observations batch using the `to_tudat()` method. Note that by setting the included_satellites to `None`, space telescope observations are filtered out. From the observation collection we can also retrieve observation links. We use the links to define our observations settings this is where you would also add bias settings. For the purpose of this example, we will keep it simple and use the plain angular position 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. +""" + +# %% +# Transform the MPC observations into a tudat compatible format. +# note that we explicitly exlude all satellite observations in this step by setting included satellites to None. +observation_collection = batch.to_tudat(bodies=bodies, included_satellites=None) + +# set create angular_position settings for each link in the list. +observation_settings_list = list() +link_list = list( + observation_collection.get_link_definitions_for_observables( + observable_type=observation.angular_position_type + ) +) + +for link in link_list: + # add optional bias settings here + observation_settings_list.append( + observation.angular_position(link, bias_settings=None) + ) +# Retrieve the first and final observation epochs and add the buffer +epoch_start_nobuffer = batch.epoch_start +epoch_end_nobuffer = batch.epoch_end + +epoch_start_buffer = epoch_start_nobuffer - time_buffer +epoch_end_buffer = epoch_end_nobuffer + time_buffer + +# %% [markdown] +### Creating the acceleration settings +""" +Eros will be propagated and as such we need to define the settings of the forces acting on it. We will include point mass gravity accelerations for each of the bodies defined before, as well as Schwarzschild relativistic corrections for the Sun. 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. +""" + +# %% +# Define accelerations +accelerations = { + "Sun": [ + propagation_setup.acceleration.point_mass_gravity(), + propagation_setup.acceleration.relativistic_correction(use_schwarzschild=True), + ], + "Mercury": [propagation_setup.acceleration.point_mass_gravity()], + "Venus": [propagation_setup.acceleration.point_mass_gravity()], + "Earth": [propagation_setup.acceleration.point_mass_gravity()], + "Moon": [propagation_setup.acceleration.point_mass_gravity()], + "Mars": [propagation_setup.acceleration.point_mass_gravity()], + "Jupiter": [propagation_setup.acceleration.point_mass_gravity()], + "Saturn": [propagation_setup.acceleration.point_mass_gravity()], + "Uranus": [propagation_setup.acceleration.point_mass_gravity()], + "Neptune": [propagation_setup.acceleration.point_mass_gravity()], +} + +# Set up the accelerations settings for each body, in this case only Eros +acceleration_settings = {} +for body in batch.MPC_objects: + acceleration_settings[str(body)] = accelerations + +# create the acceleration models. +acceleration_models = propagation_setup.create_acceleration_models( + bodies, acceleration_settings, bodies_to_propagate, central_bodies +) + +# %% [markdown] +### Retrieving an initial guess for Eros' position +""" +We use the SPICE ephemeris to retrieve a 'benchmark' initial state for Eros at the first epoch. We can also use this initial state as our initial guess for the estimation. We add a random uniform offset of +/- 1 million kilometers for the position and 100 m/s for the velocity. Adding this random offset should not have a strong influence on the final results, it is added in to keep the tutorial representative. In real-world cases we might not have such a good initial guess. +""" + +# %% +# benchmark state for later comparison retrieved from SPICE +initial_states = spice.get_body_cartesian_state_at_epoch( + target_spkid, + global_frame_origin, + global_frame_orientation, + "NONE", + epoch_start_buffer, +) + +# Add random offset for initial guess +np.random.seed = 1 + +initial_position_offset = 1e6 * 1000 +initial_velocity_offset = 100 + +initial_guess = initial_states.copy() +initial_guess[0:3] += (2 * np.random.rand(3) - 1) * initial_position_offset +initial_guess[3:6] += (2 * np.random.rand(3) - 1) * initial_velocity_offset + +print("Error between the real initial state and our initial guess:") +print(initial_guess - initial_states) + +# %% [markdown] +### Finalising the propagation setup +""" +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. +""" + +# %% +# Create numerical integrator settings +integrator_settings = propagation_setup.integrator.runge_kutta_variable_step_size( + epoch_start_buffer, + timestep_global, + propagation_setup.integrator.rkf_78, + timestep_global, + timestep_global, + 1.0, + 1.0, +) + +# Terminate at the time of oldest observation +termination_condition = propagation_setup.propagator.time_termination(epoch_end_buffer) + + +# Create propagation settings +propagator_settings = propagation_setup.propagator.translational( + central_bodies=central_bodies, + acceleration_models=acceleration_models, + bodies_to_integrate=bodies_to_propagate, + initial_states=initial_guess, + initial_time=epoch_start_buffer, + integrator_settings=integrator_settings, + termination_settings=termination_condition, +) + +# %% [markdown] +## Setting Up the estimation +""" +With the observation collection, the environment and propagations settings ready we can now begin setting up our estimation. + +In this example we will simply estimate the position of Eros and as such only include an initial states parameter. +""" + +# %% +# Setup parameters settings to propagate the state transition matrix +parameter_settings = estimation_setup.parameter.initial_states( + propagator_settings, bodies +) + +# Create the parameters that will be estimated +parameters_to_estimate = estimation_setup.create_parameter_set( + parameter_settings, bodies, propagator_settings +) + +# %% [markdown] +# 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 previously set to 6. + +# %% +# Set up the estimator +estimator = numerical_simulation.Estimator( + bodies=bodies, + estimated_parameters=parameters_to_estimate, + observation_settings=observation_settings_list, + propagator_settings=propagator_settings, + integrate_on_creation=True, +) + +# provide the observation collection as input, and limit number of iterations for estimation. +pod_input = estimation.EstimationInput( + observations_and_times=observation_collection, + convergence_checker=estimation.estimation_convergence_checker( + maximum_iterations=number_of_pod_iterations, + ), +) + +# Set methodological options +pod_input.define_estimation_settings(reintegrate_variational_equations=True) + +# %% [markdown] +## Performing the estimation +""" + +With everything set up we can now perform the estimation. +""" + +# %% +# Perform the estimation +pod_output = estimator.perform_estimation(pod_input) + +# %% [markdown] +# The estimator appears to converge within ~4 steps. Lets check how close our initial guess and final estimate are compared to the benchmark initial state. + +# %% +# retrieve the estimated initial state. +results_final = pod_output.parameter_history[:, -1] + +vector_error_initial = (np.array(initial_guess) - initial_states)[0:3] +error_magnitude_initial = np.sqrt(np.square(vector_error_initial).sum()) / 1000 + +vector_error_final = (np.array(results_final) - initial_states)[0:3] +error_magnitude_final = np.sqrt(np.square(vector_error_final).sum()) / 1000 + +print( + f"{target_name} initial guess radial error to spice: {round(error_magnitude_initial, 2)} km" +) +print( + f"{target_name} final radial error to spice: {round(error_magnitude_final, 2)} km" +) + +# %% [markdown] +## Visualising the results +""" +""" + + +#### Change in residuals per iteration +""" +We want to visualise the residuals, splitting them between Right Ascension and Declination. Internally, `concatentated_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`/`concatentated_observations`, i.e. by slicing [::2]. +""" + +# %% +residual_history = pod_output.residual_history + +# Number of columns and rows for our plot +number_of_columns = 2 + +number_of_rows = ( + int(number_of_pod_iterations / number_of_columns) + if number_of_pod_iterations % number_of_columns == 0 + else int((number_of_pod_iterations + 1) / number_of_columns) +) + +fig, axs = plt.subplots( + number_of_rows, + number_of_columns, + figsize=(9, 3.5 * number_of_rows), + sharex=True, + sharey=False, +) + +# We cheat a little to get an approximate year out of our times (which are in seconds since J2000) +residual_times = ( + np.array(observation_collection.concatenated_times) / (86400 * 365.25) + 2000 +) + + +# plot the residuals, split between RA and DEC types +for idx, ax in enumerate(fig.get_axes()): + ax.grid() + # we take every second + ax.scatter( + residual_times[::2], + residual_history[ + ::2, + idx, + ], + marker="+", + s=60, + label="Right Ascension", + ) + ax.scatter( + residual_times[1::2], + residual_history[ + 1::2, + idx, + ], + marker="+", + s=60, + label="Declination", + ) + ax.set_ylabel("Observation Residual [rad]") + ax.set_title("Iteration " + str(idx + 1)) + +plt.tight_layout() + +# add the year label for the x-axis +for col in range(number_of_columns): + axs[int(number_of_rows - 1), col].set_xlabel("Year") + +axs[0, 0].legend() + +plt.show() + +# %% [markdown] +# As seen previously, the estimation converges around iteration 4. + +# %% [markdown] +#### Residuals Corellations Matrix +""" +Lets check out the corellation of the estimated parameters. +""" + +# %% +# Corellation can be retrieved using the CovarianceAnalysisInput class: +covariance_input = estimation.CovarianceAnalysisInput(observation_collection) +covariance_output = estimator.compute_covariance(covariance_input) + +correlations = covariance_output.correlations +estimated_param_names = ["x", "y", "z", "vx", "vy", "vz"] + + +fig, ax = plt.subplots(1, 1, figsize=(9, 7)) + +im = ax.imshow(correlations, cmap=cm.RdYlBu_r, vmin=-1, vmax=1) + +ax.set_xticks(np.arange(len(estimated_param_names)), labels=estimated_param_names) +ax.set_yticks(np.arange(len(estimated_param_names)), labels=estimated_param_names) + +# add numbers to each of the boxes +for i in range(len(estimated_param_names)): + for j in range(len(estimated_param_names)): + text = ax.text( + j, i, round(correlations[i, j], 2), ha="center", va="center", color="w" + ) + +cb = plt.colorbar(im) + +ax.set_xlabel("Estimated Parameter") +ax.set_ylabel("Estimated Parameter") + +fig.suptitle(f"Correlations for estimated parameters for {target_name}") + +fig.set_tight_layout(True) + +# %% [markdown] +#### Orbit error vs spice over time +""" +Next, lets take a look at the error of the orbit over time, using spice as a reference. + +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. +""" + +# %% +# lets get ranges for all gaps larger than 6 months: +gap_in_months = 6 + +gaps = np.abs(np.diff(sorted(residual_times))) +num_gaps = ( + gaps > (gap_in_months / 12) +).sum() # counts the number of gaps larger than 0.5 years +indices_of_largest_gaps = np.argsort(gaps)[-num_gaps:] + +# (start, end) for each of the gaps +gap_ranges = [ + (sorted(residual_times)[idx - 1], sorted(residual_times)[idx + 1]) + for idx in indices_of_largest_gaps +] + +print(f"Largest gap = {round(max(gaps), 3)} years") +print(gap_ranges) + +# %% +# Now lets plot the orbit error +fig, ax = plt.subplots(1, 1, figsize=(9, 5)) + +# show areas where there are no observations: +for i, gap in enumerate(gap_ranges): + ax.axvspan( + xmin=gap[0], + xmax=gap[1], + color="red", + alpha=0.1, + label="Large gap in observations" if i == 0 else None, + ) + +spice_states = [] +estimation_states = [] + +# retrieve the states for a list of times. +times = np.linspace(epoch_start_nobuffer, epoch_end_nobuffer, 1000) +times_plot = times / (86400 * 365.25) + 2000 # approximate +for time in times: + # from spice + state_spice = spice.get_body_cartesian_state_at_epoch( + target_spkid, central_bodies[0], global_frame_orientation, "NONE", time + ) + spice_states.append(state_spice) + + # from estimation + state_est = bodies.get(str(target_mpc_code)).ephemeris.cartesian_state(time) + estimation_states.append(state_est) + +# Error in kilometers +error = (np.array(spice_states) - np.array(estimation_states)) / 1000 + +# plot +ax.plot(times_plot, error[:, 0], label="x") +ax.plot(times_plot, error[:, 1], label="y") +ax.plot(times_plot, error[:, 2], label="z") + +ax.grid() +ax.legend(ncol=1) + +plt.tight_layout() + +ax.set_ylabel("Carthesian Error [km]") +ax.set_xlabel("Year") + +fig.suptitle(f"Error vs SPICE over time for {target_name}") +fig.set_tight_layout(True) + +plt.show() + +# %% [markdown] +# 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. + +# %% [markdown] +#### Final residuals highlighted per observatory +""" +This plot shows the final iteration of the residuals, highlighting the 10 observatories with the most observations. +""" + +# %% +# 10 observatories with most observations +num_observatories = 10 + +finalresiduals = np.array(residual_history[:, -1]) +# if you would like to check the iteration 1 residuals, use: +# finalresiduals = np.array(residual_history[:, 0]) + +# %% +# This piece of code collects the 10 largest observatories +observatory_names = ( + batch.observatories_table(exclude_space_telescopes=True) + .sort_values("count", ascending=False) + .iloc[0:num_observatories] + .set_index("Code") +) +top_observatories = observatory_names.index.tolist() + +# This piece of code creates a `concatenated_receiving_observatories` map +# to identify the observatories by their MPC code instead of an internally used id +residuals_observatories = observation_collection.concatenated_link_definition_ids +unique_observatories = set(residuals_observatories) + +observatory_link_to_mpccode = { + idx: observation_collection.link_definition_ids[idx][ + observation.LinkEndType.receiver + ].reference_point + for idx in unique_observatories +} + +# the resulting map (MPC code for each item in the residuals_history): +concatenated_receiving_observatories = np.array( + [observatory_link_to_mpccode[idx] for idx in residuals_observatories] +) + +# mask for the observatories not in top 10: +mask_not_top = [ + (False if observatory in top_observatories else True) + for observatory in concatenated_receiving_observatories +] + +# get the number of observations by the other observatories +# (divide by two because the observations are concatenated RA,DEC in this list) +n_obs_not_top = int(sum(mask_not_top) / 2) + +# %% +fig, axs = plt.subplots(2, 1, figsize=(13, 9)) + +# Plot remaining observatories first +# RA +axs[0].scatter( + residual_times[mask_not_top][::2], + finalresiduals[mask_not_top][::2], + marker=".", + s=30, + label=f"{len(unique_observatories) - num_observatories} Other Observatories | {n_obs_not_top} obs", + color="lightgrey", +) +# DEC +axs[1].scatter( + residual_times[mask_not_top][1::2], + finalresiduals[mask_not_top][1::2], + marker=".", + s=30, + label=f"{len(unique_observatories) - num_observatories} Other Observatories | {n_obs_not_top} obs", + color="lightgrey", +) + +# plots the highlighted top 10 observatories +for observatory in top_observatories: + name = f"{observatory} | {observatory_names.loc[observatory].Name} | {int(observatory_names.loc[observatory]['count'])} obs" + axs[0].scatter( + residual_times[concatenated_receiving_observatories == observatory][::2], + finalresiduals[concatenated_receiving_observatories == observatory][::2], + marker=".", + s=30, + label=name, + zorder=100, + ) + axs[1].scatter( + residual_times[concatenated_receiving_observatories == observatory][1::2], + finalresiduals[concatenated_receiving_observatories == observatory][1::2], + marker=".", + s=30, + label=name, + zorder=100, + ) + + +axs[1].legend(ncols=3, loc="upper center", bbox_to_anchor=(0.47, -0.15)) + +for ax in fig.get_axes(): + ax.grid() + ax.set_ylabel("Observation Residual [rad]") + ax.set_xlabel("Year") + # this step hides a few outliers (~3 observations) + ax.set_ylim(-1.5e-5, 1.5e-5) + +axs[0].set_title("Right Ascension") +axs[1].set_title("Declination") + +fig.suptitle(f"Final Iteration residuals for {target_name}") +fig.set_tight_layout(True) + +plt.show() + +# %% [markdown] +#### Residual Boxplots per observatory +""" +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. +""" + +# %% +num_observatories = 6 + +data_per_observatory_list_RA = [] +data_per_observatory_list_DEC = [] +names = [] + +fig, ax = plt.subplots(1, 1, figsize=(10, 1.2 * num_observatories)) + +# we retrieve the observatory names again +observatory_names_box = ( + batch.observatories_table(exclude_space_telescopes=True) + .set_index("Code") + .sort_values("count", ascending=False) + .iloc[0:num_observatories] +) + +top_observatories_box = observatory_names_box.index.tolist() + +# retrieve the data for RA and DEC seperately +for observatory in top_observatories_box[::-1]: + name = f"{observatory} | {observatory_names_box.loc[observatory].Name} | {int(observatory_names_box.loc[observatory]['count'])} obs" + names.append(name) + data_per_observatory_list_RA.append( + finalresiduals[concatenated_receiving_observatories == observatory][::2] + ) + + data_per_observatory_list_DEC.append( + finalresiduals[concatenated_receiving_observatories == observatory][1::2] + ) + +# positioning the boxes +pos = (np.arange(0, len(top_observatories_box)) + 1) * 10 +widths = 2.8 +offset = 1.6 + +# box colors +RA_color = "tab:blue" +DEC_color = "tab:orange" + +# boxes for RA and DEC +RAplots = ax.boxplot( + x=data_per_observatory_list_RA, + vert=False, + positions=pos + offset, + widths=widths, + patch_artist=False, + capprops=dict(color=RA_color), + whiskerprops=dict(color=RA_color), + flierprops=dict(color=RA_color, markeredgecolor=RA_color), + medianprops=dict(color=RA_color), +) +DECplots = ax.boxplot( + x=data_per_observatory_list_DEC, + vert=False, + positions=pos - offset, + widths=widths, + patch_artist=False, + capprops=dict(color=DEC_color), + whiskerprops=dict(color=DEC_color), + flierprops=dict(color=DEC_color, markeredgecolor=DEC_color), + medianprops=dict(color=DEC_color), +) +# custom ticks +ax.set_yticks(ticks=pos, labels=names) + +# custom legend +place_holder_lines = [ + Line2D([0], [0], color=RA_color, lw=4), + Line2D([0], [0], color=DEC_color, lw=4), +] +ax.legend(place_holder_lines, ["Right Ascension", "Declination"]) + +ax.grid() +ax.set_xlabel("Observation Residual [rad]") + +fig.suptitle( + f"Residual boxplots of the {num_observatories} observatories with the most observations for {target_name}" +) + +# reducing whitespace +ax.set_ylim(10 - 4, int(len(top_observatories_box) * 10) + 4) + +fig.set_tight_layout(True) +plt.show() + +# %% [markdown] +#### Histograms per observatory +""" +Finally, lets get the residual histogram for the top 6 observatories, splitting again for right ascension and declination. +""" + +# %% +num_observatories = 6 +nbins = 20 +number_of_columns = 2 +transparency = 0.6 + +# %% +number_of_rows = ( + int(num_observatories / number_of_columns) + if num_observatories % number_of_columns == 0 + else int((num_observatories + 1) / number_of_columns) +) + +# we retrieve the observatory names again +observatory_names_hist = ( + batch.observatories_table(exclude_space_telescopes=True) + .set_index("Code") + .sort_values("count", ascending=False) + .iloc[0:num_observatories] +) + +top_observatories_hist = observatory_names_hist.index.tolist() + + +fig, axs = plt.subplots( + number_of_rows, + number_of_columns, + figsize=(4.5 * number_of_columns, 3 * number_of_rows), +) + +axs = axs.flatten() + +for idx, observatory in enumerate(top_observatories_hist): + name = f"{observatory} | {observatory_names_hist.loc[observatory].Name} | {int(observatory_names_hist.loc[observatory]['count'])} obs" + + axs[idx].hist( + finalresiduals[concatenated_receiving_observatories == observatory][0::2], + bins=nbins, + alpha=transparency + 0.05, + label="Right Ascension", + ) + axs[idx].hist( + finalresiduals[concatenated_receiving_observatories == observatory][1::2], + bins=nbins, + alpha=transparency, + label="Declination", + ) + + axs[idx].grid() + axs[idx].set_title(name) + axs[idx].set_ylabel("Number of Observations") + axs[idx].set_xlabel("Observation Residual [rad]") + +axs[0].legend() + +fig.suptitle( + f"Final residual histograms of the {num_observatories} observatories with the most observations for {target_name}" +) +fig.set_tight_layout(True) +plt.show() + +# %% [markdown] +# 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. +# +# Consider rerunning the script for some other object by changing the `target_mpc_code` variable and seeing how the results change. + + diff --git a/estimation/retrieving_mpc_observation_data.ipynb b/estimation/retrieving_mpc_observation_data.ipynb new file mode 100644 index 0000000..30e6372 --- /dev/null +++ b/estimation/retrieving_mpc_observation_data.ipynb @@ -0,0 +1,606 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Retrieving observation data from the Minor Planet Centre\n", + "Copyright (c) 2010-2023, Delft University of Technology. All rights reserved. This file is part of the Tudat. Redistribution and use in source and binary forms, with or without modification, are permitted exclusively under the terms of the Modified BSD license. You should have received a copy of the license with this file. If not, please or visit: http://tudat.tudelft.nl/LICENSE.\n", + "\n", + "## Context\n", + "The [Minor Planet Centre](https://www.minorplanetcenter.net/) (MPC) provides positional elements and observation data for minor planets, comets and outer irregular natural satellites of the major planets. Tudat's BatchMPC class allows for the retrieval and processing of observational data for these objects. This example highlights the complete functionality of the BatchMPC class itself. The [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) example showcases estimation with MPC observations, but we recommend going through this example first.\n", + "\n", + "MPC receives and stores observations from observatories across the world. These are optical observations in a Right Ascension (RA) and Declination (DEC) format which are processed into an Earth-inertial J2000 format. Objects are all assigned a unique minor-planet designation number (see examples below), comets use a distinct designation. Larger objects are often also given a name (only about 4% have been given a name currently). Similarly, observatories are also assigned a unique 3 symbol code.\n", + "\n", + "The following asteroids will be used in the example:\n", + "\n", + "- [433 Eros](https://en.wikipedia.org/wiki/433_Eros) (also the main focus of the [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) example)\n", + "- [238 Hypatia](https://en.wikipedia.org/wiki/238_Hypatia)\n", + "- [329 Svea](https://en.wikipedia.org/wiki/329_Svea)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Usage" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import statements\n", + "In this example we do not perform an estimation, as such we only need the batchMPC class from data, environment_setup and observation to convert our observations to Tudat and optionally datetime to filter our batch. We also load the standard SPICE kernels." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from tudatpy.data.mpc import BatchMPC\n", + "from tudatpy.kernel.numerical_simulation import environment_setup\n", + "from tudatpy.kernel.numerical_simulation.estimation_setup import observation\n", + "from tudatpy.kernel.interface import spice\n", + "\n", + "from datetime import datetime\n", + "\n", + "# Load spice kernels\n", + "spice.load_standard_kernels()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieval" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We initialise a `BatchMPC` object, create a list with the objects we want and use `.get_observations()` to retrieve the observations. `.get_observations()` uses [astroquery](https://astroquery.readthedocs.io/en/latest/mpc/mpc.html) to retrieve data from MPC and requires an internet connection. The observations are cached for faster retrieval in subsequent runs. The `BatchMPC` object removes duplicates if `.get_observations()` is ran twice.\n", + "\n", + "Tudat's estimation tools allow for multiple Objects to be analysed at the same time. BatchMPC can process multiple objects into a single observation collection automatically. For now lets retrieve the observations for Eros and Svea. BatchMPC uses MPC codes for objects and observatories. To get an overview of the batch we can use the `summary()` method. Let's also get some details on some of the observatories that retrieved the data using the `observatories_table()` method." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Batch Summary:\n", + "1. Batch includes 2 minor planets:\n", + " ['433', '329']\n", + "2. Batch includes 18274 observations, including 1994 observations from space telescopes\n", + "3. The observations range from 1892-03-21 21:00:12.096012 to 2023-08-30 10:04:37.718416\n", + " In seconds TDB since J2000: -3401189955.718365 to 746661946.9011023\n", + " In Julian Days: 2412179.37514 to 2460186.919881\n", + "4. The batch contains observations from 378 observatories, including 3 space telescopes\n", + "\n", + " Code Name count\n", + "0 000 Greenwich 230.0\n", + "6 006 Fabra Observatory, Barcelona 80.0\n", + "7 007 Paris 7.0\n", + "8 008 Algiers-Bouzareah 556.0\n", + "12 012 Uccle 68.0\n", + "... ... ... ...\n", + "2369 Z22 MASTER-IAC Observatory, Tenerife 55.0\n", + "2381 Z34 NNHS Drummonds Observatory 5.0\n", + "2399 Z52 The Studios Observatory, Grantham 12.0\n", + "2420 Z73 Observatorio Nuevos Horizontes, Camas 5.0\n", + "2427 Z80 Northolt Branch Observatory 54.0\n", + "\n", + "[378 rows x 3 columns]\n", + "Space Telescopes:\n", + " Code Name count\n", + "1225 C51 WISE 372.0\n", + "1231 C57 TESS 1620.0\n", + "1232 C59 Yangwang-1 2.0\n" + ] + } + ], + "source": [ + "asteroid_MPC_codes = [433, 329] # Eros and Svea\n", + "\n", + "batch1 = BatchMPC()\n", + "\n", + "batch1.get_observations(asteroid_MPC_codes)\n", + "\n", + "batch1.summary()\n", + "print(batch1.observatories_table(only_in_batch=True, only_space_telescopes=False, include_positions=False))\n", + "print(\"Space Telescopes:\")\n", + "print(batch1.observatories_table(only_in_batch=True, only_space_telescopes=True, include_positions=False))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also directly have a look at the the observations themselves, for example, lets take a look at the first and final observations from TESS and WISE. The table property allows for read only access to the observations in pandas dataframe format. " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial and Final Observations by TESS\n", + " number epochUTC RA DEC\n", + "11601 433 2021-06-06 21:34:01.804817 4.753241 -0.722587\n", + "13220 433 2021-06-24 04:44:01.103987 4.588734 -0.674985\n", + "Initial and Final Observations by WISE\n", + " number epochUTC RA DEC\n", + "9530 433 2014-04-03 09:20:06.403193 4.944692 -0.634497\n", + "4468 329 2022-12-04 04:24:29.951981 0.087998 -0.125128\n" + ] + } + ], + "source": [ + "obs_by_TESS = batch1.table.query(\"observatory == 'C57'\").loc[:, [\"number\", \"epochUTC\", \"RA\", \"DEC\"]].iloc[[0, -1]]\n", + "obs_by_WISE = batch1.table.query(\"observatory == 'C51'\").loc[:, [\"number\", \"epochUTC\", \"RA\", \"DEC\"]].iloc[[0, -1]]\n", + "\n", + "print(\"Initial and Final Observations by TESS\")\n", + "print(obs_by_TESS)\n", + "print(\"Initial and Final Observations by WISE\")\n", + "print(obs_by_WISE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Filtering" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the summary we can see that even the first observations from the 1890s are included. This is not ideal. We might also want to exclude some observatories. To fix this we use the `.filter()` method. Dates can be filtered using the standard seconds since J2000 TDB format or through python's datetime standard library in UTC for simplicity. Additionally, specific bands can be selected and observatories can explicitly be included or excluded. The `.filter()` method alters the original batch in place, an alternative is shown in the Additional Features section." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Size before filter: 18274\n", + "Size after filter: 5425\n", + "\n", + " Batch Summary:\n", + "1. Batch includes 2 minor planets:\n", + " ['433', '329']\n", + "2. Batch includes 5425 observations, including 1853 observations from space telescopes\n", + "3. The observations range from 2018-05-01 03:22:18.336012 to 2023-08-22 22:03:05.184015\n", + " In seconds TDB since J2000: 578417007.5214744 to 746013854.3668225\n", + " In Julian Days: 2458239.64049 to 2460179.41881\n", + "4. The batch contains observations from 78 observatories, including 2 space telescopes\n", + "\n" + ] + } + ], + "source": [ + "observatories_to_exlude = [\"000\", \"C59\"] # chosen as an example\n", + "\n", + "print(f\"Size before filter: {batch1.size}\")\n", + "batch1.filter(observatories_exclude=observatories_to_exlude, epoch_start=datetime(2018, 1, 1), epoch_end=746013855.0)\n", + "print(f\"Size after filter: {batch1.size}\")\n", + "\n", + "batch1.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up the system of bodies\n", + "A system of bodies must be created to keep observatories' positions consistent with Earth's shape model and to allow the attachment of these observatories to Earth. For the purposes of this example, we keep it as simple as possible. See the [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) for a more complete setup and explanation appropriate for estimation. For our bodies, we only use Earth and the Sun. We set our origin to `\"SSB\"`, the solar system barycenter. We use the default body settings from the `SPICE` kernel to initialise the planet and use it to create a system of bodies. This system of bodies is used in the `to_tudat()` method." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "bodies_to_create = [\"Sun\", \"Earth\"]\n", + "\n", + "# Create default body settings\n", + "global_frame_origin = \"SSB\"\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", + "metadata": {}, + "source": [ + "### Retrieve Observation Collection\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that our batch is ready, we can transform it to a Tudat `ObservationCollection` object using the `to_tudat()` method.\n", + "\n", + "The `.to_tudat()` does the following for us:\n", + "\n", + "1. Creates an empty body for each minor planet with their MPC code as a name.\n", + "2. Adds this body to the system of bodies inputted to the method.\n", + "3. Retrieves the global position of the terrestrial observatories in the batch and adds these stations to the Tudat environment.\n", + "4. Creates link definitions between each unique terrestrial observatory/ minor planet combination in the batch.\n", + "5. (Optionally) creates a link definition between each space telescope / minor planet combination in the batch. This requires an addional input.\n", + "6. Creates a `SingleObservationSet` object for each unique link that includes all observations for that link.\n", + "7. Returns an `ObservationCollection` object.\n", + "\n", + "If our batch includes space telescopes like WISE and TESS we must either link their Tudat name or exclude them. For now we exclude them by setting `included_satellites` to `None`. The additional features section shows an example of how to link satellites to the `to_tudat()` method. The '.to_tudat()' method does not alter the batch object itself." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "observation_collection = batch1.to_tudat(bodies, included_satellites=None)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The names of the bodies added to the system of bodies object as well as the dates of the oldest and latest observations can be retrieved from the batch:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "epoch_start = batch1.epoch_start # in seconds since J2000 TDB (Tudat default)\n", + "epoch_end = batch1.epoch_end\n", + "object_names = batch1.MPC_objects" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now retrieve the links from the ObservationCollection we got from `to_tudat()` and we can now create settings for these links. This is where link biases would be set, for now we just keep the settings default." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "observation_settings_list = list()\n", + "\n", + "link_list = list(\n", + " observation_collection.get_link_definitions_for_observables(\n", + " observable_type=observation.angular_position_type\n", + " )\n", + ")\n", + "\n", + "for link in link_list:\n", + " # add optional bias settings\n", + " observation_settings_list.append(\n", + " observation.angular_position(link, bias_settings=None)\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the `observation_collection` and `observation_settings_list` ready, we have all the observation inputs we need to perform an estimation. Next, lets verify the observations. Next, check out the [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) example to try estimation with the observations we have retrieved here. The remainder of the example discusses additional features." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Additional Features" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using satellite observations.\n", + "Space Telescopes in Tudat are treated as bodies instead of stations. To use their observations, their motion should be known to Tudat. A user may for example retrieve their ephemirides from a SPICE kernel or propagate the satellite. This body must then be linked to the MPC code for that space telescope when calling the `to_tudat()` method. The MPC code for TESS can be obtained using the `observatories_table()` method as used previously. Bellow is an example using a spice kernel." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "# Note that we are using the add_empty_settings() method instead of add_empty_body().\n", + "# This allows us to add ephemeris settings, \n", + "# which tudat uses to create an ephemeris which is consistent with the rest of the environment.\n", + "TESS_code = \"-95\"\n", + "body_settings.add_empty_settings(\"TESS\")\n", + "\n", + "# Set up the space telescope's dynamics, TESS orbits earth\n", + "# the spice kernel can be retrieved from: https://archive.stsci.edu/missions/tess/models/\n", + "spice.load_kernel(r\"tess_20_year_long_predictive.bsp\")\n", + "body_settings.get(\"TESS\").ephemeris_settings = environment_setup.ephemeris.direct_spice(\n", + " \"Earth\", global_frame_orientation, TESS_code)\n", + "\n", + "# NOTE this is incorrect, here we are trying to set the ephemeris directly:\n", + "# Setting the ephemeris settings allows tudat to complete the relevant setup for the body. \n", + "# bodies.create_empty_body(\"TESS\")\n", + "# bodies.get(\"TESS\").ephemeris = environment_setup.ephemeris.direct_spice(\n", + "# global_frame_origin, global_frame_orientation, TESS_code)\n", + "\n", + "# Create system of bodies\n", + "bodies = environment_setup.create_system_of_bodies(body_settings)\n", + "# create dictionary to link names. MPCcode:NameInTudat\n", + "sats_dict = {\"C57\":\"TESS\"}\n", + "\n", + "observation_collection = batch1.to_tudat(bodies, included_satellites=sats_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Manual retrieval from astroquery\n", + "Those familiar with astroquery (or those who have existing filitering/ retrieval processes) may use the `from_astropy()` and `from_pandas()` methods to still use `to_tudat()` functionality. The input must meet some requirements which can be found in the API documentation, the default format from astroquery fits these requirements." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Batch Summary:\n", + "1. Batch includes 1 minor planets:\n", + " ['238']\n", + "2. Batch includes 4288 observations, including 235 observations from space telescopes\n", + "3. The observations range from 1892-03-18 22:48:06.047982 to 2023-09-09 08:26:57.379211\n", + " In seconds TDB since J2000: -3401442681.766395 to 747520086.5617365\n", + " In Julian Days: 2412176.45007 to 2460196.852053\n", + "4. The batch contains observations from 106 observatories, including 1 space telescopes\n", + "\n" + ] + } + ], + "source": [ + "from astroquery.mpc import MPC\n", + "\n", + "mpc_code_hypatia = 238\n", + "data = MPC.get_observations(mpc_code_hypatia)\n", + "\n", + "# ...\n", + "# Any additional filtering steps\n", + "# ...\n", + "\n", + "batch2 = BatchMPC()\n", + "batch2.from_astropy(data)\n", + "\n", + "# alternative if pandas is preffered:\n", + "# data_pandas = data.to_pandas()\n", + "# batch2.from_astropy(data_pandas)\n", + "\n", + "batch2.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Combining batches" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Batches can be combined using the `+` operator, duplicates are removed." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Batch Summary:\n", + "1. Batch includes 3 minor planets:\n", + " ['238', '433', '329']\n", + "2. Batch includes 9713 observations, including 2088 observations from space telescopes\n", + "3. The observations range from 1892-03-18 22:48:06.047982 to 2023-09-09 08:26:57.379211\n", + " In seconds TDB since J2000: -3401442681.766395 to 747520086.5617365\n", + " In Julian Days: 2412176.45007 to 2460196.852053\n", + "4. The batch contains observations from 156 observatories, including 2 space telescopes\n", + "\n" + ] + } + ], + "source": [ + "batch3 = batch2 + batch1\n", + "batch3.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Copying and non in-place filtering\n", + "We may want to compare results between batches. In that case it is usefull to copy a batch or perform non-destructive filtering:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Batch Summary:\n", + "1. Batch includes 2 minor planets:\n", + " ['433', '329']\n", + "2. Batch includes 322 observations, including 28 observations from space telescopes\n", + "3. The observations range from 2023-01-04 19:17:22.271984 to 2023-08-22 22:03:05.184015\n", + " In seconds TDB since J2000: 726131911.4559577 to 746013854.3668225\n", + " In Julian Days: 2459949.30373 to 2460179.41881\n", + "4. The batch contains observations from 18 observatories, including 1 space telescopes\n", + "\n", + "\n", + " Batch Summary:\n", + "1. Batch includes 2 minor planets:\n", + " ['433', '329']\n", + "2. Batch includes 322 observations, including 28 observations from space telescopes\n", + "3. The observations range from 2023-01-04 19:17:22.271984 to 2023-08-22 22:03:05.184015\n", + " In seconds TDB since J2000: 726131911.4559577 to 746013854.3668225\n", + " In Julian Days: 2459949.30373 to 2460179.41881\n", + "4. The batch contains observations from 18 observatories, including 1 space telescopes\n", + "\n" + ] + } + ], + "source": [ + "# Copying existing batches:\n", + "import copy\n", + "batch1_copy = copy.copy(batch1)\n", + "# simpler equivalent:\n", + "batch1_copy = batch1.copy()\n", + "\n", + "# normal in-place/destructive filter\n", + "batch1_copy.filter(epoch_start=datetime(2023, 1, 1)) # returns None\n", + "# non-destructive filter:\n", + "batch1_copy2 = batch1.filter(epoch_start=datetime(2023, 1, 1), in_place=False) # returns filtered copy\n", + "\n", + "batch1_copy.summary()\n", + "batch1_copy2.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting observations\n", + "The `.plot_observations_sky()` method can be used to view a projection of the observations. Similarly, `.plot_observations_temporal()` shows the declination and right ascension of a batch's bodies over time." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Try some of the other projections: 'hammer', 'mollweide' and 'lambert'\n", + "fig = batch1.plot_observations_sky(projection=\"aitoff\")\n", + "# specific objects can be selected for large batches:\n", + "fig = batch1.plot_observations_sky(projection=None, objects=[329]) \n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Similar to the sky plot, specific bodies can be chosen to be plotted with the objects argument\n", + "fig = batch1.plot_observations_temporal()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tudat-bundle", + "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.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/estimation/retrieving_mpc_observation_data.py b/estimation/retrieving_mpc_observation_data.py new file mode 100644 index 0000000..ea0ebff --- /dev/null +++ b/estimation/retrieving_mpc_observation_data.py @@ -0,0 +1,281 @@ +# %% [markdown] +# Retrieving observation data from the Minor Planet Centre +""" +Copyright (c) 2010-2023, Delft University of Technology. All rights reserved. This file is part of the Tudat. Redistribution and use in source and binary forms, with or without modification, are permitted exclusively under the terms of the Modified BSD license. You should have received a copy of the license with this file. If not, please or visit: http://tudat.tudelft.nl/LICENSE. +""" + + +## Context +""" +The [Minor Planet Centre](https://www.minorplanetcenter.net/) (MPC) provides positional elements and observation data for minor planets, comets and outer irregular natural satellites of the major planets. Tudat's BatchMPC class allows for the retrieval and processing of observational data for these objects. This example highlights the complete functionality of the BatchMPC class itself. The [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) example showcases estimation with MPC observations, but we recommend going through this example first. + +MPC receives and stores observations from observatories across the world. These are optical observations in a Right Ascension (RA) and Declination (DEC) format which are processed into an Earth-inertial J2000 format. Objects are all assigned a unique minor-planet designation number (see examples below), comets use a distinct designation. Larger objects are often also given a name (only about 4% have been given a name currently). Similarly, observatories are also assigned a unique 3 symbol code. + +The following asteroids will be used in the example: + +- [433 Eros](https://en.wikipedia.org/wiki/433_Eros) (also the main focus of the [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) example) +- [238 Hypatia](https://en.wikipedia.org/wiki/238_Hypatia) +- [329 Svea](https://en.wikipedia.org/wiki/329_Svea) +""" + +# %% [markdown] +## Basic Usage +""" +""" + +# %% [markdown] +### Import statements +""" +In this example we do not perform an estimation, as such we only need the batchMPC class from data, environment_setup and observation to convert our observations to Tudat and optionally datetime to filter our batch. We also load the standard SPICE kernels. +""" + +# %% +from tudatpy.data.mpc import BatchMPC +from tudatpy.kernel.numerical_simulation import environment_setup +from tudatpy.kernel.numerical_simulation.estimation_setup import observation +from tudatpy.kernel.interface import spice + +from datetime import datetime + +# Load spice kernels +spice.load_standard_kernels() + + +# %% [markdown] +### Retrieval +""" +""" + +# %% [markdown] +# We initialise a `BatchMPC` object, create a list with the objects we want and use `.get_observations()` to retrieve the observations. `.get_observations()` uses [astroquery](https://astroquery.readthedocs.io/en/latest/mpc/mpc.html) to retrieve data from MPC and requires an internet connection. The observations are cached for faster retrieval in subsequent runs. The `BatchMPC` object removes duplicates if `.get_observations()` is ran twice. +# +# Tudat's estimation tools allow for multiple Objects to be analysed at the same time. BatchMPC can process multiple objects into a single observation collection automatically. For now lets retrieve the observations for Eros and Svea. BatchMPC uses MPC codes for objects and observatories. To get an overview of the batch we can use the `summary()` method. Let's also get some details on some of the observatories that retrieved the data using the `observatories_table()` method. + +# %% +asteroid_MPC_codes = [433, 329] # Eros and Svea + +batch1 = BatchMPC() + +batch1.get_observations(asteroid_MPC_codes) + +batch1.summary() +print(batch1.observatories_table(only_in_batch=True, only_space_telescopes=False, include_positions=False)) +print("Space Telescopes:") +print(batch1.observatories_table(only_in_batch=True, only_space_telescopes=True, include_positions=False)) + +# %% [markdown] +# We can also directly have a look at the the observations themselves, for example, lets take a look at the first and final observations from TESS and WISE. The table property allows for read only access to the observations in pandas dataframe format. + +# %% +obs_by_TESS = batch1.table.query("observatory == 'C57'").loc[:, ["number", "epochUTC", "RA", "DEC"]].iloc[[0, -1]] +obs_by_WISE = batch1.table.query("observatory == 'C51'").loc[:, ["number", "epochUTC", "RA", "DEC"]].iloc[[0, -1]] + +print("Initial and Final Observations by TESS") +print(obs_by_TESS) +print("Initial and Final Observations by WISE") +print(obs_by_WISE) + +# %% [markdown] +### Filtering +""" +""" + +# %% [markdown] +# From the summary we can see that even the first observations from the 1890s are included. This is not ideal. We might also want to exclude some observatories. To fix this we use the `.filter()` method. Dates can be filtered using the standard seconds since J2000 TDB format or through python's datetime standard library in UTC for simplicity. Additionally, specific bands can be selected and observatories can explicitly be included or excluded. The `.filter()` method alters the original batch in place, an alternative is shown in the Additional Features section. + +# %% +observatories_to_exlude = ["000", "C59"] # chosen as an example + +print(f"Size before filter: {batch1.size}") +batch1.filter(observatories_exclude=observatories_to_exlude, epoch_start=datetime(2018, 1, 1), epoch_end=746013855.0) +print(f"Size after filter: {batch1.size}") + +batch1.summary() + +# %% [markdown] +### Set up the system of bodies +""" +A system of bodies must be created to keep observatories' positions consistent with Earth's shape model and to allow the attachment of these observatories to Earth. For the purposes of this example, we keep it as simple as possible. See the [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) for a more complete setup and explanation appropriate for estimation. For our bodies, we only use Earth and the Sun. We set our origin to `"SSB"`, the solar system barycenter. We use the default body settings from the `SPICE` kernel to initialise the planet and use it to create a system of bodies. This system of bodies is used in the `to_tudat()` method. +""" + +# %% +bodies_to_create = ["Sun", "Earth"] + +# Create default body settings +global_frame_origin = "SSB" +global_frame_orientation = "J2000" +body_settings = environment_setup.get_default_body_settings( + bodies_to_create, global_frame_origin, global_frame_orientation) + +# Create system of bodies +bodies = environment_setup.create_system_of_bodies(body_settings) + +# %% [markdown] +### Retrieve Observation Collection +""" + +""" + +# %% [markdown] +# Now that our batch is ready, we can transform it to a Tudat `ObservationCollection` object using the `to_tudat()` method. +# +# The `.to_tudat()` does the following for us: +# +# 1. Creates an empty body for each minor planet with their MPC code as a name. +# 2. Adds this body to the system of bodies inputted to the method. +# 3. Retrieves the global position of the terrestrial observatories in the batch and adds these stations to the Tudat environment. +# 4. Creates link definitions between each unique terrestrial observatory/ minor planet combination in the batch. +# 5. (Optionally) creates a link definition between each space telescope / minor planet combination in the batch. This requires an addional input. +# 6. Creates a `SingleObservationSet` object for each unique link that includes all observations for that link. +# 7. Returns an `ObservationCollection` object. +# +# If our batch includes space telescopes like WISE and TESS we must either link their Tudat name or exclude them. For now we exclude them by setting `included_satellites` to `None`. The additional features section shows an example of how to link satellites to the `to_tudat()` method. The '.to_tudat()' method does not alter the batch object itself. + +# %% +observation_collection = batch1.to_tudat(bodies, included_satellites=None) + +# %% [markdown] +# The names of the bodies added to the system of bodies object as well as the dates of the oldest and latest observations can be retrieved from the batch: + +# %% +epoch_start = batch1.epoch_start # in seconds since J2000 TDB (Tudat default) +epoch_end = batch1.epoch_end +object_names = batch1.MPC_objects + +# %% [markdown] +# We can now retrieve the links from the ObservationCollection we got from `to_tudat()` and we can now create settings for these links. This is where link biases would be set, for now we just keep the settings default. + +# %% +observation_settings_list = list() + +link_list = list( + observation_collection.get_link_definitions_for_observables( + observable_type=observation.angular_position_type + ) +) + +for link in link_list: + # add optional bias settings + observation_settings_list.append( + observation.angular_position(link, bias_settings=None) + ) + +# %% [markdown] +# With the `observation_collection` and `observation_settings_list` ready, we have all the observation inputs we need to perform an estimation. Next, lets verify the observations. Next, check out the [Estimation with MPC](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/estimation_with_mpc.html) example to try estimation with the observations we have retrieved here. The remainder of the example discusses additional features. + +# %% [markdown] +## Additional Features +""" +""" + +# %% [markdown] +### Using satellite observations. +""" +Space Telescopes in Tudat are treated as bodies instead of stations. To use their observations, their motion should be known to Tudat. A user may for example retrieve their ephemirides from a SPICE kernel or propagate the satellite. This body must then be linked to the MPC code for that space telescope when calling the `to_tudat()` method. The MPC code for TESS can be obtained using the `observatories_table()` method as used previously. Bellow is an example using a spice kernel. +""" + +# %% +# Note that we are using the add_empty_settings() method instead of add_empty_body(). +# This allows us to add ephemeris settings, +# which tudat uses to create an ephemeris which is consistent with the rest of the environment. +TESS_code = "-95" +body_settings.add_empty_settings("TESS") + +# Set up the space telescope's dynamics, TESS orbits earth +# the spice kernel can be retrieved from: https://archive.stsci.edu/missions/tess/models/ +spice.load_kernel(r"tess_20_year_long_predictive.bsp") +body_settings.get("TESS").ephemeris_settings = environment_setup.ephemeris.direct_spice( + "Earth", global_frame_orientation, TESS_code) + +# NOTE this is incorrect, here we are trying to set the ephemeris directly: +# Setting the ephemeris settings allows tudat to complete the relevant setup for the body. +# bodies.create_empty_body("TESS") +# bodies.get("TESS").ephemeris = environment_setup.ephemeris.direct_spice( +# global_frame_origin, global_frame_orientation, TESS_code) + +# Create system of bodies +bodies = environment_setup.create_system_of_bodies(body_settings) +# create dictionary to link names. MPCcode:NameInTudat +sats_dict = {"C57":"TESS"} + +observation_collection = batch1.to_tudat(bodies, included_satellites=sats_dict) + +# %% [markdown] +### Manual retrieval from astroquery +""" +Those familiar with astroquery (or those who have existing filitering/ retrieval processes) may use the `from_astropy()` and `from_pandas()` methods to still use `to_tudat()` functionality. The input must meet some requirements which can be found in the API documentation, the default format from astroquery fits these requirements. +""" + +# %% +from astroquery.mpc import MPC + +mpc_code_hypatia = 238 +data = MPC.get_observations(mpc_code_hypatia) + +# ... +# Any additional filtering steps +# ... + +batch2 = BatchMPC() +batch2.from_astropy(data) + +# alternative if pandas is preffered: +# data_pandas = data.to_pandas() +# batch2.from_astropy(data_pandas) + +batch2.summary() + +# %% [markdown] +### Combining batches +""" +""" + +# %% [markdown] +# Batches can be combined using the `+` operator, duplicates are removed. + +# %% +batch3 = batch2 + batch1 +batch3.summary() + +# %% [markdown] +### Copying and non in-place filtering +""" +We may want to compare results between batches. In that case it is usefull to copy a batch or perform non-destructive filtering: +""" + +# %% +# Copying existing batches: +import copy +batch1_copy = copy.copy(batch1) +# simpler equivalent: +batch1_copy = batch1.copy() + +# normal in-place/destructive filter +batch1_copy.filter(epoch_start=datetime(2023, 1, 1)) # returns None +# non-destructive filter: +batch1_copy2 = batch1.filter(epoch_start=datetime(2023, 1, 1), in_place=False) # returns filtered copy + +batch1_copy.summary() +batch1_copy2.summary() + +# %% [markdown] +### Plotting observations +""" +The `.plot_observations_sky()` method can be used to view a projection of the observations. Similarly, `.plot_observations_temporal()` shows the declination and right ascension of a batch's bodies over time. +""" + +# %% +import matplotlib.pyplot as plt + +# Try some of the other projections: 'hammer', 'mollweide' and 'lambert' +fig = batch1.plot_observations_sky(projection="aitoff") +# specific objects can be selected for large batches: +fig = batch1.plot_observations_sky(projection=None, objects=[329]) + +plt.show() + +# %% +# Similar to the sky plot, specific bodies can be chosen to be plotted with the objects argument +fig = batch1.plot_observations_temporal() + + diff --git a/estimation/tess_20_year_long_predictive.bsp b/estimation/tess_20_year_long_predictive.bsp new file mode 100644 index 0000000..3daff8f Binary files /dev/null and b/estimation/tess_20_year_long_predictive.bsp differ