# Covariance propagation with modeled maneuvers

Hi all,

I’m trying to implement a covariance propagation model considering a modelled (known and error-free) maneuver.
The model is based on the following paper offering different methodologies to assert the covariance propagation with maneuvers.

On a first approach, as mentionned above, the maneuver would be considered as perfect, with no errors, and its effect can be reflected on the state transition matrix at the maneuver triggering time (see page 2 of above paper, method A).

Before proceeding with the implementation, I would like to make sure such applicative layer is not already available in Orekit.
Indeed, an unique impulsive maneuver, could be considered as an external force model influencing the covariance state transition matrix. Correct me if I’m wrong, but if so, then a propagator setup with a STM and maneuver could actually provide a Covariance matrix influenced by the maneuver, right ?

Similarly, could we consider the same approach for a finite maneuver scenario implementing a basic constant thrust propulsion model ?

In future development, with uncertainties added to the maneuver model, we might need to consider a custom implementation though…

Best regards,
Gueorguy Serafimov

Hi @Gueorguy,

Orekit already supports maneuvers’ estimation (thrust, orientation and dates), see for example the tutorial ManeuversEstimation by GC.
(The OD tutorials are a bit hard to understand because most of the work is done in `AbstractOrbitDetermination` with some customization for each type of propagator.)

To do so, there are some internal mechanisms computing the STM, so it’s actually already doable to propagate the covariance and have the STM or covariance of the maneuvers’ parameters.
Unfortunately (but that should change soon) you cannot directly use the `StateCovarianceMatrixProvider` since for now it only propagates the orbital covariance.
You’ll have to do it the “old way”, look for example how it’s done in method KalmanModel.getErrorStateTransitionMatrix.
You’ll need to:

• First define the maneuver using for example a ConstantThrustManeuver.
• “Select” the maneuver `ParameterDriver`s that you want to have in the STM:
`maneuver.getParameterDriver(driverName).setSelected(true)`
• Then setup your propagator with a matrices’ “harvester”
`MatricesHarvester harvester = propagator.setupMatricesComputation("stm", null, null);` (assuming initial STM is null)
• Then, during propagation, assuming you have a propagated `state` a time t, you can get:
• the STM: `RealMatrix dYdY0 = harvester.getStateTransitionMatrix(state);`
• the Jacobian of the propagation maneuvers: `RealMatrix dYdPp = harvesters.getParametersJacobian(state);`
This last one contains the derivatives of the state a t with respect to the maneuver’s parameters selected in the second step. I’m assuming this is what you want ?

Yes, it’s done in the Kalman filter’s “prediction” step: P(t) = \Phi(t,t_0) * P(t_0) * \Phi^T(t,t_0) + Q(t)
With:

• P(t_0), P(t) the covariances a t0 and t
• \Phi(t, t_0) the STM + Jacobian of parameters between t0 and t
• Q(t) the process noise matrix (can be hard to define)

That’s the one I actually provided. The `ImpulseManeuver` in Orekit is an `EventDetector` (not a `ForceModel`) so the mechanism above won’t work. There’s a work around though, which is to consider a very small constant thrust maneuver (1 second should work well).

For this I think you should try to define a proper process noise model (as mentioned above). There’s a basic class for this in Orekit called UnivariateProcessNoise. Maybe you will have to improve it.

Hope this helps.
Best regards,
Maxime

1 Like

Hi Maxime,

Thanks a lot for the detailed answer ! It helps a lot.

Just to make sure I fully understand the methodology on the Covariance computation:
The State Transition Matrix required to compute the Covariance matrix at the maneuver time tm is a sum of the propagation STM and the Jacobian matrix of the propagated matrix.
In this case scenario I still neglect the process noise matrix. We obtain the following equation:

$P\left ( t_{m}\right ) = \left (STM\left ( {t_{m}}, t_{0}\right ) + J\left ( t_{m}, t_{0} \right ) \right ) \times P\left ( t_{0} \right )\times \left (STM\left ( {t_{m}}, t_{0}\right ) + J\left ( t_{m}, t_{0} \right ) \right )^{T}$

And similarly, If I wish to compute the finale state Covariance, then I should apply the same formula at tf > tm, with the STM matrix and Jacobian paremeters extracted at tf.

A question came out from this:
Should we consider a loss in the Covariance computation model accuracy in case of long finite maneuvers ?
“Long” is a term yet to be defined. Thus, we might want to virtually discretize the maneuver into maximum duration thrust sections, perform intermediate Covariance computations, and reset the STM within the propagator at each step.

If we consider n sections, with 0 <i<n, we would obtain something like this at each computation steps:

$P\left ( t_{i} \right ) = \Phi \left ( t_{i}, t_{i-1} \right ).P\left ( t_{i-1} \right ).\Phi \left ( t_{i}, t_{i-1} \right )^{T}$
And the propagation final state Covariance matrix would be obtained as followed:

$P\left ( t_{f} \right ) = \Phi \left ( t_{f}, t_{n} \right ).P\left ( t_{n} \right ).\Phi \left ( t_{f}, t_{n} \right )^{T}$

If I’m not wring, this approach would also be necessary in case the process noise matrix is considered.

Best regards,
Gueorguy

Hi @Gueorguy,

You’re welcome !

Just to be clear it’s not a “sum” as in a matrix sum but more a matrix concatenation, see the comments at the beginning of KalmanModel.getErrorStateTransitionMatrix method for a proper equation.
Sorry if my first answer was misleading since I used the “+” sign.

Yes

I would tend to define this loss of accuracy with a process noise matrix instead and keep the linear model of the STM on the other hand.

I’m not sure to follow.
Know that the STM is a first order linearization and that you have:
\Phi(t_f,t_0) = \Phi(t_f, t_i) * \Phi(t_i, t_0) for any ti in [t0, tf]. So P_f = \Phi(t_f,t_0)*P_0*\Phi^T(t_f,t_0)=\Phi(t_f,t_i)*\Phi(t_i,t_0)*P_0*\Phi^T(t_i,t_0)*\Phi^T(t_f,t_i)=\Phi(t_f,t_i)*P_i*\Phi^T(t_f,t_i)
So stopping the propagation to get the covariance at each computation step won’t change the final value, unless you change the covariance at each ti to account for the loss of accuracy.
That being said, maybe I didn’t understand your point.

Best regards,
Maxime