11. Orbit Determination and Parameter Estimation (Basic)

In all previous tutorials, we were only concerned with the propagation of orbits, and the analysis of the numerical results. In this tutorial, we will show how to simulate tracking observables, and use these observations to estimate the state of a spacecraft, as well as a variety of physical parameters of the environment. The estimation framework in Tudat has a broad variety of features, and we only cover the basic aspects here. A tutorial of more extensive features is given on the page Orbit Determination and Parameter Estimation.

The code for this tutorial is given on Github, and is also located in your Tudat bundle at:


As you can see in the code, setting up the environment is done in a similar manner as the previous tutorials: a set of celestial bodies is created, as well as a vehicle, which is endowed with radiation pressure and aerodynamic properties.

The first modification is that we change the Earth rotation model

bodySettings[ "Earth" ]->rotationModelSettings = std::make_shared< SimpleRotationModelSettings >(
            "ECLIPJ2000", "IAU_Earth", spice_interface::computeRotationQuaternionBetweenFrames(
                "ECLIPJ2000", "IAU_Earth", initialEphemerisTime ),
            initialEphemerisTime, 2.0 * mathematical_constants::PI / physical_constants::JULIAN_DAY );

We take this extra step, so that we can estimate the rotational properties of the Earth, as they are described by this model (fixed rotation axis and rotation rate). Details of the architecture of the parameter estimation is given on the page on Parameter Architecture.

Secondly, after creating the bodies, we add a number of ground stations on our body Earth. Ground stations serve as reference points from which observations can be performed. Their body-fixed state is, in this case, defined in geodetic coordinates. See the page Ground Station Creation for more details:

// Create ground stations from geodetic positions.
std::vector< std::string > groundStationNames;
groundStationNames.push_back( "Station1" );
groundStationNames.push_back( "Station2" );
groundStationNames.push_back( "Station3" );

createGroundStation( bodyMap.at( "Earth" ), "Station1",
                     ( Eigen::Vector3d( ) << 0.0, 1.25, 0.0 ).finished( ), geodetic_position );
createGroundStation( bodyMap.at( "Earth" ), "Station2",
                     ( Eigen::Vector3d( ) << 0.0, -1.55, 2.0 ).finished( ), geodetic_position );
createGroundStation( bodyMap.at( "Earth" ), "Station3",
                     ( Eigen::Vector3d( ) << 0.0, 0.8, 4.0 ).finished( ), geodetic_position );

The subsequent creation of acceleration, propagation and integration settings is done in the same manner as previous tutorials.

11.1. Defining Observation Settings

In Tudat, an observation model is referred to a number of link ends (see Setting up the link ends). For a one-way range model, for instance, a receiver and transmitter are required, both of which are termed a ‘link end’. An enum termed LinkEndType is available that lists all the possible kinds of link ends. A full list of observation models, as well as the link ends that they require, is given on page Observation Types. A set of link ends used for a given observable are stored in a LinkEnds type, which is a typedef for std::map< LinkEndType, std::pair< std::string, std::string > >. As you can see, the map value is a pair of strings. The first entry of the pair is the body on which the link end is placed, whereas the second entry is the reference point on this body (typically the ground station). In the case where the second entry is empty (as is often the case for spacecraft), the body’s center of mass is used.

Here, we want to create a set of link ends that use each of the ground stations as a receiver, and the spacecraft as a transmitter, as well as vice-versa. We do this by:

// Create list of link ends in which station is receiver and in which station is transmitter (with spacecraft other link end).
std::vector< LinkEnds > stationReceiverLinkEnds;
std::vector< LinkEnds > stationTransmitterLinkEnds;

for( unsigned int i = 0; i < groundStationNames.size( ); i++ )
    LinkEnds linkEnds;
    linkEnds[ transmitter ] = std::make_pair( "Earth", groundStationNames.at( i ) );
    linkEnds[ receiver ] = std::make_pair( "Vehicle", "" );
    stationTransmitterLinkEnds.push_back( linkEnds );

    linkEnds.clear( );
    linkEnds[ receiver ] = std::make_pair( "Earth", groundStationNames.at( i ) );
    linkEnds[ transmitter ] = std::make_pair( "Vehicle", "" );
    stationReceiverLinkEnds.push_back( linkEnds );

For instance, stationReceiverLinkEnds.at( 1 ) will now denote a set of link ends where the spacecraft is the transmitter, and the ground station termed "Station2" is the receiver.

Next, we need to define which link ends are to be used for which observable. We do this somewhat arbitrarily, and define:

// Define (arbitrarily) link ends to be used for 1-way range, 1-way doppler and angular position observables
std::map< ObservableType, std::vector< LinkEnds > > linkEndsPerObservable;
linkEndsPerObservable[ one_way_range ].push_back( stationReceiverLinkEnds[ 0 ] );
linkEndsPerObservable[ one_way_range ].push_back( stationTransmitterLinkEnds[ 0 ] );
linkEndsPerObservable[ one_way_range ].push_back( stationReceiverLinkEnds[ 1 ] );

