Hi @MaximeJ,

Thank you for all the info. I have just gotten back into this, so haven’t had time to try out the UnivariateProcessNoise class yet. I imagine that it will be fine using only the diagonal elements since I am working with less accurate orbit determination measurements and don’t need to be too precise at this point. Will let you know if I get it working.

I did however attempt to do the transform for each step, though no longer seem to have a converging filter as a result. Below is a code snippet of my implementation:

```
class filt_covar_provider(PythonCovarianceMatrixProvider):
def getInitialCovarianceMatrix(self, initial):
i_cov = JArray_double(len(init_cov))
# Initial diagonal covariance into Java
for x,i in enumerate(init_cov):
i_cov[x] = i
return MatrixUtils.createRealDiagonalMatrix(i_cov)
def getProcessNoiseMatrix(self, prev, curr):
t_meas = abs(curr.getDate().durationFrom(prev.getDate()))
if t_meas > 0.0:
meas_delta_t = t_meas
else:
t_meas = meas_delta_t
return xform_vnc_to_j2k(curr, get_proc_noise_mat(t_meas))
vnc_acc_sig = [(2.4e-11)**2, (1.4e-9)**2, (5e-9)**2] # final values from AURA in paper
# Custom Process Noise Matrix
def get_proc_noise_mat(t):
Q = Array2DRowRealMatrix(6, 6)
for i in range(3):
Q.setEntry(i, i, (vnc_acc_sig[i] * t**4 / 3))
Q.setEntry(i, i+3, (vnc_acc_sig[i] * t**3 / 2))
for i in range(3,6):
Q.setEntry(i, i, (vnc_acc_sig[i-3] * t**2))
Q.setEntry(i, i-3, (vnc_acc_sig[i-3] * t**3 / 2))
return RealMatrix.cast_(Q)
# Transform the covariance to J2000
def xform_vnc_to_j2k(curr_state, cov_mat_vnc):
# Get dummy propagator to build VNC frame
propagator_num.resetInitialState(curr_state)
vnc = LocalOrbitalFrame(j2k_frame, LOFType.VNC, propagator_num, 'VNC')
sc_state = propagator_num.getInitialState()
# Get frozen orbit and Jacobian
vnc_to_j2k_frozen = vnc.getTransformTo(j2k_frame, sc_state.date).freeze()
jacobianDoubleArray = JArray_double2D(6, 6)
vnc_to_j2k_frozen.getJacobian(CartesianDerivativesFilter.USE_PV, jacobianDoubleArray)
jacobian = Array2DRowRealMatrix(jacobianDoubleArray)
cov_mat_j2k_java = jacobian.multiply(cov_mat_vnc.multiply(cov_mat_vnc.transpose()))
return cov_mat_j2k_java
```

To start off, I just took the sigmas from Aura listed in the paper (can calibrate later once I get it working).

When I run the filter, it diverges fairly quickly, so I am afraid that my implementation of the transform was not done properly.