Efficient orbit propagation?

I'd like to know whether there are recommended practices when using orbit propagation from the point of view of accuracy and memory and computational efficiency. I'd like to know:

1) Assuming that I want to do SGP4 propagation (from TLEs or OMMs), do satelliteScenario objects (from Satellite Communications toolbox) and propagateOrbit (from Aerospace Toolbox) work the same 'under the hood'? The former seems better integrated with the visualization tools, but if I'm primarily interested in the propagation, does it matter what I choose?

2) Is there any better documentation for the OrbitPropagator property for satelliteScenarios? Some options seem self explanatary, but what is 'Numerical''?

3) If I have multiple 'groups' of satellites that I want to simulate orbits for (over the same span of time), is there much practical difference between creating two separate satelliteScenario objects, versus creating one object and just keeping a record of the satellite indices, i.e., group_A_idx, group_B_idx, etc.

4) I can retreive states (e.g., position/velocity) for the satellites using my_scenario.satellites(sat_idx).states() method. I can specify multiple satellite indices, but I can only give one specified time or I can get all the time steps (governed by StartTime, StopTime, and SampleTime). Does the call to states do the propagation? Or does the propagation happen in the background? If I want states over a specifc set of times t_obs, am I better off looping over t_obs, or redefining the scenatio start/stop/sample times?

[Torsten]

If you want "human" confirmation or if the below answer is not sufficient, contact support:

https://uk.mathworks.com/support/contact_us.html

Answer from AI:

Here is the breakdown of how MATLAB handles orbit propagation under the hood regarding accuracy, memory, and computational efficiency.

1. satelliteScenario vs. propagateOrbit: Under the Hood

Yes, they use the exact same underlying SGP4 propagation engine. If your primary goal is numerical propagation without visualization, propagateOrbit is significantly more efficient.

• propagateOrbit (Aerospace Toolbox): This is a lightweight, low-overhead function. It takes a time vector and TLE data, performs the vectorised SGP4 math, and immediately returns raw position and velocity arrays. It minimizes memory allocations and avoids object-oriented overhead.
• satelliteScenario (Satellite Communications Toolbox): This is a high-level, object-oriented framework. When you use SGP4 here, it calls the same math routines, but it wraps them in a rigid time-stepping architecture meant for dynamic link analysis, ground station visibility, and 3D animations (satelliteScenarioViewer). It incurs significant memory and CPU overhead to maintain the object states, hierarchy, and data logging.

2. The OrbitPropagator Documentation & The 'Numerical' Option

The OrbitPropagator property determines the fidelity of your simulation. While 'SGP4' or 'TwoBody' use analytical equations, 'Numerical' activates a high-precision numerical ODE solver.

Here is what the standard options mean:

• Two-Body (Keplerian): Analytical. Assumes Earth is a perfect point mass. Fastest, least accurate.
• SGP4 / SDP4: Analytical. Uses TLE/OMM data. Accounts for bulk Earth oblateness (J₂, J₃, J₄) and atmospheric drag.
• Numerical: This uses a variable-step numerical integrator (like ode45 or ode113 under the hood) combined with a high-fidelity force model. It integrates the differential equations of motion step-by-step. It typically includes Hanna-King or EGM96 Earth gravity models (up to high degrees/orders), atmospheric drag models (like NRLMSISE-00), solar radiation pressure, and third-body third-body gravity (Sun/Moon). It is highly accurate but computationally expensive.

3. One Multi-Satellite Scenario vs. Multiple Scenarios

You should use a single satelliteScenario object and manage your groups via indices.

• Memory & Performance: Creating multiple satelliteScenario objects duplicates the time-keeping machinery, coordinate system definitions, and internal event-listeners. A single scenario handling N satellites scales much better than M scenarios handling smaller fractions.
• Interactivity: If you ever need to calculate inter-satellite links (ISLs) or visibility between Group A and Group B, they must reside in the same satelliteScenario. You cannot compute access across two different scenario objects.
• Index Tracking: Matlab's satellite object handles arrays natively. You can easily store your groups like this:

matlab

groupA = scenario.satellites(group_A_idx);

4. How .states() Triggers Propagation & Handling t_obs

The .states() method triggers the propagation on-demand (lazy evaluation), but it caches the results.

When you call states(), MATLAB checks if the requested times match the pre-defined scenario grid (StartTime to StopTime via SampleTime). If you ask for a custom time array, it evaluates the analytical SGP4 equations at those specific timestamps at that exact moment.

If you have a custom, non-uniform vector of observation times t_obs:

Do not loop over t_obs calling states(t_obs(i)) one by one. This ruins MATLAB's vectorization and creates massive function-call overhead.

Instead, use one of these two strategies depending on your toolbox setup:

• Strategy A (If sticking to satelliteScenario): Pass the entire vector at once: [pos, vel] = my_scenario.satellites.states(t_obs);. MATLAB will compute the SGP4 propagation for all times in a fast, vectorized internal loop.
• Strategy B (The Maximum Efficiency Route): Bypass the scenario object entirely and use propagateOrbit:

matlab

% Highly optimized, low memory, perfectly tailored to your exact t_obs
[pos, vel] = propagateOrbit(tleFile, t_obs, "CoordinateFrame", "Inertial");