linkEndsPerObservable[ one_way_doppler ].push_back( stationReceiverLinkEnds[ 1 ] );
linkEndsPerObservable[ one_way_doppler ].push_back( stationTransmitterLinkEnds[ 2 ] );

linkEndsPerObservable[ angular_position ].push_back( stationReceiverLinkEnds[ 2 ] );
linkEndsPerObservable[ angular_position ].push_back( stationTransmitterLinkEnds[ 1 ] );

Where you can see that the ObservableType enumeration denotes which types of observations are considered. Here, we limit ourselves to 1-way range, 1-way Doppler and angular position observables.

Now that we have defined which link ends are used for which observables, we can start adding more properties to the observation models. This is done by using the ObservationSettings class. This class is discussed in more detail on the page Observation Settings. For this tutorial, we restrict ourselves to simple observation models (which do not require any information in addition to their type) and we do not use observation biases or light-time corrections.

The resulting code to create settings for the observation models then becomes:

observation_models::ObservationSettingsMap observationSettingsMap;
for( std::map< ObservableType, std::vector< LinkEnds > >::iterator linkEndIterator = linkEndsPerObservable.begin( );
     linkEndIterator != linkEndsPerObservable.end( ); linkEndIterator++ )
    ObservableType currentObservable = linkEndIterator->first;

    std::vector< LinkEnds > currentLinkEndsList = linkEndIterator->second;
    for( unsigned int i = 0; i < currentLinkEndsList.size( ); i++ )
        // Define settings for observable, no light-time corrections, and biases for selected 1-way range links
        observationSettingsMap.insert( std::make_pair( currentLinkEndsList.at( i ),
                                                       std::make_shared< ObservationSettings >( currentObservable ) ) );

Where we have defined a map ObservationSettingsMap (a typedef for std::multimap< LinkEnds, std::shared_ptr< ObservationSettings > >) that contains all the settings necessary to create the observation models.

11.2. Defining Estimation Settings

We have now defined the settings for the observation models that are to be used. Next are the settings for the parameters that are to be estimated. In this tutorial, we use only a limited set of parameters, namely:

  • The spacecraft initial state \(x_{0}\), where use only a single arc to estimate its dynamics.
  • A constant radiation pressure coefficient \(C_{r}\) of the spacecraft (assuming a cannonball radiation pressure model)
  • A constant aerodynamic drag coefficient \(C_{D}\) of the spacecraft
  • Spherical harmonic cosine coefficients at degree 2, and orders 0 to 2 (so \(C_{20}, C_{21}, C_{22}\))
  • Spherical harmonic sine coefficients at degree 2, and orders 1 to 2 (so \(S_{21}, S_{22}\))

Defining the settings for these parameters is done by:

// Define list of parameters to estimate.
std::vector< std::shared_ptr< EstimatableParameterSettings > > parameterNames;
parameterNames.push_back( std::make_shared< InitialTranslationalStateEstimatableParameterSettings< double > >(
                              "Vehicle", systemInitialState, "Earth" ) );
parameterNames.push_back( std::make_shared< EstimatableParameterSettings >( "Vehicle", radiation_pressure_coefficient ) );
parameterNames.push_back( std::make_shared< EstimatableParameterSettings >( "Vehicle", constant_drag_coefficient ) );
parameterNames.push_back( std::make_shared< SphericalHarmonicEstimatableParameterSettings >(
                              2, 0, 2, 2, "Earth", spherical_harmonics_cosine_coefficient_block ) );
parameterNames.push_back( std::make_shared< SphericalHarmonicEstimatableParameterSettings >(
                              2, 1, 2, 2, "Earth", spherical_harmonics_sine_coefficient_block ) );

details on the set up of the parameters can be found on the page Creating Estimated Parameters. The general idea behind the settings may be familiar: they are similar to the acceleration settings. Some parameters (\(C_{r}\) and \(C_{D}\)) require no information in addition to the type of parameter and associated bodies and are created using the EstimatableParameterSettings base class. The other parameters require additional information, and have a dedicated derived class.

Now, the actual objects that are used in the simulation are created by:

// Create parameters
std::shared_ptr< estimatable_parameters::EstimatableParameterSet< double > > parametersToEstimate =
        createParametersToEstimate( parameterNames, bodyMap );

// Print identifiers and indices of parameters to terminal.
printEstimatableParameterEntries( parametersToEstimate );

Where the second part (i.e., printEstimatableParameterEntries) is optional, and produces a list of the estimated parameters to your console. The output should be something like:

 Parameter start index, Parameter definition
 0, translational state of (Vehicle).
 6, radiation pressure coefficient of (Vehicle).
 7, constant drag coefficient of (Vehicle).
 8, cosine spherical harmonic coefficient block of (Earth), Minimum D/O: (2, 0), Maximum D/O: (2, 2).
