 # Normalized Parameters Question

Dear All,
I apologize for constantly spamming the message board but I have yet another question. I am still wrestling with the conditioning of my covariance matrices. Obviously a way to deal with this is normalizing the orbital elements so that values are on roughly the same order of magnitude. So what I’m doing is setting the normalizedparameters used in the arguments for NumericalPropagatorBuilder.buildpropagator. For the keplerian case for example I set the normalized parameters to

new double[]{orbit.getA()/radiusEarth, orbit.getE()/1, orbit.getI/(Math.PI*2), orbit.getPerigeeArgument()/(Math.PI*2), orbit.getRightAscensionOfAscendingNode()/(Math.PI*2),orbit()).getAnomaly(PositionAngle)/(Math.PI*2)};

Then later I use the same normalizedparameters scheme except using the initial guess’ element for the batch least squares. I assume then that the using the optimum.getCovariance(0) would give me a normalized covariance. Is this correct or should i use the estimator.getPhysicalCovariance and then normalize using my own scheme?

The orbit determination process already normalizes the parameters internally, so you should not
have to do it by yourself. The automatic normalization process is controlled by a call in the constructor of `AbstractPropagatorBuilder`, which is the abstract class above all propagator builders. This call reads:

``````this.orbitalDrivers      = orbitType.getDrivers(positionScale, templateOrbit, positionAngle);
``````

If you look at all the implementations of `getDrivers` in the enumerate OrbitType (i.e. CARTESIAN, CIRCULAR, EQUINOCTIAL and KEPLERIAN), you will see that the `positionScale` is used to compute a proper scale for each orbital parameter.

The mathematical optimizer used in the orbit determination process will see the normalized parameters, not the physical parameters (i.e. in the `ParameterDriversList` returned by `getDriver`, the optimizer will use `get/setNormalizedValue()`, whereas the propagator will use `getValue`).

So you should not have to normalize by yourself, but you should:

• set a sensible value for `positionScale` in the propagator builder
• use an OrbitType for propagation that is stable for your orbit (i.e. avoid Keplerian if orbit is circular)

If you still get ill-conditioned matrices with this, you may have to look at your measurements, perhaps you don’t have the appropriate measurements or enough measurements to observe every orbital parameter.

1 Like

As a followup, what would you consider a sensible value for positionScale?

I would say something slightly more accurate than what you expect from your system. So if you aim to have orbit determination at centimeter level, put 0.001m as the scale. If on the other hand you expect orbit determination at 100m level, put 10m as the scale. Beware this scale is used in the numerical integrator as a threshold to compare against an error that is both estimated and local (i.e. on the current step only). So it may be different from the real and global error; in other word if you put 0.001m as the position error, it does not guarantee your orbit will have millimeter accuracy.