STK Components for Java 2021 r3

## 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 |
---|---|

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

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:

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