11, sine spherical harmonic coefficient block of (Earth), Minimum D/O: (2, 1), Maximum D/O: (2, 2).

which provides information on the physical meaning of the entries of the parameter vector (note that the order is not necessarilly the same as in the parameterNames list). Here, the initial state starts at index 0, the radiation pressure at index 6, etc.

11.3. Initializing Dynamics, Observation Models and Partial Derivatives

All required objects that compute the dynamics, variational equations, observation models and observation partials are created by the following line of code:

// Create orbit determination object (propagate orbit, create observation models)
OrbitDeterminationManager< double, double > orbitDeterminationManager =
        OrbitDeterminationManager< double, double >(
            bodyMap, parametersToEstimate, observationSettingsMap,
            integratorSettings, propagatorSettings );

The OrbitDeterminationManager object that is created will automatically propagate the dynamics (accordinng to the integratorSettings and propagatorSettings), as well as the associated variational equations (according to, in this case, the same propagatorSettings). Observation models are created using observationSettingsMap, as well as the associated models for the observation partial derivatives. More details can be found in Creating the estimation object.

11.4. Simulating Observations

The tutorial is concerned with using simulated data to perform the estimation. Here, we discuss how to generate simulated observations. First, we start by defining the times at which we want to simulate observations:

// Define time of first observation
double observationTimeStart = initialEphemerisTime + 1000.0;

// Define time between two observations
double  observationInterval = 20.0;

// Simulate observations for 3 days
std::vector< double > baseTimeList;
for( unsigned int i = 0; i < 3; i++ )
    // Simulate 500 observations per day (observationInterval apart)
    for( unsigned int j = 0; j < 500; j++ )
        baseTimeList.push_back( observationTimeStart + static_cast< double >( i ) * 86400.0 +
                                static_cast< double >( j ) * observationInterval );

So, we start simulating at \(t=t_{0}+1000\) (with \(t_{0}\) the start time of the simulation), and then simulate 500 simulations 20 seconds apart at the start of each of the 3 days in the simulations. This list of time is then stored in the baseTimeList vector.

In general, observation times will be different for each link end/observable type. Here, however, we take a simpler approach and use the same observation time for each link:

// Create measureement simulation input
std::map< ObservableType, std::map< LinkEnds, std::pair< std::vector< double >, LinkEndType > > > measurementSimulationInput;
for( std::map< ObservableType, std::vector< LinkEnds > >::iterator linkEndIterator = linkEndsPerObservable.begin( );
     linkEndIterator != linkEndsPerObservable.end( ); linkEndIterator++ )
    // Define observable type and link ends
    ObservableType currentObservable = linkEndIterator->first;
    std::vector< LinkEnds > currentLinkEndsList = linkEndIterator->second;

    // Define observation times and reference link ends
    for( unsigned int i = 0; i < currentLinkEndsList.size( ); i++ )
        measurementSimulationInput[ currentObservable ][ currentLinkEndsList.at( i ) ] =
                std::make_pair( baseTimeList, receiver );

This code iterates over all observable types and link ends (which were stored in the linkEndsPerObservable variable), and then populate the measurementSimulationInput map. This map contains a list of observation times for each link ends/observable. Note that the input to the map is std::make_pair( baseTimeList, receiver ), not only baseTimeList. The receiver identifier denotes that the observation time is valid at reception of the signal (not at its transmission).

Simulating the observations is then done as:

// Set typedefs for POD input (observation types, observation link ends, observation values, associated times with
// reference link ends.
typedef Eigen::Matrix< double, Eigen::Dynamic, 1 > ObservationVectorType;
typedef std::map< LinkEnds, std::pair< ObservationVectorType, std::pair< std::vector< double >, LinkEndType > > >
typedef std::map< ObservableType, SingleObservablePodInputType > PodInputDataType;

// Simulate observations
PodInputDataType observationsAndTimes = simulateObservations< double, double >(
            measurementSimulationInput, orbitDeterminationManager.getObservationSimulators( ) );

In this simulation, we have completely neglected the fact that the spacecraft may not be visible from the ground station from which the observation is taken. Tudat has the capabilities to prune the observations with this (and other) checks, but this is discussed in a later tutorial (and in more detail on the page on Observation Viability Setttings). The simulated data type observationsAndTimes now contains a simulated observables, along with information on the associated observable type, link ends and times.

11.5. Performing the Estimation

Now that we have our simulated data and our estimation objects all ready to go, we can perform the actual simulated estimation. Since this is a simulated scenario without noise, we first need to perturb our parameter vector a bit, otherwise the postfit residuals will all be exactly zero even on the first iteration. This we do by:

