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 bodyfixed 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 >( "Vehicle", radiation_pressure_coefficient ) ); 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 repropagated. 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 baseclass 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, asstd::string
.parameterType
EstimatebleParametersEnum
variable that can take the following values:gravitational_parameter
. Gravitational parameter of a body, linked to aGravityFieldModel
object, which may be a pointmass or (timedependent) spherical harmonic field. Parameter size: 1. Secondary identifer: None.constant_drag_coefficient
. Drag coefficient of a body that is constant, linked to aCustomAerodynamicCoefficientInterface
object derived fromAerodynamicCoefficientInterface
, 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 aSimpleRotationalEphemeris
object derived fromRotationalEphemeris
. Parameter size: 1. Secondary identifer: None.radiation_pressure_coefficient
. Constant radiation pressure coefficient of a body, linked to aRadiationPressureInterface
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 aSimpleRotationalEphemeris
object. Parameter size: 2 (denoting pole right ascension and declination). Secondary identifer: None.ground_station_position
. Fixed bodyfixed position of a ground station on a body, linked to aGroundStationState
object (requires aGroundStationState
class). Parameter size: 3 (denoting bodyfixed x, y and z Cartesian position). Secondary identifer: Ground station name.ppn_parameter_gamma
. Parameter \(\gamma\) used in Parametric PostNewtonian (PPN) framework, linked to aPPNParameterSet
object (nominally the globalrelativity::ppnParameterSet
variable). Parameter size: 1. Note that the name of the associated body should be"global_metric"
. Secondary identifer: None.ppn_parameter_gamma
. Parameter \(\beta\) used in Parametric PostNewtonian (PPN) framework, linked to aPPNParameterSet
object (nominally the globalrelativity::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 theequivalencePrincipleLpiViolationParameter
global variable (in namespacerelativity
. 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 (typicallydouble
). 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
) ofassociatedBody
w.r.t.centralBody
in Cartesian coordinates, expressed frameframeOrientation
.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 tocentralBody
, 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 arcwise manner. It is templated by the state scalar type of the dynamics (typicallydouble
). As was the case for theInitialTranslationalStateEstimatableParameterSettings
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
) ofassociatedBody
w.r.t.centralBody
in Cartesian coordinates, expressed frameframeOrientation
. This vector consists of the concatenated arc initial states, and must have a size6 * 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 twofold: 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
orspherical_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
orspherical_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 anBasicSolidBodyTideGravityFieldVariations
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 anstd::vector< std::string >
. If, and only if, the body only has oneBasicSolidBodyTideGravityFieldVariations
, 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 multipleFullDegreeTidalLoveNumberEstimatableParameterSettings
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 anBasicSolidBodyTideGravityFieldVariations
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, fordegree = 3
andorders = {2, 1, 3}
, \(k_{32}, k_{31}\) and \(k_{33}\) are estimateddeformingBodies
List of bodies that cause tidal deformation of
associatedBody
, as anstd::vector< std::string >
. If, and only if, the body only has oneBasicSolidBodyTideGravityFieldVariations
, 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 multipleSingleDegreeVariableTidalLoveNumberEstimatableParameterSettings
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 ofLinkEnds
andObservableType
. 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 theConstantObservationBiasSettings
orConstantRelativeObservationBiasSettings
, and the estimated parameter is a property of anConstantObservationBias
ofConstantRelativeObservationBias
object. The parameter estimation settings are creating by:parameterNames.push_back( std::make_shared< ConstantObservationBiasEstimatableParameterSettings >( linkEnds, observableType, isBiasAdditive ) );
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 typeEmpiricalAcceleration
, which is created by using an object of typeEmpiricalAccelerationSettings
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 > >
. TheEmpiricalAccelerationComponents
denotes the direction of the acceleration, andEmpiricalAccelerationFunctionalShapes
whether a constant, sine or cosine coefficient is estimated.EmpiricalAccelerationComponents
can take the values: radial_empirical_acceleration_component
 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 alongtrack, a sine and cosine radial, and a constant and sine acrosstrack empirical acceleration, the
componentsToEstimate
becomes:std::map< EmpiricalAccelerationComponents, std::vector< EmpiricalAccelerationFunctionalShapes > > componentsToEstimate; componentsToEstimate[ along_track_empirical_acceleration_component ].push_back( constant_empirical ); componentsToEstimate[ radial_empirical_acceleration_component ].push_back( sine_empirical ); componentsToEstimate[ radial_empirical_acceleration_component ].push_back( cosine_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 arcwise 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 typeEmpiricalAcceleration
, which is created by using an object of typeEmpiricalAccelerationSettings
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 > >
. TheEmpiricalAccelerationComponents
denotes the direction of the acceleration, andEmpiricalAccelerationFunctionalShapes
whether a constant, sine or cosine coefficient is estimated. See above in documentation forEmpiricalAccelerationEstimatableParameterSettings
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\)