Click or drag to resize

Propagation

Propagation, in the context of STK Components, 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

Propagator

Description

TwoBodyPropagator

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

J2Propagator

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.

J4Propagator

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.

Sgp4Propagator

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.

LifetimeOrbitPropagator

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.

NavstarISGps200DPropagator

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

WaypointPropagator

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

NumericalPropagator

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

SegmentPropagator

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.

BallisticPropagator

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

RoutePropagator

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:

Java
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(orbitEpochJD,
        CentralBodiesFacet.getFromContext().getEarth().getInertialFrame(),
        elementsAtEpoch,
        WorldGeodeticSystem1984.GravitationalParameter);

The propagators currently available in STK Components 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:

Java
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.

Java
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:

Java
Platform satellite = new Platform();
satellite.setLocationPoint(propagator.createPoint());

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:

Java
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);