// Perturb parameter estimate
Eigen::Matrix< double, Eigen::Dynamic, 1 > initialParameterEstimate =
        parametersToEstimate->template getFullParameterValues< double >( );
Eigen::Matrix< double, Eigen::Dynamic, 1 > truthParameters = initialParameterEstimate;
Eigen::Matrix< double, Eigen::Dynamic, 1 > parameterPerturbation =
        Eigen::Matrix< double, Eigen::Dynamic, 1 >::Zero( truthParameters.rows( ) );
parameterPerturbation.segment( 0, 3 ) = Eigen::Vector3d::Constant( 10.0 );
parameterPerturbation.segment( 3, 3 ) = Eigen::Vector3d::Constant( 1.0E-2 );
parameterPerturbation( 6 ) = 0.01;
parameterPerturbation( 7 ) = 0.01;
initialParameterEstimate += parameterPerturbation;

In which we perturb the initial position and velocity by 10 m and 0.01 m/s, respectively. Both \(C_{r}\) and \(C_{D}\), we perturb by 0.01. Note that only the parameters of the model are changed, so that the estimation should converge (to within its numerical capabilities) to the original parameter set.

We define the input to the estimation with the PodInput class:

// Define estimation input
std::shared_ptr< PodInput< double, double > > podInput =
        std::make_shared< PodInput< double, double > >(
            observationsAndTimes, initialParameterEstimate.rows( ),
            Eigen::MatrixXd::Zero( truthParameters.rows( ), truthParameters.rows( ) ),
            initialParameterEstimate - truthParameters );
podInput->defineEstimationSettings( true, true, false, true );

where details on the input (and the defineEstimationSettings function) is given here: Defining estimation input. Additionally, since we are using different observables we must set their weights explicitly (they are all set as 1 if we don’t). This we do by:

// Define observation weights (constant per observable type)
std::map< observation_models::ObservableType, double > weightPerObservable;
weightPerObservable[ one_way_range ] = 1.0 / ( 1.0 * 1.0 );
weightPerObservable[ angular_position ] = 1.0 / ( 1.0E-5 * 1.0E-5 );
weightPerObservable[ one_way_doppler ] = 1.0 / ( 1.0E-11 * 1.0E-11 );
podInput->setConstantPerObservableWeightsMatrix( weightPerObservable );

which sets the expected range data precision at 1.0 m, the angular position data at 10 mrad, and the Doppler data at \(10^{-11}\) (Doppler data is range-rate uncertainty non-dimensionalized by the speed of light).

The estimation is then performed by:

// Perform estimation
std::shared_ptr< PodOutput< double > > podOutput = orbitDeterminationManager.estimateParameters(
            podInput, std::make_shared< EstimationConvergenceChecker >( 4 ) );

Where the index 4 indicates that the estimation will perform 4 iterations. The estimation should produce output similar to the following:

Calculating residuals and partials 13500
Parameter update   -6.08378    -18.9676    -7.76344 -0.00696149  -0.0186691 -0.00883959   -0.165673  -0.0139745 -1.4458e-09 9.05548e-08 3.77696e-08 1.44452e-07   8.374e-10
Current residual: 2502.59
Warning, tabulated ephemeris is being reset using data at different precision
Calculating residuals and partials 13500
Parameter update    -3.91642      8.96792     -2.23662  -0.00303872   0.00866954  -0.00116045      0.15567   0.00397531  1.44563e-09 -9.05592e-08  -3.7772e-08 -1.44462e-07 -8.40113e-10
Current residual: 1.40276
Warning, tabulated ephemeris is being reset using data at different precision
Calculating residuals and partials 13500
Parameter update 0.000194697 -0.000314532  5.82188e-05  2.08074e-07 -4.85731e-07  4.99801e-08   4.5677e-06 -2.21992e-06  2.18631e-13   4.6825e-12  2.48334e-12  9.83626e-12  2.55367e-12
Current residual: 0.000221693
Warning, tabulated ephemeris is being reset using data at different precision
Calculating residuals and partials 13500
Parameter update 5.18789e-06 -9.23697e-06 -2.86618e-06  4.95883e-09  4.12459e-09  2.61187e-09 -2.04626e-06  1.16347e-06 -5.01255e-14 -2.42908e-13 -1.31398e-13  9.26677e-14  1.81624e-13
Current residual: 0.000496538
Maximum number of iterations reached
Final residual: 0.000221693

which shows the estimation progress. Clearly, no improvements are made in the final iteration, so that only 3 iterations would have been needed. The example also prints the true and formal estimation errors where, in this case, the true error is much smaller, as the observations are noise-free (and not noisy at the level presumed by the weights). The performance is in this case only limited by the numerical precision, causing the initial state to be estimated at the 0.01 mm level. The simulation also prints various quantities to files, which are then processed by the MATLAB function provided.