{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e67134f8",
   "metadata": {},
   "source": [
    "# Covariance Analysis with DELFI-C3\n",
    "## Objectives\n",
    "This example will guide you through the set-up of an orbit estimation routine, which usually comprises the **estimation of the covariance**, as well as the **estimation of the initial parameters**. In this example we will **focus on the former**, and you'll learn:\n",
    "\n",
    "* how to **set up the estimation** of a covariance matrix;\n",
    "* how to **plot the correlation coefficients**;\n",
    "* how to **plot the uncertainty ellipsoids**.\n",
    "\n",
    "For the **full estimation** of some selected parameters, such as initial state, drag coefficient, and radiation pressure coefficient of a spacecraft, see [DELFI-C3 - Parameter Estimation Example](full_estimation_example.ipynb).\n",
    "\n",
    "To simulate the orbit of a spacecraft, we will fall back and reiterate on all aspects of orbit propagation that are important within the scope of orbit estimation. Further, we will highlight all relevant features of modelling a tracking station on Earth. Using this station, we will simulate a tracking routine of the spacecraft using a series of instantaneous unbiased one-way Doppler range-rate measurements with uncertainty of 1 mm/s every 60 seconds. To assure an uninterrupted line-of-sight between the station and the spacecraft, a minimum elevation angle of more than 15 degrees above the horizon - as seen from the station - will be imposed as constraint on the simulation of observations.\n",
    "\n",
    "The first part of this example deals with the setup of all relevant (environment, propagation, and estimation) modules, so feel free to skip these steps if you're already familiar with them!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e99cbeda",
   "metadata": {},
   "source": [
    "## Import statements\n",
    "Typically - in the most pythonic way - all required modules are imported at the very beginning.\n",
    "\n",
    "Some standard modules are first loaded: `numpy` and `matplotlib.pyplot`.\n",
    "\n",
    "Then, the different modules of `tudatpy` that will be used are imported. Most notably, the `estimation`,`dynamics.parameters_setup`, and `observations` modules will be used and demonstrated within this example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b71677c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load required standard modules\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# Load required tudatpy modules\n",
    "from tudatpy import constants\n",
    "from tudatpy.interface import spice\n",
    "from tudatpy import dynamics\n",
    "from tudatpy.dynamics import environment, environment_setup\n",
    "from tudatpy.dynamics import propagation_setup, parameters_setup, simulator\n",
    "from tudatpy import estimation\n",
    "from tudatpy.estimation import observable_models_setup, observable_models, observations_setup, observations, estimation_analysis\n",
    "from tudatpy.astro.time_representation import DateTime\n",
    "from tudatpy.astro import element_conversion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "707bd319",
   "metadata": {},
   "source": [
    "## Configuration\n",
    "First, NAIF's `SPICE` kernels are loaded, to make the positions of various bodies such as the Earth, the Sun, or the Moon known to `tudatpy`.\n",
    "\n",
    "Subsequently, the start and end epoch of the simulation and observations are defined.* Note that using `tudatpy`, the times are generally specified in seconds since J2000. Hence, setting the start epoch to `0` corresponds to the 1st of January 2000. The end epoch specifies a total duration of the simulation of four days.\n",
    "\n",
    "For more information on J2000 and the conversion between different temporal reference frames, please refer to the [API documentation](https://py.api.tudat.space/en/latest/time_representation.html) of the `time_representation` module.\n",
    "\n",
    "*Please note that it is always a good practice to separate the observation start and end epochs from the simulated ones. This way, we ensure that the times at which the observations are simulated all fall within the simulation timespan, especially given the geometry of the problem and the time difference at the two link ends (receiver and transmitter are separated by a certain distance). For this reason, we will set the first observation start epoch at one day after the simulation start epoch, and the observation end epoch at one day before the end of the simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e336516b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load spice kernels\n",
    "spice.load_standard_kernels()\n",
    "\n",
    "# Set simulation start and end epochs\n",
    "simulation_start_epoch = DateTime(2000, 1, 1).epoch()\n",
    "simulation_end_epoch   = DateTime(2000, 1, 5).epoch()\n",
    "\n",
    "observation_start_epoch = DateTime(2000, 1, 2).epoch()\n",
    "observation_end_epoch   = DateTime(2000, 1, 4).epoch()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd2cea53",
   "metadata": {},
   "source": [
    "## Set up the environment\n",
    "We will now create and define the settings for the environment of our simulation. In particular, this covers the creation of (celestial) bodies, vehicle(s), and environment interfaces.\n",
    "\n",
    "### Create the main bodies\n",
    "To create the systems of bodies for the simulation, one first has to define a list of strings of all bodies that are to be included. Note that the default body settings (such as atmosphere, body shape, rotation model) are taken from the `SPICE` kernel.\n",
    "\n",
    "These settings, however, can be adjusted. Please refer to the [Available Environment Models](https://docs.tudat.space/en/latest/_src_user_guide/state_propagation/environment_setup/environment_models.html#available-model-types) in the user guide for more details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4563c7d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create default body settings for \"Sun\", \"Earth\", \"Moon\", \"Mars\", and \"Venus\"\n",
    "bodies_to_create = [\"Sun\", \"Earth\", \"Moon\", \"Mars\", \"Venus\"]\n",
    "\n",
    "# Create default body settings for bodies_to_create, with \"Earth\"/\"J2000\" as the global frame origin and orientation\n",
    "global_frame_origin = \"Earth\"\n",
    "global_frame_orientation = \"J2000\"\n",
    "body_settings = environment_setup.get_default_body_settings(\n",
    "    bodies_to_create, global_frame_origin, global_frame_orientation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1b002c1",
   "metadata": {},
   "source": [
    "### Create the vehicle and its environment interface\n",
    "We will now create the satellite - called Delfi-C3 - for which an orbit will be simulated. Using an `empty_body` as a blank canvas for the satellite, we define mass of 2.2 kg, a reference area (used both for aerodynamic and radiation pressure) of 4m$^2$, and a aerodynamic drag coefficient of 1.2. Idem for the radiation pressure coefficient. Finally, when setting up the radiation pressure interface, the Earth is set as a body that can occult the radiation emitted by the Sun."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1585b93e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create vehicle objects.\n",
    "body_settings.add_empty_settings(\"Delfi-C3\")\n",
    "body_settings.get(\"Delfi-C3\").constant_mass = 2.2 #kg\n",
    "\n",
    "# Create aerodynamic coefficient interface settings\n",
    "reference_area_drag = (4*0.3*0.1+2*0.1*0.1)/4  # Average projection area of a 3U CubeSat\n",
    "drag_coefficient = 1.2\n",
    "aero_coefficient_settings = environment_setup.aerodynamic_coefficients.constant(\n",
    "    reference_area_drag, [drag_coefficient, 0.0, 0.0]\n",
    ")\n",
    "# Add the aerodynamic interface to the environment\n",
    "body_settings.get(\"Delfi-C3\").aerodynamic_coefficient_settings = aero_coefficient_settings\n",
    "\n",
    "# Create radiation pressure settings\n",
    "reference_area_radiation = (4*0.3*0.1+2*0.1*0.1)/4  # Average projection area of a 3U CubeSat\n",
    "radiation_pressure_coefficient = 1.2\n",
    "occulting_bodies = dict()\n",
    "occulting_bodies[\"Sun\"] = [\"Earth\"]\n",
    "radiation_pressure_settings = environment_setup.radiation_pressure.cannonball_radiation_target(\n",
    "    reference_area_radiation, radiation_pressure_coefficient, occulting_bodies)\n",
    "\n",
    "# Add the radiation pressure interface to the environment\n",
    "body_settings.get(\"Delfi-C3\").radiation_pressure_target_settings = radiation_pressure_settings\n",
    "\n",
    "# Create system of bodies\n",
    "bodies = environment_setup.create_system_of_bodies(body_settings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bc428bc",
   "metadata": {},
   "source": [
    "## Set up the propagation\n",
    "Having the environment created, we will define the settings for the propagation of the spacecraft. First, we have to define the body to be propagated - here, the spacecraft - and the central body - here, Earth - with respect to which the state of the propagated body is defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f4c79591",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define bodies that are propagated\n",
    "bodies_to_propagate = [\"Delfi-C3\"]\n",
    "\n",
    "# Define central bodies of propagation\n",
    "central_bodies = [\"Earth\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a615dbcd",
   "metadata": {},
   "source": [
    "### Create the acceleration model\n",
    "Subsequently, all accelerations (and there settings) that act on `Delfi-C3` have to be defined. In particular, we will consider:\n",
    "\n",
    "* Gravitational acceleration using a spherical harmonic approximation up to 8th degree and order for Earth.\n",
    "* Aerodynamic acceleration for Earth.\n",
    "* Gravitational acceleration using a simple point mass model for:\n",
    "\n",
    "    - The Sun\n",
    "    - The Moon\n",
    "    - Mars\n",
    "\n",
    "* Radiation pressure experienced by the spacecraft - shape-wise approximated as a spherical cannonball - due to the Sun.\n",
    "\n",
    "The defined acceleration settings are then applied to `Delfi-C3` by means of a dictionary, which is finally used as input to the propagation setup to create the acceleration models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ae320f6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the accelerations acting on Delfi-C3\n",
    "accelerations_settings_delfi_c3 = dict(\n",
    "    Sun=[\n",
    "        propagation_setup.acceleration.radiation_pressure(),\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ],\n",
    "    Mars=[\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ],\n",
    "    Moon=[\n",
    "        propagation_setup.acceleration.point_mass_gravity()\n",
    "    ],\n",
    "    Earth=[\n",
    "        propagation_setup.acceleration.spherical_harmonic_gravity(8, 8),\n",
    "        propagation_setup.acceleration.aerodynamic()\n",
    "    ])\n",
    "\n",
    "# Create global accelerations dictionary\n",
    "acceleration_settings = {\"Delfi-C3\": accelerations_settings_delfi_c3}\n",
    "\n",
    "# Create acceleration models\n",
    "acceleration_models = propagation_setup.create_acceleration_models(\n",
    "    bodies,\n",
    "    acceleration_settings,\n",
    "    bodies_to_propagate,\n",
    "    central_bodies)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4a73dba",
   "metadata": {},
   "source": [
    "### Define the initial state\n",
    "In Tudat, the initial state of the spacecraft always has to be provided as a **cartesian state** - i.e. in the form of a list with the first three elements representing the initial position, and the three remaining elements representing the initial velocity.\n",
    "\n",
    "Within this example, we will retrieve the initial state of Delfi-C3 using its Two-Line-Elements (TLE) the date of its launch (April the 28th, 2008). The TLE strings are obtained from [space-track.org](https://www.space-track.org) and are converted in to cartesian state via the `cartesian_state`function of the `ephemeris` class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "12458abf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve the initial state of Delfi-C3 using Two-Line-Elements (TLEs)\n",
    "delfi_tle = environment.Tle(\n",
    "    \"1 32789U 07021G   08119.60740078 -.00000054  00000-0  00000+0 0  9999\",\n",
    "    \"2 32789 098.0082 179.6267 0015321 307.2977 051.0656 14.81417433    68\",\n",
    ")\n",
    "delfi_ephemeris = environment.TleEphemeris(\"Earth\", \"J2000\", delfi_tle, False)\n",
    "initial_state = delfi_ephemeris.cartesian_state( simulation_start_epoch )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd8e2587",
   "metadata": {},
   "source": [
    "### Create the integrator settings\n",
    "For the problem at hand, we will use an RKF78 integrator with a **fixed step-size of 60 seconds**. This can be achieved by tweaking the implemented RKF78 integrator with variable step-size such that both the minimum and maximum step-size is equal to 60 seconds and a tolerance of 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "44edeb70",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create numerical integrator settings\n",
    "integrator_settings = propagation_setup.integrator.\\\n",
    "    runge_kutta_fixed_step_size(initial_time_step=60.0,\n",
    "                                coefficient_set=propagation_setup.integrator.CoefficientSets.rkdp_87)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "890fda75",
   "metadata": {},
   "source": [
    "### Create the propagator settings\n",
    "By combining all of the above-defined settings we can define the settings for the propagator to simulate the orbit of `Delfi-C3` around Earth. A **termination condition** needs to be defined so that the propagation stops as soon as the specified end epoch is reached. Finally, the translational propagator's settings are created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "facb90c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create termination settings\n",
    "termination_condition = propagation_setup.propagator.time_termination(simulation_end_epoch)\n",
    "\n",
    "# Create propagation settings\n",
    "propagator_settings = propagation_setup.propagator.translational(\n",
    "    central_bodies,\n",
    "    acceleration_models,\n",
    "    bodies_to_propagate,\n",
    "    initial_state,\n",
    "    simulation_start_epoch,\n",
    "    integrator_settings,\n",
    "    termination_condition\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "956c9ebe",
   "metadata": {},
   "source": [
    "## Set up the observations\n",
    "Having set the underlying dynamical model of the simulated orbit, we can define the **observational model**. Generally, this entails the addition of all required ground stations, the definition of the observation links and types, as well as the precise simulation settings.\n",
    "\n",
    "### Add a ground station\n",
    "Trivially, the simulation of observations requires the extension of the current environment by at least one observer - a ground station. For this example, we will model a single ground station located in Delft, Netherlands, at an altitude of 0m, 52.00667°N, 4.35556°E.\n",
    "\n",
    "More information on how to use the `add_ground_station()` function can be found in the respective [API documentation](https://py.api.tudat.space/en/latest/environment_setup.html#tudatpy.dynamics.environment_setup.add_ground_station)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4eebd846",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the position of the ground station on Earth\n",
    "station_altitude = 0.0\n",
    "delft_latitude = np.deg2rad(52.00667)\n",
    "delft_longitude = np.deg2rad(4.35556)\n",
    "\n",
    "# Add the ground station to the environment\n",
    "environment_setup.add_ground_station(\n",
    "    bodies.get_body(\"Earth\"),\n",
    "    \"TrackingStation\",\n",
    "    [station_altitude, delft_latitude, delft_longitude],\n",
    "    element_conversion.geodetic_position_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "451a76c7",
   "metadata": {},
   "source": [
    "### Define Observation Links and Types\n",
    "To establish the links between our ground station and `Delfi-C3`, we will make use of the [observation module](https://py.api.tudat.space/en/latest/observation.html#observation) of tudat. During the link definition, each member is assigned a certain function within the link, for instance as \"transmitter\", \"receiver\", or \"reflector\". Once two (or more) members are connected to a link, they can be used to simulate observations along this particular link. The precise type of observation made along this link - e.g., range, range-rate, angular position, etc. - is then determined by the chosen observable type.\n",
    "\n",
    "To fully define an observation model for a given link, we have to create a list of the observation model settings of all desired observable types and their associated links. This list will later be used as input to the actual estimator object. \n",
    "\n",
    "Each observable type has its own function for creating observation model settings - in this example we will use the `one_way_doppler_instantaneous()` function to model a series of one-way open-loop (i.e. instantaneous) Doppler observations. Realise that the individual observation model settings can also include corrective models or define biases for more advanced use-cases.\n",
    "\n",
    "Note that the `one_way_doppler_instantaneous()` measurements use the **satellite** as **transmitter** and the **ground station** as **receiver**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8a19c012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the uplink link ends for one-way observable\n",
    "link_ends = dict()\n",
    "link_ends[observable_models_setup.links.receiver] = observable_models_setup.links.body_reference_point_link_end_id(\"Earth\", \"TrackingStation\")\n",
    "link_ends[observable_models_setup.links.transmitter] = observable_models_setup.links.body_origin_link_end_id(\"Delfi-C3\")\n",
    "\n",
    "# Create observation settings for each link/observable\n",
    "link_definition = observable_models_setup.links.LinkDefinition(link_ends)\n",
    "observation_settings_list = [observable_models_setup.model_settings.one_way_doppler_instantaneous(link_definition)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9b8518a",
   "metadata": {},
   "source": [
    "### Define Observation Simulation Settings\n",
    "We now have to define the **times at which observations are to be simulated**. To this end, we will define the settings for the simulation of the individual observations from the previously defined observation models. Bear in mind that these observation simulation settings are not to be confused with the ones to be used when setting up the estimator object, as done just above.\n",
    "\n",
    "Finally, for each observation model, the observation simulation settings set the times at which observations are simulated and defines the viability criteria and noise of the observation. Realise that the latter is technically not needed within the scope of a covariance analysis but for the sake of completeness (and with eye for the estimation example re-using this code) we have opted to nonetheless include it already.\n",
    "\n",
    "Note that the actual simulation of the observations requires `Observation Simulators`, which are created automatically by the `Estimator` object. Hence, one cannot simulate observations before the creation of an estimator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "48d30336",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define observation simulation times for each link (separated by steps of 1 minute)\n",
    "observation_times = np.arange(observation_start_epoch, observation_end_epoch, 60.0)\n",
    "observation_simulation_settings = observations_setup.observations_simulation_settings.tabulated_simulation_settings(\n",
    "    observable_models_setup.model_settings.one_way_instantaneous_doppler_type,\n",
    "    link_definition,\n",
    "    observation_times\n",
    ")\n",
    "\n",
    "# Add noise levels of roughly 1.0E-3 [m/s] and add this as Gaussian noise to the observation\n",
    "noise_level = 1.0E-3\n",
    "observations_setup.random_noise.add_gaussian_noise_to_observable(\n",
    "    [observation_simulation_settings],\n",
    "    noise_level,\n",
    "    observable_models_setup.model_settings.one_way_instantaneous_doppler_type\n",
    ")\n",
    "\n",
    "# Create viability settings\n",
    "viability_setting = observations_setup.viability.elevation_angle_viability([\"Earth\", \"TrackingStation\"], np.deg2rad(15))\n",
    "observations_setup.viability.add_viability_check_to_all(\n",
    "    [observation_simulation_settings],\n",
    "    [viability_setting]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee6a84e0",
   "metadata": {},
   "source": [
    "## Set up the estimation\n",
    "Using the defined models for the environment, the propagator, and the observations, we can finally set the actual presentation up. In particular, this consists of defining all parameter that should be estimated, the creation of the estimator, and the simulation of the observations.\n",
    "\n",
    "### Defining the parameters to estimate\n",
    "For this example estimation, we decided to estimate the initial state of `Delfi-C3`, its drag coefficient, and the gravitational parameter of Earth. A comprehensive list of parameters available for estimation is provided at [this link](https://py.api.tudat.space/en/latest/parameter.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "44bf1b2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup parameters settings to propagate the state transition matrix\n",
    "parameter_settings = dynamics.parameters_setup.initial_states(propagator_settings, bodies)\n",
    "\n",
    "# Add estimated parameters to the sensitivity matrix that will be propagated\n",
    "parameter_settings.append(dynamics.parameters_setup.gravitational_parameter(\"Earth\"))\n",
    "parameter_settings.append(dynamics.parameters_setup.constant_drag_coefficient(\"Delfi-C3\"))\n",
    "\n",
    "# Create the parameters that will be estimated\n",
    "parameters_to_estimate = dynamics.parameters_setup.create_parameter_set(parameter_settings, bodies)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c248e5c",
   "metadata": {},
   "source": [
    "### Creating the Estimator object\n",
    "Ultimately, the `Estimator` object consolidates all relevant information required for the estimation of any system parameter:\n",
    "    \n",
    "1) the environment (`bodies`)\n",
    "2) the parameter set (`parameters_to_estimate`)\n",
    "3) observation models (`observation_settings_list`)\n",
    "4) dynamical, numerical, and integrator setup (`propagator_settings`)\n",
    "\n",
    "Underneath its hood, upon creation, the estimator automatically takes care of setting up the relevant Observation Simulator and Variational Equations which will subsequently be required for the simulation of observations and the estimation of parameters, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bd694993",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the estimator\n",
    "estimator = estimation_analysis.Estimator(\n",
    "    bodies,\n",
    "    parameters_to_estimate,\n",
    "    observation_settings_list,\n",
    "    propagator_settings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f7cad02",
   "metadata": {},
   "source": [
    "### Perform the observations simulation\n",
    "Using the created `Estimator` object, we can perform the simulation of observations by calling its `simulate_observations()` method, see the [API reference](https://py.api.tudat.space/en/latest/estimation/observations_setup/observations_wrapper.html#tudatpy.estimation.observations_setup.observations_wrapper.simulate_observations). Note that to know about the time settings for the individual types of observations, this function makes use of the earlier defined observation simulation settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e66fd2ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulate required observations\n",
    "simulated_observations = observations_setup.observations_wrapper.simulate_observations(\n",
    "    [observation_simulation_settings],\n",
    "    estimator.observation_simulators,\n",
    "    bodies)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41e33162",
   "metadata": {},
   "source": [
    "<a id='covariance_section'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fdf3ba3-7528-4618-87de-d15cd6ab907c",
   "metadata": {},
   "source": [
    "## Perform the covariance analysis\n",
    "Having simulated the observations and created the `Estimator` object - containing the variational equations for the parameters to estimate - we have defined everything to conduct the actual estimation. Realise that up to this point, we have not yet specified whether we want to perform a covariance analysis or the full estimation of all parameters. It should be stressed that the general setup for either path to be followed is largely identical up to this point (see, for example, the [full estimation example](full_estimation_example.ipynb)).\n",
    "\n",
    "### Set up the inversion\n",
    "To set up the inversion of the problem, we collect all relevant inputs in the form of a covariance input object and define some basic settings of the inversion. Most crucially, this is the step where we can account for different weights - if any - of the different observations, to give the estimator knowledge about the quality of the individual types of observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a1478bbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning, function setConstantPerObservableWeightsMatrix is deprecated, weights should preferably be defined at the observation collection level."
     ]
    }
   ],
   "source": [
    "# Define weighting of the observations in the inversion\n",
    "weights_per_observable = { observations.observations_processing.observation_parser(\n",
    "    observable_models_setup.model_settings.one_way_instantaneous_doppler_type ): noise_level ** -2}\n",
    "simulated_observations.set_constant_weight_per_observation_parser(weights_per_observable)\n",
    "\n",
    "# Create input object for covariance analysis\n",
    "covariance_input = estimation_analysis.CovarianceAnalysisInput(\n",
    "    simulated_observations)\n",
    "\n",
    "# Set methodological options\n",
    "covariance_input.define_covariance_settings(\n",
    "    reintegrate_variational_equations=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39f16498",
   "metadata": {},
   "source": [
    "### Computing the Covariance\n",
    "Using the just defined inputs, we can ultimately run the computation of our covariance matrix. The formal errors are the square root of the diagonal entries of the covariance matrix. While the first six entries represent the uncertainties in the (cartesian) initial state, the seventh and eighth are the errors associated with the gravitational parameter of Earth and the aerodynamic drag coefficient, respectively.\n",
    "\n",
    "When dealing with the results of covariance analyses - as a measure of how the estimated variable differs from the 'thought' true value - it is important to stress that the correlation between the parameters is another important aspect to take into consideration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fcb86d74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating residuals and partials 39\n"
     ]
    }
   ],
   "source": [
    "# Perform the covariance analysis\n",
    "covariance_output = estimator.compute_covariance(covariance_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e4e2be65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Formal Errors:\n",
      "[4.57167455e-01 2.44191250e-01 2.30598510e-01 2.43082490e-04\n",
      " 2.56548138e-04 4.67122880e-04 1.76648068e+07 3.11485945e-04]\n"
     ]
    }
   ],
   "source": [
    "# Print the covariance matrix\n",
    "formal_errors = covariance_output.formal_errors\n",
    "print(f'Formal Errors:\\n{formal_errors}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41061acd",
   "metadata": {},
   "source": [
    "### Visualizing Correlations \n",
    "In particular, correlation describes how the estimate and uncertainty of two parameters are related with each other. Typically, a value of 1.0 indicates entirely correlated elements (thus always present on the diagonal, indicating the correlation of an element with itself), a value of 0.0 indicates perfectly uncorrelated elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3a8b2784",
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "\n",
    "plt.imshow((np.abs(covariance_output.correlations)), aspect='auto', interpolation='none')\n",
    "plt.colorbar()\n",
    "\n",
    "plt.title(\"Correlation Matrix\")\n",
    "plt.xlabel(\"Index - Estimated Parameter\")\n",
    "plt.ylabel(\"Index - Estimated Parameter\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e83e2b1c-0abf-4c32-bf9b-7d8f1a192497",
   "metadata": {},
   "source": [
    "## Post-Processing Results\n",
    "Perfect, we have got our results. Now it is time to make sense of them. To further process them, one can - exemplary - plot:\n",
    "\n",
    "1) the ellipsoidal confidence region defined by the covariance;\n",
    "2) the behaviour of the simulated observations over time;\n",
    "3) the history of the residuals;\n",
    "4) the statistical interpretation of the final residuals.\n",
    "\n",
    "### 1) Plotting the Ellipsoidal Confidence Region\n",
    "In the following, we will see how to plot the **confidence ellipsoid**. This is defined by the **covariance matrix**, which also encodes information about the **correlations** between different parameters. Then, we will perform the same operation, taking the \"*formal errors matrix*\" instead (namely is the covariance where all the off-diagonal elements are set to zero) - and **we will compare the two ellipsoids** so obtained. \n",
    "\n",
    "#### Formal Errors and Covariance Matrix: How Are They Related?\n",
    "Note how we have mentioned above that the **formal errors** constitute the **diagonal entries of the covariance matrix (variances)**. \n",
    "In practice, the \"formal error matrix\" is a covariance matrix where all the **off-diagonal terms are set to zero**. Recalling what done just above, this amounts discard any **correlation** in the errors between different parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6671648f-17a1-4bd3-974d-608aba762816",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating residuals and partials 39\n",
      "Initial_covariance:\n",
      "\n",
      "[[ 2.09002082e-01  5.59277380e-02 -8.54574640e-02  1.00071946e-04\n",
      "   9.42974647e-06  2.02978672e-04 -5.16706934e+04  1.03956096e-04]\n",
      " [ 5.59277380e-02  5.96293667e-02 -2.66220168e-02  3.60341312e-05\n",
      "  -9.25677685e-06  7.79103641e-05 -3.08960951e+05  5.18603748e-05]\n",
      " [-8.54574642e-02 -2.66220169e-02  5.31756730e-02 -4.80510873e-05\n",
      "  -2.16619919e-05 -9.07474499e-05 -2.17756571e+06 -4.87655706e-05]\n",
      " [ 1.00071946e-04  3.60341312e-05 -4.80510873e-05  5.90890971e-08\n",
      "  -4.23232468e-09  9.99741263e-08  8.88318580e+02  5.39830703e-08]\n",
      " [ 9.42974681e-06 -9.25677675e-06 -2.16619920e-05 -4.23232454e-09\n",
      "   6.58169470e-08  1.32170938e-08  2.75284675e+03  2.40487053e-09]\n",
      " [ 2.02978672e-04  7.79103641e-05 -9.07474497e-05  9.99741262e-08\n",
      "   1.32170935e-08  2.18203785e-07  1.55978692e+02  1.26322326e-07]\n",
      " [-5.16706605e+04 -3.08960942e+05 -2.17756573e+06  8.88318596e+02\n",
      "   2.75284676e+03  1.55978724e+02  3.12045401e+14 -1.79501558e+02]\n",
      " [ 1.03956096e-04  5.18603749e-05 -4.87655705e-05  5.39830703e-08\n",
      "   2.40487036e-09  1.26322326e-07 -1.79501574e+02  9.70234939e-08]]\n",
      "\n",
      "Formal Error Matrix:\n",
      "\n",
      "[[2.09002082e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
      "  0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n",
      " [0.00000000e+00 5.96293667e-02 0.00000000e+00 0.00000000e+00\n",
      "  0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 5.31756730e-02 0.00000000e+00\n",
      "  0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 0.00000000e+00 5.90890971e-08\n",
      "  0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
      "  6.58169470e-08 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
      "  0.00000000e+00 2.18203785e-07 0.00000000e+00 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
      "  0.00000000e+00 0.00000000e+00 3.12045401e+14 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n",
      "  0.00000000e+00 0.00000000e+00 0.00000000e+00 9.70234939e-08]]\n",
      "\n",
      "Estimated state and parameters:\n",
      "\n",
      " [-2.86506915e+06 -1.81810499e+05 -6.40693678e+06  6.27519638e+03\n",
      "  2.96693121e+03 -2.89377723e+03  3.98600442e+14  1.20000000e+00]\n",
      "\n",
      "Eigenvalues of Covariance Matrix:\n",
      "\n",
      " [2.09002082e-01 5.96293667e-02 5.31756730e-02 5.90890971e-08\n",
      " 6.58169470e-08 2.18203785e-07 3.12045401e+14 9.70234939e-08]\n",
      "\n",
      "Eigenvalues of Formal Errors Matrix:\n",
      "\n",
      " [2.09002082e-01 5.96293667e-02 5.31756730e-02 5.90890971e-08\n",
      " 6.58169470e-08 2.18203785e-07 3.12045401e+14 9.70234939e-08]\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning, function setConstantPerObservableWeightsMatrix is deprecated, weights should preferably be defined at the observation collection level."
     ]
    }
   ],
   "source": [
    "# # Define the parameters\n",
    "x_star = parameters_to_estimate.parameter_vector # Nominal solution (center of the ellipsoid)\n",
    "# Create input object for covariance analysis\n",
    "covariance_input = estimation_analysis.CovarianceAnalysisInput(\n",
    "      simulated_observations)\n",
    "\n",
    "# # Set methodological options\n",
    "covariance_input.define_covariance_settings(\n",
    "     reintegrate_variational_equations=False)\n",
    "covariance_output = estimator.compute_covariance(covariance_input)\n",
    "initial_covariance = covariance_output.covariance  # Covariance matrix\n",
    "print(f'Initial_covariance:\\n\\n{initial_covariance}\\n')\n",
    "\n",
    "state_transition_interface = estimator.state_transition_interface\n",
    "output_times = observation_times\n",
    "\n",
    "diagonal_covariance = np.diag(formal_errors**2)\n",
    "print(f'Formal Error Matrix:\\n\\n{diagonal_covariance}\\n')\n",
    "\n",
    "sigma = 3  # Confidence level\n",
    "original_eigenvalues, original_eigenvectors = np.linalg.eig(diagonal_covariance)\n",
    "original_diagonal_eigenvalues, original_diagonal_eigenvectors = np.linalg.eig(diagonal_covariance)\n",
    "print(f'Estimated state and parameters:\\n\\n {parameters_to_estimate.parameter_vector}\\n')\n",
    "print(f'Eigenvalues of Covariance Matrix:\\n\\n {original_eigenvalues}\\n')\n",
    "print(f'Eigenvalues of Formal Errors Matrix:\\n\\n {original_diagonal_eigenvalues}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f95c86bc-8415-4ec1-be21-397c73a6256a",
   "metadata": {},
   "source": [
    "## Visualizing the covariance and the formal errors\n",
    "In the following, we will get the **eigenvalues and eigenvectors** corresponding to both the **full covariance matrix** and the **\"formal errors matrix\"** (i.e. the covariance with only the diagonal elements different from zero). Then, we will show how a unit sphere is stretched by the two matrices ([this website](https://cookierobotics.com/007/) briefly explains how to plot a covariance ellipsoid in two dimensions).\n",
    "\n",
    "Please note that, in our case, the space of parameters has dimension 8 (initial state + drag coefficient + gravitational parameter), but we will plot the ellipsoid obtained by restricting the problem to the **3 spatial dimensions only** (unless you can find a way to plot an 8D ellipsoid in python!)\n",
    "\n",
    "The plots will show, for each of the two matrices:\n",
    "\n",
    "1) the 3-sigma ellipsoid\n",
    "2) the 1-sigma ellipsoid\n",
    "3) the projections of both 1) and 2) on the x,y,z axes.\n",
    "\n",
    "As you will see, based on how the two ellipsoids are oriented in 3D space, we can tell the formal errors matrix eigenvectors are parallel to the x,y and z axis, while the one belonging to the full covariance matrix are not, due to the **existing relationship (correlation)** between different parameters (variables). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "cfc1a08f-4aec-46bc-8302-bf5396d23550",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted Eigenvalues (variances along principal axes):\n",
      "\n",
      "[3.12045401e+14 2.09002082e-01 5.96293667e-02 5.31756730e-02\n",
      " 2.18203785e-07 9.70234939e-08 6.58169470e-08 5.90890971e-08]\n",
      "\n",
      "Sorted Formal Error Matrix Eigenvalues (variances along principal axes):\n",
      "\n",
      "[3.12045401e+14 2.09002082e-01 5.96293667e-02 5.31756730e-02\n",
      " 2.18203785e-07 9.70234939e-08 6.58169470e-08 5.90890971e-08]\n",
      "\n",
      "Sorted Eigenvectors (directions of principal axes):\n",
      "\n",
      "[[0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [0. 0. 0. 0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 1. 0. 0.]]\n",
      "\n",
      "Sorted Formal Error Matrix Eigenvectors (directions of principal axes):\n",
      "\n",
      "[[0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [0. 0. 0. 0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 1. 0. 0.]]\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# # Select the first 3 dimensions for plotting\n",
    "\n",
    "# Sort eigenvalues and eigenvectors\n",
    "sorted_indices = np.argsort(original_eigenvalues)[::-1]\n",
    "diagonal_sorted_indices = np.argsort(original_diagonal_eigenvalues)[::-1]\n",
    "\n",
    "eigenvalues = original_eigenvalues[sorted_indices]\n",
    "eigenvectors = original_eigenvectors[:, sorted_indices]\n",
    "\n",
    "diagonal_eigenvalues = original_diagonal_eigenvalues[diagonal_sorted_indices]\n",
    "diagonal_eigenvectors = original_diagonal_eigenvectors[:, diagonal_sorted_indices]\n",
    "\n",
    "# Output results\n",
    "print(f\"Sorted Eigenvalues (variances along principal axes):\\n\\n{eigenvalues}\\n\")\n",
    "print(f\"Sorted Formal Error Matrix Eigenvalues (variances along principal axes):\\n\\n{diagonal_eigenvalues}\\n\")\n",
    "print(f\"Sorted Eigenvectors (directions of principal axes):\\n\\n{eigenvectors}\\n\")\n",
    "print(f\"Sorted Formal Error Matrix Eigenvectors (directions of principal axes):\\n\\n{diagonal_eigenvectors}\\n\")\n",
    "\n",
    "COV_sub = initial_covariance[np.ix_(np.sort(sorted_indices)[:3], np.sort(sorted_indices)[:3])]  #Covariance restriction to first 3 (spatial) eigenvectors\n",
    "diagonal_COV_sub = diagonal_covariance[np.ix_(np.sort(diagonal_sorted_indices)[:3], np.sort(diagonal_sorted_indices)[:3])]  #Covariance restriction to first 3 (spatial) eigenvectors\n",
    "\n",
    "x_star_sub = x_star[sorted_indices[:3]] #Nominal solution subset\n",
    "diagonal_x_star_sub = x_star[diagonal_sorted_indices[:3]] #Nominal solution subset\n",
    "\n",
    "# Eigenvalue decomposition of the submatrix\n",
    "eigenvalues, eigenvectors = np.linalg.eig(COV_sub)\n",
    "diagonal_eigenvalues, diagonal_eigenvectors = np.linalg.eig(diagonal_COV_sub)\n",
    "\n",
    "# Ensure eigenvalues are positive\n",
    "if np.any(eigenvalues <= 0):\n",
    "     raise ValueError(f\"$Covariance$ submatrix is not positive definite. Eigenvalues must be positive.\\n\")\n",
    "if np.any(diagonal_eigenvalues <= 0):\n",
    "    raise ValueError(f\"$Formal Errors$ submatrix is not positive definite. Eigenvalues must be positive.\\n\")\n",
    "\n",
    "phi = np.linspace(0, np.pi, 50)\n",
    "theta = np.linspace(0, 2 * np.pi,50)\n",
    "phi, theta = np.meshgrid(phi, theta)\n",
    "\n",
    "# Generate points on the unit sphere and multiply each direction by the corresponding eigenvalue\n",
    "x_ell= np.sqrt(eigenvalues[0])*  np.sin(phi) * np.cos(theta)\n",
    "y_ell = np.sqrt(eigenvalues[1])* np.sin(phi) * np.sin(theta)\n",
    "z_ell = np.sqrt(eigenvalues[2])* np.cos(phi)\n",
    "\n",
    "# Generate points on the unit sphere and multiply each direction by the corresponding diagonal_eigenvalue\n",
    "diagonal_x_ell = np.sqrt(diagonal_eigenvalues[0])*np.sin(phi) * np.cos(theta)\n",
    "diagonal_y_ell = np.sqrt(diagonal_eigenvalues[1])*np.sin(phi) * np.sin(theta)\n",
    "diagonal_z_ell = np.sqrt(diagonal_eigenvalues[2])*np.cos(phi)\n",
    "\n",
    "ell = np.stack([x_ell, y_ell, z_ell], axis=0)\n",
    "diagonal_ell = np.stack([diagonal_x_ell, diagonal_y_ell, diagonal_z_ell], axis=0)\n",
    "\n",
    "#Rotate the Ellipsoid(s). This is done by multiplying ell and diagonal_ell by the corresponding eigenvector matrices\n",
    "ellipsoid_boundary_3_sigma = 3 * np.tensordot(eigenvectors, ell, axes=1)\n",
    "ellipsoid_boundary_1_sigma = 1 * np.tensordot(eigenvectors, ell, axes=1) \n",
    "diagonal_ellipsoid_boundary_3_sigma = 3 * np.tensordot(diagonal_eigenvectors, diagonal_ell, axes=1)\n",
    "diagonal_ellipsoid_boundary_1_sigma = 1 * np.tensordot(diagonal_eigenvectors, diagonal_ell, axes=1)\n",
    "\n",
    "# Plot the ellipsoid in 3D\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "ax = fig.add_subplot(121, projection='3d')\n",
    "diagonal_ax =fig.add_subplot(122, projection='3d')\n",
    "\n",
    "ax.plot_surface(ellipsoid_boundary_3_sigma[0], ellipsoid_boundary_3_sigma[1], ellipsoid_boundary_3_sigma[2], color='cyan', alpha=0.4, label = '3-sigma (covariance)')\n",
    "ax.plot_surface(ellipsoid_boundary_1_sigma[0], ellipsoid_boundary_1_sigma[1], ellipsoid_boundary_1_sigma[2], color='blue', alpha=0.4, label = '1-sigma (covariance)')\n",
    "\n",
    "diagonal_ax.plot_surface(diagonal_ellipsoid_boundary_3_sigma[0], diagonal_ellipsoid_boundary_3_sigma[1], diagonal_ellipsoid_boundary_3_sigma[2], color='red', alpha=0.2, label = '3-sigma (formal errors)')\n",
    "diagonal_ax.plot_surface(diagonal_ellipsoid_boundary_1_sigma[0], diagonal_ellipsoid_boundary_1_sigma[1], diagonal_ellipsoid_boundary_1_sigma[2], color='black', alpha=0.2, label = '1-sigma (formal errors)')\n",
    "\n",
    "ax.plot(ellipsoid_boundary_1_sigma[0], ellipsoid_boundary_1_sigma[2], 'r+', alpha=0.1, zdir='y', zs=2*np.max(ellipsoid_boundary_3_sigma[1]))\n",
    "ax.plot(ellipsoid_boundary_1_sigma[1], ellipsoid_boundary_1_sigma[2], 'r+',alpha=0.1, zdir='x', zs=-2*np.max(ellipsoid_boundary_3_sigma[0]))\n",
    "ax.plot(ellipsoid_boundary_1_sigma[0], ellipsoid_boundary_1_sigma[1], 'r+',alpha=0.1, zdir='z', zs=-2*np.max(ellipsoid_boundary_3_sigma[2]))\n",
    "\n",
    "ax.plot(ellipsoid_boundary_3_sigma[0], ellipsoid_boundary_3_sigma[2], 'b+', alpha=0.1, zdir='y', zs=2*np.max(ellipsoid_boundary_3_sigma[1]))\n",
    "ax.plot(ellipsoid_boundary_3_sigma[1], ellipsoid_boundary_3_sigma[2], 'b+',alpha=0.1, zdir='x', zs=-2*np.max(ellipsoid_boundary_3_sigma[0]))\n",
    "ax.plot(ellipsoid_boundary_3_sigma[0], ellipsoid_boundary_3_sigma[1], 'b+',alpha=0.1, zdir='z', zs=-2*np.max(ellipsoid_boundary_3_sigma[2]))\n",
    "\n",
    "diagonal_ax.plot(diagonal_ellipsoid_boundary_1_sigma[0], diagonal_ellipsoid_boundary_1_sigma[2], 'r+', alpha=0.1, zdir='y', zs=2*np.max(diagonal_ellipsoid_boundary_3_sigma[1]))\n",
    "diagonal_ax.plot(diagonal_ellipsoid_boundary_1_sigma[1], diagonal_ellipsoid_boundary_1_sigma[2], 'r+',alpha=0.1, zdir='x', zs=-2*np.max(diagonal_ellipsoid_boundary_3_sigma[0]))\n",
    "diagonal_ax.plot(diagonal_ellipsoid_boundary_1_sigma[0], diagonal_ellipsoid_boundary_1_sigma[1], 'r+',alpha=0.1, zdir='z', zs=-2*np.max(diagonal_ellipsoid_boundary_3_sigma[2]))\n",
    "\n",
    "diagonal_ax.plot(diagonal_ellipsoid_boundary_3_sigma[0], diagonal_ellipsoid_boundary_3_sigma[2], 'b+', alpha=0.1, zdir='y', zs=2*np.max(diagonal_ellipsoid_boundary_3_sigma[1]))\n",
    "diagonal_ax.plot(diagonal_ellipsoid_boundary_3_sigma[1], diagonal_ellipsoid_boundary_3_sigma[2], 'b+',alpha=0.1, zdir='x', zs=-2*np.max(diagonal_ellipsoid_boundary_3_sigma[0]))\n",
    "diagonal_ax.plot(diagonal_ellipsoid_boundary_3_sigma[0], diagonal_ellipsoid_boundary_3_sigma[1], 'b+',alpha=0.1, zdir='z', zs=-2*np.max(diagonal_ellipsoid_boundary_3_sigma[2]))\n",
    "\n",
    "ax.set_xlabel('(x-x^*)')\n",
    "ax.set_ylabel('(y-y^*)')\n",
    "ax.set_zlabel('(z-z^*)')\n",
    "ax.set_aspect('equal')\n",
    "ax.set_title('3D Confidence Ellipsoid and Projections')\n",
    "#ax.set_aspect('equal')\n",
    "ax.legend(loc = 'upper right')\n",
    "\n",
    "diagonal_ax.set_xlabel('(x-x^*)')\n",
    "diagonal_ax.set_ylabel('(y-y^*)')\n",
    "diagonal_ax.set_zlabel('(z-z^*)')\n",
    "diagonal_ax.set_aspect('equal')\n",
    "diagonal_ax.set_title('Formal Errors and Projections')\n",
    "#diagonal_ax.set_aspect('equal')\n",
    "diagonal_ax.legend(loc = 'upper right')\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0def0590-4a58-49e1-9f35-720a08c833f9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}