4.5. Parameter Estimation

4.5.1. Creating the estimation object

The estimation of orbits and physical parameters in Tudat is done through the use of an OrbitDeterminationManager object. This object is created once for a given set of estimated parameters, and may be (re-)used to reset and/or estimate parameters from a given set of data.

class OrbitDeterminationManager

Creating an object of this type automatically propagates both the equations of motion and variational equations using the input to its constructor. Additionally, a set of ObservationSimulatorBase objects is created, as well as all required objects to compute the partial derivatives of the observations.

An object is created as follows:

OrbitDeterminationManager orbitDeterminationManager =
      std::make_shared< ObservationViabilitySettings >(
          OrbitDeterminationManager( bodyMap, parametersToEstimate, observationSettingsMap, integratorSettings, propagatorSettings );

The input is:

  • bodyMap

    A NamedBodyMap variable which contains all information on the physical environment

  • parametersToEstimate

    A std::shared_ptr< EstimatableParameterSet< ObservationScalarType > > variable which contains the full list of parameters that are to be estimated.

  • observationSettingsMap

    A list of ObservationSettings that may be provided as either std::multimap< LinkEnds, std::shared_ptr< ObservationSettings > > or a std::map< ObservableType, std::map< LinkEnds, std::shared_ptr< ObservationSettings > >. In the former case, the list is sorter by LinkEnds only, in the latter by both ObservableType and LinkEnds

  • integratorSettings

    A std::shared_ptr< IntegratorSettings< TimeType > > object which contains all settings for the numerical integrator, used to numerically calcualte the dynamics and variational equations.

  • propagatorSettings

    A std::shared_ptr< PropagatorSettings< ObservationScalarType > > object which contains all propagation settings.


    The settings in PropagatorSettings and EstimatableParameterSet must be consistently defined: any initial state that is propagated must also be estimated, there is as yet no possibility to only estimate some of the propagates states.

After the creation of the OrbitDeterminationManager object, a number of objects are created internally that can be used for various purposes:

  • An object with base class VariationalEquationsSolver, which contains the numerically propagated variational equations and dynamics, can be retrieved using the getVariationalEquationsSolver member function.
  • A list of objects with base class ObservationSimulatorBase (one per observable type) to simulate observations, discussed in more detail on the page on Creating the Observation Simulator
  • A list of objects with base class ObservationManagerBase (one per observable type) to simulate observations and the associated partial derivatives. These objects are not directly accesed by users. Their output (partial derivatives of observables) are provided a posterior through an object of type PodOutput, discussed on the page on Estimation output.

4.5.2. Defining estimation input

The input to the estimation consists of several parts. Firstly, the input data, weights, etc. need to be defined, which is done through the PodInput class.

class PodInput

This class is templated by both ObservationScalarType and TimeType. An object of PodInput is created as follows:

std::shared_ptr< PodInput< ObservationScalarType, TimeType > > podInput =
      std::make_shared< PodInput< ObservationScalarType, TimeType >  >(
          observationsAndTimes, numberOfEstimatedParameters, inverseOfAprioriCovariance );

The input is:

  • observationsAndTimes A container of type std::map< ObservableType, std::map< LinkEnds, std::pair< Eigen::Matrix< ObservationScalarType, Eigen::Dynamic, 1 >, std::pair< std::vector< TimeType >, LinkEndType > > > > (the structure of which is described in more detail on the page Generating the observations). This container has both the observables to be used in the estimation, and the assictaed times and link end types.
  • numberOfEstimatedParameters An int denoting the length of the vector of estimated paramaters, discussed in more detail on the page Creating Estimated Parameters.
  • inverseOfAprioriCovariance An Eigen::MatrixXd with the inverse of the a priori covariance matrix. This input type may be left empty, in which case no a priori covariance is used.


Currently, Tudat only supports diagonal weight matrices, implicitly assuming independent observation noise in the inversion.

4.5.3. Estimation output

When performing the estimation, the code rescales the values of all parameters \(p\), where we denote the scaled parameters as \(\tilde{h}\), so that all partials \(\partial h/\partial\tilde{p}\) w.r.t. lie in the range \([-1,1]\). To provide transparency, it is the covariance and partial derivative matrix of these scaled parameters that is saved to the PodOutput object. However, the following functions allow you to retrieve the information w.r.t. the unscaled parameters:

  • Inverse covariance, obtained using the getUnnormalizedInverseCovarianceMatrix function.
  • Covariance, obtained using the getUnnormalizedCovarianceMatrix function. Note that this only produces valid results if the problem is not ill-posed.
  • Formal error vector, obtained using the getFormalErrorVector function. Note that this only produces valid results if the problem is not ill-posed.
  • Correlation matrix, obtained using the getCorrelationMatrix function. Note that this only produces valid results if the problem is not ill-posed.