# 4.4. Setting Up Estimated Parameters¶

## 4.4.1. Parameter Architecture¶

The parameter estimation framework of Tudat allows an ever increasing variety of parameters to be estimated, these parameters may be:

• Properties of a body, such as a gravitational parameter $$\mu$$
• Properties of a ground station, such as its body-fixed position $$\mathbf{x}_{GS}^{(B)}$$
• Global properties of the simulation, such a Parameterize Post_Newtonian (PPN) parameters $$\gamma$$ and $$\beta$$
• Acceleration model properties, such as empirical acceleration magnitudes
• Observation model properties, such as absolute and relative observation biases

In Tudat, these parameters influence the simulation in a variety of manners, and during propagation and/or observation simulation, information of this parameter is transferred in manner different ways. To provide a unified framework for estimating any type of parameter, the EstimatableParameter class has been set up.

class EstimatableParameter

This class has interfaces to retrieve and reset parameters, providing a single interface for modifying/obtaining any of the parameters that Tudat supports. For each estimated parameter, there is a dedicated derived class of EstimatableParameter.

class EstimatableParameterSet

The full list of estimated parameters is stored in an object of type EstimatableParameterSet. This class is templated by the state scalar type of the estimated initial state parameters.

Note

For the remainder of this page, we will implicitly assume that the template argument of an EstimatableParameterSet object is double, unless explicitly mentioned otherwise.

As is the case for acceleration models, integration models, environment models, etc., the parameter objects are created by defining settings for them, and subsequently calling the associated factory function. The settings and passed by creating objects of type EstimatableParameterSettings (or one of its derived classes). Some parameters settings are provided through the EstimatableParameterSettings base class, and some through its derived classes. A full list is provided in the section on Creating Estimated Parameters. An example of the creation of the parameter objects is given below:

// Define parameter settings
std::vector< std::shared_ptr< EstimatableParameterSettings > > parameterNames;
parameterNames.push_back( std::make_shared< EstimatableParameterSettings >(
parameterNames.push_back( std::make_shared< EstimatableParameterSettings >(
"Vehicle", constant_drag_coefficient ) );
parameterNames.push_back(  std::make_shared< EstimatableParameterSettings >(
"Earth", rotation_pole_position ) );

// Define parameter objects
std::shared_ptr< EstimatableParameterSet< double > > parametersToEstimate =
createParametersToEstimate( parameterNames, bodyMap );


Which creates parameter objects for the radiation pressure coefficient and drag coefficient of body “Vehicle”, and the orientation of the rotation axis of the body “Earth”.

The EstimatableParameterSet object contains three objects that have EstimatableParameter as base class (one for each parameter). We distinguish two types of EstimatableParameter objects:

• Those that represent initial conditions for dynamics (denoted as $$\mathbf{x}_{0}$$ below)
• Those that represent fixed parameters for environment, acceleration or observation models (denoted as $$\mathbf{q}$$ below)

Resetting the full parameter vector $$\mathbf{p}(=[\mathbf{x}_{0};\mathbf{q}])$$ is done as follows (for double state scalar type):

// Create parameter set
std::shared_ptr< EstimatableParameterSet< double > > parametersToEstimate = ...

Eigen::VectorXd parameterVector =
parametersToEstimate->getFullParameterValues< double >( );


While resetting the full parameter vector is done as:

// Create parameter set
std::shared_ptr< EstimatableParameterSet< double > > parametersToEstimate = ...

// Define vector of new values of estimated parameters
Eigen::VectorXd newParameterVector = ...

// Reset parameter values
parametersToEstimate->resetParameterValues< double >( );


When resetting the parameter vector, the change in the values in $$\mathbf{q}$$ immediately take effect. For the initial state parameters to take effect, however, the dynamics must be re-propagated. This occurs automatically when estimating parameters. It can also be performed manually by calling the resetParameterEstimate member function of the VariationalEquationsSolver class.

## 4.4.2. Creating Estimated Parameters¶

The framework discussed in the previous section explains how the parameterNames is populated. The goal of this section is to list the available parameters that can be estimated, and which environment models they are linked to.

class EstimatableParameterSettings

This base-class is a generic method to define parameters that require no more information than their type, the associated body, and (in some cases) a secondary identifier. Variables are added to the parameterNames using the following code:

parameterNames.push_back(
std::make_shared< EstimatableParameterSettings >( associatedBody, parameterType, secondaryIdentifier ) );


where: - associatedBody

Name of body for which the parameter is estimated, as std::string.
• parameterType

EstimatebleParametersEnum variable that can take the following values:

• gravitational_parameter. Gravitational parameter of a body, linked to a GravityFieldModel object, which may be a point-mass or (time-dependent) spherical harmonic field. Parameter size: 1. Secondary identifer: None.
• constant_drag_coefficient. Drag coefficient of a body that is constant, linked to a CustomAerodynamicCoefficientInterface object derived from AerodynamicCoefficientInterface, which must have 0 independent variables for the coefficients. Parameter size: 1. Secondary identifer: None.
• constant_rotation_rate. Rotation rate of a body around a fixed axis, linked to a SimpleRotationalEphemeris object derived from RotationalEphemeris. Parameter size: 1. Secondary identifer: None.
• radiation_pressure_coefficient. Constant radiation pressure coefficient of a body, linked to a RadiationPressureInterface object. Parameter size: 1. Secondary identifer: None.
• rotation_pole_position. Fixed rotation axis about which a body rotates with a fixed rotation rate, linked to a SimpleRotationalEphemeris object. Parameter size: 2 (denoting pole right ascension and declination). Secondary identifer: None.
• ground_station_position. Fixed body-fixed position of a ground station on a body, linked to a GroundStationState object (requires a GroundStationState class). Parameter size: 3 (denoting body-fixed x, y and z Cartesian position). Secondary identifer: Ground station name.
• ppn_parameter_gamma. Parameter $$\gamma$$ used in Parametric Post-Newtonian (PPN) framework, linked to a PPNParameterSet object (nominally the global relativity::ppnParameterSet variable). Parameter size: 1. Note that the name of the associated body should be "global_metric". Secondary identifer: None.
• ppn_parameter_beta. Parameter $$\beta$$ used in Parametric Post-Newtonian (PPN) framework, linked to a PPNParameterSet object (nominally the global relativity::ppnParameterSet variable). Parameter size: 1. Note that the name of the associated body should be "global_metric". Secondary identifer: None.
• equivalence_principle_lpi_violation_parameter. Parameter used to compute influence of a gravitational potential on proper time rate, equals 0 in general relativity, not linked to any object, but instead the equivalencePrincipleLpiViolationParameter global variable (in namespace relativity. Parameter size: 1. Note that the name of the associated body should be "global_metric". Secondary identifer: None.
• secondaryIdentifier

Secondary identifier to define the estimated parameter (if necessary, see above), as std::string. Empty by default.

class InitialTranslationalStateEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for estimating an initial translational state of a single body. It is templated by the state scalar type of the dynamics (typically double). Two constructors are available for this class. The first constructor explicitly provides the current value of the initial state, while the second extracts the initial state from the current ephemeris of the body. The first constructor is called as:

parameterNames.push_back(
std::make_shared< InitialTranslationalStateEstimatableParameterSettings< double > >(
associatedBody, initialStateValue, centralBody, frameOrientation  ) );


where:

• associatedBody

Name of body for which the initial state is to be estimated, as std::string.

• initialStateValue

Initial state (Eigen::Vector6d) of associatedBody w.r.t. centralBody in Cartesian coordinates, expressed frame frameOrientation.

• centralBody

Name of body w.r.t. which the dynamics is to be estimated, as std::string.

• frameOrientation

Orientation in the frame in which the dynamics is to be estimated, as std::string.

The second constructor is called as:

parameterNames.push_back(
std::make_shared< InitialTranslationalStateEstimatableParameterSettings< double > >(
associatedBody, initialTime, centralBody, frameOrientation  ) );


where:

• associatedBody

Name of body for which the initial state is to be estimated, as std::string.

• initialTime

Time (double) at which the body’s ephemeris is to be interrogated to extract the initial state. If the ephemeris origin is not equal to centralBody, any required frame translations are applied.

• centralBody

Name of body w.r.t. which the dynamics is to be estimated, as std::string.

• frameOrientation

Orientation in the frame in which the dynamics is to be estimated, as std::string.

class ArcWiseInitialTranslationalStateEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for estimating an initial translational state of a single body in an arc-wise manner. It is templated by the state scalar type of the dynamics (typically double). As was the case for the InitialTranslationalStateEstimatableParameterSettings class, two constructors are available for this class. The first constructor explicitly provides the current value of the arc initial states, while the second extracts the arc initial states from the current ephemeris of the body. The first constructor is called as:

parameterNames.push_back(
std::make_shared< ArcWiseInitialTranslationalStateEstimatableParameterSettings< double > >(
associatedBody, concatenatedInitialStateValues, arcStartTimes, centralBody, frameOrientation  ) );


where:

• associatedBody

Name of body for which the initial state is to be estimated, as std::string.

• concatenatedInitialStateValues

Initial states (as Eigen::VectorXd) of associatedBody w.r.t. centralBody in Cartesian coordinates, expressed frame frameOrientation. This vector consists of the concatenated arc initial states, and must have a size 6 * arcStartTimes.size( ). With the initial state of arc $$j$$ denotes as $$\mathbf{x}_{j,0}$$, this input vector must be given as $$[\mathbf{x}_{1,0};\mathbf{x}_{1,0};...;\mathbf{x}_{N,0}]$$, for $$N$$ arcs.

• arcStartTimes

List of times (std::vector< double >) at which the arcs for which the dynamics is to be estimated start. The entries of this arcs must be continuously increasing: denoting the start time of arc $$j$$ as $$t_{j,0}$$, $$t_{j+1,0}>t_{j,0}$$ must always be satisfied.

• centralBody

Name of body w.r.t. which the dynamics is to be estimated, as std::string.

• frameOrientation

Orientation in the frame in which the dynamics is to be estimated, as std::string.

The second constructor is called as:

parameterNames.push_back(
std::make_shared< ArcWiseInitialTranslationalStateEstimatableParameterSettings< double > >(
associatedBody, arcStartTimes, centralBody, frameOrientation  ) );


where:

• associatedBody

Name of body for which the initial state is to be estimated, as std::string.

• arcStartTimes

List of times (std::vector< double >) at which the arcs for which the dynamics is to be estimated start. The entries of this arcs must be continuously increasing: denoting the start time of arc $$j$$ as $$t_{j,0}$$, $$t_{j+1,0}>t_{j,0}$$ must always be satisfied. The role of this variable is two-fold: firstly to inform the propagation on the times at which to switch to a new arc, and secondly to retrieve the initial state of each arc from the body’s ephemeris.

• centralBody

Name of body w.r.t. which the dynamics is to be estimated, as std::string.

• frameOrientation

Orientation in the frame in which the dynamics is to be estimated, as std::string.

class SphericalHarmonicEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for estimating spherical harmonic coefficients. Two constructors are available for this class. The first constructor allows a specific set of coefficients to be estimated and is used as follows:

parameterNames.push_back(
std::make_shared< SphericalHarmonicEstimatableParameterSettings >(
blockIndices, associatedBody, coefficientType ) );


where:

• blockIndices

A list of degrees/orders at which the coefficients should be estimated, of type std::vector< std::pair< int, int > >, with a single pair entry denoting the degree (first) and order (second) of a coefficient that is to be estimated. The vector can have arbitrary size, but may not contain repeated coefficients.

• associatedBody

The name of the body for which coefficients are to be estimated (as std::string).

• coefficientType

The type of coefficients that are estimated, must be either spherical_harmonics_cosine_coefficient_block or spherical_harmonics_sine_coefficient_block.

The second constructor defines a ‘full’ block of coefficients to be estimated: it sets all degrees and orders from given minimum and maximum degrees and orders as the estimated parameters. It is created from:

parameterNames.push_back(
std::make_shared< SphericalHarmonicEstimatableParameterSettings >(
minimumDegree, minimumOrder, maximumDegree, maximumOrder, associatedBody, coefficientType ) );


where:

• minimumDegree

Minimum degree of coefficients that are estimated.

• minimumOrder

Minimum order of coefficients that are estimated.

• maximumDegree

Maximum degree of coefficients that are estimated.

• maximumOrder

Maximum order of coefficients that are estimated.

• associatedBody

The name of the body for which coefficients are to be estimated (as std::string).

• coefficientType

The type of coefficients that are estimated, must be either spherical_harmonics_cosine_coefficient_block or spherical_harmonics_sine_coefficient_block.

As an example:

parameterNames.push_back(
std::make_shared< SphericalHarmonicEstimatableParameterSettings >(
2, 1, 4, 3, "Earth", spherical_harmonics_cosine_coefficient_block ) );


Sets $$C_{21}, C_{22}, C_{31}, C_{32},C_{33}, C_{41}, C_{42}, C_{43}$$ as the estimated parameters.

Note

If a full set of coefficients is to be estimated, ensure that two SphericalHarmonicEstimatableParameterSettings objects are created: one for cosine and one for sine coefficients (unless only order 0 coefficients are estimated, which have no sine coefficients)

class FullDegreeTidalLoveNumberEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for tidal Love numbers $$k_{n}$$ at degree $$n$$ that are constant over all all orders at that degree (so for $$n=2, k_{20}=k_{21}=k_{22}$$. The estimated parameters are a property of an BasicSolidBodyTideGravityFieldVariations object. It is created by:

parameterNames.push_back(
std::make_shared< FullDegreeTidalLoveNumberEstimatableParameterSettings >(
associatedBody, degree, deformingBodies, useComplexValue ) );


where:

• associatedBody

An std::string that gives the name of the body for which the Love number is to be estimated.

• degree

An int that denotes the degree $$n$$ of the Love number that is estimated.

• deformingBodies

List of bodies that cause tidal deformation of associatedBody, as an std::vector< std::string >. If, and only if, the body only has one BasicSolidBodyTideGravityFieldVariations, this list may be left empty and this single tidal model is used for estimating $$k_{n}$$. If this list of deforming bodies is not empty, it must match exactly the list of deforming bodies of the tidal model. In this way, multiple Love numbers at different forcing frequencies can be estimated (by creating multiple FullDegreeTidalLoveNumberEstimatableParameterSettings objects.

• useComplexValue

A bool that denotes whether to estimate the Love number as a real value (size 1) or a complex value (size 2). In the complex case, the imaginary part represents the impact of tidal dissipation.

class SingleDegreeVariableTidalLoveNumberEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for tidal Love numbers $$k_{nm}$$ at degree $$n$$ that are vary over the orders at that degree. The estimated parameters are a property of an BasicSolidBodyTideGravityFieldVariations object. It is created by:

parameterNames.push_back(
std::make_shared< SingleDegreeVariableTidalLoveNumberEstimatableParameterSettings >(
associatedBody, degree, orders deformingBodies, useComplexValue ) );


where:

• associatedBody

An std::string that gives the name of the body for which the Love numbers are to be estimated.

• degree

An int that denotes the degree $$n$$ of the Love numbers that are estimated.

• orders

An std::vector< int > that denotes the orders $$m$$ of the Love numbers that are to be estimated. For instance, for degree = 3 and orders = {2, 1, 3}, $$k_{32}, k_{31}$$ and $$k_{33}$$ are estimated

• deformingBodies

List of bodies that cause tidal deformation of associatedBody, as an std::vector< std::string >. If, and only if, the body only has one BasicSolidBodyTideGravityFieldVariations, this list may be left empty and this single tidal model is used for estimating $$k_{nm}$$. If this list of deforming bodies is not empty, it must match exactly the list of deforming bodies of the tidal model. In this way, multiple Love numbers at different forcing frequencies can be estimated (by creating multiple SingleDegreeVariableTidalLoveNumberEstimatableParameterSettings objects.

• useComplexValue

A bool that denotes whether to estimate the Love numbers as real value (size 1 per Love number) or a complex value (size 2 per Love number). In the complex case, the imaginary parts represent the impact of tidal dissipation.

class ConstantObservationBiasEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for estimating a constant absolute or relative observation biases for a given set of LinkEnds and ObservableType. Depending on the input, an object of this class defines settings for estimating an abolute or a relative bias. The bias model itself is created by using the ConstantObservationBiasSettings or ConstantRelativeObservationBiasSettings, and the estimated parameter is a property of an ConstantObservationBias of ConstantRelativeObservationBias object. The parameter estimation settings are creating by:

parameterNames.push_back(
std::make_shared< ConstantObservationBiasEstimatableParameterSettings >(


where:

• linkEnds

A LinkEnds map that defines the link ends (receiver, transmitter, etc.) for the bias.

• observableType

An ObservableType variable that denotes the type of observable for which the bias is to be estimated.

• isBiasAdditive

A bool that is true if the bias is absolute and false if it is relative.

class EmpiricalAccelerationEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for estimating a set of empirical accelerations that are constant throughout the propation interval. Coefficients can be estimated for each of the three directions in the RSW frame, and as a constant term, as well a sine/cosine of true anomaly (for a total of 9 possible coefficients). The parameter is a property of an object of type EmpiricalAcceleration, which is created by using an object of type EmpiricalAccelerationSettings The parameter estimation settings are creating by:

parameterNames.push_back(
std::make_shared< EmpiricalAccelerationEstimatableParameterSettings >(
associatedBody, centralBody, componentsToEstimate ) );


where:

• associatedBody

Name of body for which accelerations are to be estimated, as std::string.

• centralBody

Name of body central body about which the accelerated body is orbiting (e.g. the body w.r.t. which the Kepler elements are calculated), as std::string.

• componentsToEstimate

A list that defines the list of components that are to be estimated, of type std::map< EmpiricalAccelerationComponents, std::vector< EmpiricalAccelerationFunctionalShapes > >. The EmpiricalAccelerationComponents denotes the direction of the acceleration, and EmpiricalAccelerationFunctionalShapes whether a constant, sine or cosine coefficient is estimated. EmpiricalAccelerationComponents can take the values:

• along_track_empirical_acceleration_component
• across_track_empirical_acceleration_component

EmpiricalAccelerationFunctionalShapes can take the values:

• constant_empirical
• sine_empirical
• cosine_empirical

For instance, to estimate a constant along-track, a sine and cosine radial, and a constant and sine across-track empirical acceleration, the componentsToEstimate becomes:

std::map< EmpiricalAccelerationComponents, std::vector< EmpiricalAccelerationFunctionalShapes > > componentsToEstimate;
componentsToEstimate[ along_track_empirical_acceleration_component ].push_back( constant_empirical );

componentsToEstimate[ across_track_empirical_acceleration_component ].push_back( constant_empirical );
componentsToEstimate[ across_track_empirical_acceleration_component ].push_back( sine_empirical );

class ArcWiseEmpiricalAccelerationEstimatableParameterSettings

This derived class of EstimatableParameterSettings is used to define settings for estimating a set of empirical acceleration components that are arc-wise constant. Coefficients can be estimated for each of the three directions in the RSW frame, and as a constant term, as well a sine/cosine of true anomaly (for a total of 9 possible coefficients). The parameter is a property of an object of type EmpiricalAcceleration, which is created by using an object of type EmpiricalAccelerationSettings The parameter estimation settings are creating by:

parameterNames.push_back(
std::make_shared< EmpiricalAccelerationEstimatableParameterSettings >(
associatedBody, centralBody, componentsToEstimate, arcStartTimeList ) );


where:

• associatedBody

Name of body for which accelerations are to be estimated, as std::string.

• centralBody

Name of body central body about which the accelerated body is orbiting (e.g. the body w.r.t. which the Kepler elements are calculated), as std::string.

• componentsToEstimate

A list that defines the list of components that are to be estimated, of type std::map< EmpiricalAccelerationComponents, std::vector< EmpiricalAccelerationFunctionalShapes > >. The EmpiricalAccelerationComponents denotes the direction of the acceleration, and EmpiricalAccelerationFunctionalShapes whether a constant, sine or cosine coefficient is estimated. See above in documentation for EmpiricalAccelerationEstimatableParameterSettings for more details.

• arcStartTimeList

A list of times at which the arcs start during which the coefficients are to be estimated, of type std::vector< double >. For instance, when using:

std::vector< double > arcStartTimeList;
arcStartTimeList.push_back( 1000.0 );
arcStartTimeList.push_back( 7200.0 );
arcStartTimeList.push_back( 10000.0 );


One set of empirical accelerations will be estimated, that are used for $$1000<t<7200$$, one set for $$7200<t<10000$$ and one set for $$t>10000$$