Re: [Orekit Developers] Ephemeris Mode & AbstractPropagator

[MAISONOBE Luc <luc.maisonobe@c-s.fr>]

Thomas Neidhart <thomas.neidhart@gmail.com> a écrit :

> Hi,

Hello Thomas,

> I used the ephemeris mode for the TLEPropagator, but after digging more
> into this, I realized that this mode is more or less working in the same
> way as the slave mode.
>
> The AbstractPropagator only returns a wrapper class
> (BoundedPropagatorView) for itself when calling getGeneratedEphemeris.
> So if I understand it correctly, there is no real benefit in using the
> ephemeris mode for any propagator derived from AbstractPropagator at the
> moment?

Yes, except if the method is overriden by a concrete class.

The rationale behind this strange behaviour is related to  
performances. For numerical propagators, performing a complete  
propagation may be CPU internsive. In this case, we save the  
intermediate state in an ephemeris that is built on the fly and we  
reuse it later. It is a trade-off between computation time and memory  
consumption. In this case, the computation comes first and the  
ephemeris is a by-product. For analytical propagators, the reverse is  
true. Computation is very cheap so there is really no need to waste  
memory by storing results, it is more efficient to recompute  
everything. In this case there are no differences between propagation  
and ephemeride use.

However, it seems important to let the user still have all these  
features available regardless of the underlying propagator. So user  
may select either a numerical or an analytical propagator and use  
either direct computation (mainly if he wants to do a single pass from  
start to end) or ephemeris (mainly if he needs to go back to some  
dates or navigate back and forth, for example in a search algorithm).

The boundaries betwwen these two modes is blurred in the case of DSST  
which is a semianalytical model. If I remember well, Pascal did set up  
a smart mechanism to build ephemeris as propagation goes on, and reuse  
it at the same time. this means that if you propagate from t0 to t2 it  
builds an internal ephemeris, then if you go back to t1 (between t0  
and t2) it will see it already has the required data and will use its  
ephemeris, and if you then go to t3 it will jump to t2, then propagate  
to t3 storing the results at the same time.

From user point of view, all propagators provide the same features,  
and all of them are as fast as they can be.

best regards,
Luc

> Thomas



----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.