Click or drag to resize


Propagation, in the context of DME Component Libraries, is the process of taking a set of initial conditions at a particular time and employing a specific algorithm to determine the conditions at some other time. The library includes specialized propagators for modeling the motion of satellites, aircraft, and surface vehicles.

Available Propagators




The Two-Body propagator considers only the force of gravity from a primary body which is modeled as a point mass.


The two-body state transition matrix propagator considers only the force of gravity from a primary body which is modeled as a point mass. It propagates the state transition matrix of the spacecraft rather than the position and velocity of the spacecraft.


The J2 Perturbation (first-order) propagator accounts for secular variations in the orbit elements due to oblateness. This propagator does not model atmospheric drag or solar or lunar gravitational forces.


The J4 Perturbation (second-order) propagator accounts for secular variations in the orbit elements due to oblateness. This propagator does not model atmospheric drag or solar or lunar gravitational forces. The J4 propagator includes the first- and second-order effects of J2 and the first-order effects of J4. The J3 coefficient, which produces long period periodic effects, is not included.


The Simplified General Perturbations (SGP4) propagator is used with two-line mean element (TLE) sets. It considers secular and periodic variations due to oblateness, solar and lunar gravitational effects, gravitational resonance effects and orbital decay using a simple drag model.


Propagates a set of initial conditions using a long-term propagation technique to determine when the orbit is expected to decay, based on the evolution of the mean orbital elements under the effects of gravitational, atmospheric, and solar perturbations.


Propagates a Global Positioning System (GPS) satellite according to the IS-GPS-200D interface specification.


Defines a point-by-point path with respect to the surface of an ellipsoid by specifying the longitude, latitude, and height at each point.


A general propagator which propagates a set of state elements using their derivatives.


Allows the modeling of trajectories and other states where the type of propagation varies over the lifetime of the object being modeled. Can also be used to solve for solutions to target states.


Calculates a ballistic trajectory (two body gravity only) between two locations on a CentralBody.


Constructs a geometrically defined route from a sequential list of procedures and connection segments.

Using Propagators

Creating a propagator requires defining the initial conditions. Each propagator utilizes slightly different initial conditions. See the reference documentation for each propagator. This example shows how to create a TwoBodyPropagator:

GregorianDate orbitEpoch = new GregorianDate(2007, 5, 30, 12, 0, 0.0);
JulianDate orbitEpochJD = new JulianDate(orbitEpoch);

Motion1<Cartesian> elementsAtEpoch = new Motion1<>(
        new Cartesian(12000000.0, 0.0, 0.0), // initial position
        new Cartesian(0.0, 5763.0, 0.0)); // initial velocity

TwoBodyPropagator propagator = new TwoBodyPropagator(

The propagators currently available in DME Component Libraries can efficiently produce data both at a single time and over an entire interval. When a propagator is producing data at a single time we say it is operating in a "one-point" mode. Of course, you can still produce data for multiple times by evaluating each in turn, but there are no special requirements on the times. For example, it is not required that the input times be evaluated in increasing order.

To propagate at individual times, call the getEvaluator method to obtain an evaluator. Then, call the evaluate method on the evaluator instance. The following example evaluates the position and velocity of a spacecraft at later times:

MotionEvaluator1<Cartesian> evaluator = propagator.getEvaluator();
Motion1<Cartesian> elementsAfter1Day = evaluator.evaluate(orbitEpochJD.addDays(1.0), 1);
Motion1<Cartesian> elementsAfter2Days = evaluator.evaluate(orbitEpochJD.addDays(2.0), 1);

Evaluating in this way produces position information in the native reference frame of the propagator. The native reference frame can be identified by the propagator's ReferenceFrame (get / set) property.

It is also possible to propagate over an entire range of times using the propagate method. This method takes a start date, a stop date, the time step between each point, and the reference frame in which the ephemeris should be generated, and returns a DateMotionCollection1<Cartesian> containing all of the propagated points.

GregorianDate startDate = new GregorianDate(2007, 6, 1, 12, 0, 0.0);
GregorianDate stopDate = new GregorianDate(2007, 7, 1, 12, 0, 0.0);
Duration step = Duration.fromSeconds(60.0);

JulianDate startDateJD = new JulianDate(startDate);
JulianDate stopDateJD = new JulianDate(stopDate);

EarthCentralBody earth = CentralBodiesFacet.getFromContext().getEarth();
DateMotionCollection1<Cartesian> ephemeris = propagator.propagate(startDateJD, stopDateJD, step, 1, earth.getFixedFrame());

Most propagators also have a createPoint method that creates a Point representing the position and velocity produced by the propagator. This is helpful if you want to create a vehicle whose motion is defined by a propagator. This example configures a satellite to have its LocationPoint (get / set) defined by a TwoBodyPropagator:

Platform satellite = new Platform();

The createPoint method is also helpful for observing the motion produced by the propagator in different reference frames. This example uses the point returned by createPoint to find the position and velocity produced by the propagator in the Earth Fixed reference frame:

PropagatorPoint point = propagator.createPoint();
ReferenceFrame earthFixedFrame = CentralBodiesFacet.getFromContext().getEarth().getFixedFrame();
PointEvaluator evaluator = GeometryTransformer.observePoint(point, earthFixedFrame);
Motion1<Cartesian> fixedElementsAfter1Day = evaluator.evaluate(orbitEpochJD.addDays(1.0), 1);
Motion1<Cartesian> fixedElementsAfter2Days = evaluator.evaluate(orbitEpochJD.addDays(2.0), 1);
Using Two-Body State Transition Matrix Propagator

Creating a two-body state transition matrix propagator requires defining a two-body propagator first. This example shows how to create a TwoBodyStateTransitionMatrixPropagator from a pre-existing TwoBodyPropagator:

// The propagation starts at the orbit epoch of the pre-existing two-body propagator.
JulianDate epoch = twoBodyPropagator.getOrbitEpoch();
final double stepSize = 60.0; // Seconds.
final int durationDays = 1;
JulianDate stopTime = epoch.addDays(durationDays);

// Construct the two-body state transition matrix propagator.
TwoBodyStateTransitionMatrixPropagator stmPropagator = new TwoBodyStateTransitionMatrixPropagator(twoBodyPropagator);

// Create an evaluator and then propagate the state transition matrix for one day in one minute increments.
EvaluatorGroup group = new EvaluatorGroup();
DynamicMatrixEvaluator evaluator = stmPropagator.getEvaluator(group);
DateMotionCollection1<Matrix> stateTransitionMatrices = evaluator.evaluate(epoch, stopTime, Duration.fromSeconds(stepSize), 0);

More explanatory details associated with state transition matrices can be found in Covariance and Uncertainty. Details about how to numerically propagate state transition matrices using more sophisticated force models are also available on that page.