AGI.Foundation.Propagators Namespace |
Classes| Class | Description | |
|---|---|---|
 | AuxiliaryStateScalar |
Represents a scalar value which may depend on integrated quantities in the state
and is evaluated and stored for output during propagation.
|
| AuxiliaryStateVector |
An auxiliary state vector which is not integrated with the rest of the state
but is evaluated for the propagation output during propagation.
|
| BallisticPropagator |
This class calculates a ballistic trajectory (two body gravity only) between two locations on a CentralBody.
|
| BallisticTrajectoryInformation |
An object with many metrics that describe a ballistic trajectory from an initial point to a target point.
|
| CartesianOnePointPropagator |
The base class for simple one-point propagators that produce only MotionT.
|
 | CelestrakGeneralPerturbationElements |
Celestrak general perturbation (GP) orbital elements.
|
| ConstantStateStoppablePropagator |
A StoppablePropagator that always returns the initial state passed in
at propagation time. This can be useful when you are modeling a trajectory with
multiple propagators strung together and one of those segments is in some way fixed
for a time, such as landed or docked.
|
| DynamicStateStoppablePropagator |
A StoppablePropagator that evaluates a StateEvaluatorT
in time until a StoppingCondition is tripped. The initial state of this
segment will only be used to evaluate the DynamicState at the date of the passed
in state. The DynamicState does not have a way to
initialize the values within it, so except for the date this propagator can not be initialized with an
initial state at propagation time. As such this propagator does not need adapters.
|
| ExceptionDuringPropagationEventArgs |
Provides information about the exception during propagation event conditions.
|
| GpsRinexPropagator |
GPS RINEX Propagator class propagates GPS orbits - providing GPS satellite positions based on RINEX
broadcast ephemeris sets.
|
| InitialOrbitSolver |
Solves for an initial orbit under two body conditions.
|
| InitialOrbitSolverResults |
Contains the results produced by the InitialOrbitSolver. These motions contain the necessary information to determine the orbit.
|
| J2Propagator |
An analytic propagator that uses a first order J2 perturbation algorithm which models
only the secular effects on the orbital elements.
|
| J4Propagator |
An analytic propagator that uses a second order J2/J4 perturbation algorithm which
models only the secular effects on the orbital elements. J2 effects are considered
to the second order and J4 effects are considered to the first order.
|
| LambertOrbitSolver |
Solves the orbit targeting problem and initial orbit determination.
Given a set of input positions, and an optional time of flight, the solver will return the appropriate velocity vectors that determine the orbit.
|
| LambertOrbitSolverFailedToConvergeEventArgs |
Holds details of the FailedToConvergeEvent event.
|
| LambertResult |
Contains the results produced by the LambertOrbitSolver.
|
| 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 the orbit of a Global Positioning System (GPS) satellite according to the propagation scheme
defined in the Navstar Interface Specific (IS) GPS-200D.
|
| NumericalIntegrationInformation |
Contains information about the behavior of an integrator in a given integration step.
|
| NumericalPropagationException |
An exception that indicates an error was encountered during propagation. See the inner exception
for details regarding the root cause.
|
| NumericalPropagationStateHistory |
Contains a collection of data resulting from propagating the state over a span of time.
|
| NumericalPropagator | A propagator which can advance the state from initial conditions by either taking individual integration steps or by propagating over a given time span. Note that a given instance of a propagator is NOT thread safe. So if there is a need to propagate a given state in different threads, make sure to clone the propagator for another thread using CopyT(T). A NumericalPropagator is created by configuring a NumericalPropagatorDefinition and then calling CreatePropagator. |
| NumericalPropagatorDefinition | The definitional object that creates a NumericalPropagator. It consists of the overall propagation state which represents individual scalar, vector, or custom parameters within IntegrationElements (which are integrated during propagation), and the AuxiliaryElements (which are not). It also contains StateCorrectors which correct the IntegrationElements and their derivatives in between propagation steps, the Epoch of the initial conditions, and the Integrator which integrates the IntegrationElements. Call CreatePropagator in order to create the defined NumericalPropagator. |
| NumericalPropagatorState |
A state representing every propagated value in a particular
NumericalPropagator.
|
| OrbitLifetimeResults |
A set of results indicating the time at which an orbit is expected to decay
and the time history of the mean elements. Note that these results may
not always indicate a decayed orbit. Check the Status to
see whether one of the limit conditions was met before finishing the calculation.
In that case, the DateOfDecay will be equal to the ReferenceEpoch,
indicating an unknown decay date.
|
| PropagationEulerianAxes |
A PropagationStateElement representing the attitude (and angular velocity) of a rigid body
with its angular acceleration represented by Euler's equations of motion. Body-fixed coordinates are used
for the initial attitude, angular velocity, and moment of inertia matrix.
|
| PropagationEventArgs |
Provides information about the current propagation event conditions and provides a
means of indicating how the propagation should continue.
|
| PropagationNewtonianPoint |
An PropagationStateElement representing the position (and velocity) of a body
with its second derivative defined by Newton's second law of motion: Acceleration = AppliedForce / Mass
|
| PropagationScalar |
An PropagationStateElement representing a scalar value to be integrated over time.
|
| PropagationStateConverter |
A converter which can take raw data from the output of propagation and turn it into useful
data by using PropagationStateElement and AuxiliaryStateElement
converter types to convert to their corresponding output types. For instance, a
PropagationVector defines its values using Cartesian types. So
if the user enters an element identification corresponding to a PropagationVector,
it can convert the raw data into the Motion<Cartesian> data
containing the vector value and its derivatives.
|
| PropagationVector |
A PropagationStateElement representing a vector value to be integrated over time.
|
| PropagatorPoint |
A point with its location computed by a propagator. To create an instance of this class,
call a propagator method that returns an instance.
|
| Sgp4Elements |
A set of orbital elements intended to be propagated with the SGP4 propagator.
|
| Sgp4ElementsSwitchByClosestApproach |
An algorithm which determines when to switch from one element set to another
by propagating each element set against the next to determine the time
at which the range between the positions of the two orbits is the smallest.
This may not represent the most accurate position for the orbit at all times.
However, it will minimize discontinuities which may result from fitting the
newer element set to the correct orbit.
|
| Sgp4ElementsSwitchByEpoch |
An algorithm which determines when to switch from one element set to another
by comparing their respective Epoch values. The
first element set is used up until the epoch of the second and the last element
set is used after its epoch.
|
| Sgp4ElementsSwitchByMidpoint |
An algorithm which determines when to switch from one element set to another
by comparing their respective Epoch values. The
first element set is used up until the midpoint in time between the epoch of the
first and the epoch of the second. The last element set is used from the
midpoint in time between its epoch and the epoch of the set before it.
|
| Sgp4ElementsSwitching |
An algorithm for determining when to switch from one set of elements to another.
|
| Sgp4Propagator | Propagates an orbit using the NORAD SGP4/SDP4 model as defined by the Center for Space Standards and Innovation (CSSI). More information and the algorithm's code can be found at www.centerforspace.com. Note that the SGP4 propagator performs its propagation using the TAI time standard. If the user asks for a propagation over an interval and timestep specified in UTC, the system interprets this to mean that the reported values should be in UTC. However, in order to compute the correct timespans (potentially propagating through leap seconds), the system will convert to TAI in order to compare times. Since the length of a second is different in various time standards, the stepsize is measured in the time standard the user specifies even though the comparisons and propagation occurs in TAI. If the length of a given time step is important, this may be a necessary calculation. However, the performance of the SGP4 propagation can be improved by specifying input times in TAI. The acceleration returned from the SGP4Propagator is identical to the J4Propagator, which is an approximation used to prevent code using this propagator from being unable to provide analysis in the absence of acceleration. In DME Component Libraries, there are a number of places that expect or require acceleration information from propagators. In order to support this, the Sgp4Propagator will return an acceleration when asked. However, because the SGP4 theory does not explicitly contain a representation of the acceleration and the velocity of the SGP4 theory does not correspond exactly with the position, the acceleration returned for SGP4 is an approximation. Compared with numerical differentiation of the position, the velocity returned from the SGP4 theory can have a discrepancy anywhere from a few millimeters to several meters. Since the acceleration perturbations from drag and third body effects are several orders of magnitude less than gravitational effects, the J4 perturbations are used here to approximate the acceleration for SGP4. |
| Sgp4PropagatorSgp4EstimationInput |
A class containing configuration information for the static estimation methods available on the Sgp4Propagator.
|
| Sgp4PropagatorSgp4EstimationOutput |
A class containing the estimated Sgp4Elements along with the associated
information from the fit.
|
| SimpleAscentPropagator |
Propagates a simple (point) launch vehicle from a CentralBody to a specified burnout motion.
|
| SimpleAscentPropagatorWarnings |
The arguments passed to any event handlers listening for propagation warnings that may be produced when using the SimpleAscentPropagator.
|
| SinglePointStoppablePropagator |
Samples a Point at a specified time step until a StoppingCondition is
satisfied, returning the ephemeris computed and all events found by the
StoppingConditions.
|
| SinglePointStoppablePropagatorDefinition |
Provides the infrastructure to use a Point as a basis for propagating a
trajectory that can be stopped with StoppingConditions.
Note that this only propagates a single point; no other items will be propagated.
|
| SinglePointStoppablePropagatorResults |
The StoppablePropagatorResults returned from a SinglePointStoppablePropagator.
|
| SpecializedOrbitSolver |
Create propagators that model specialized orbit types, including:
circular, critically-inclined, stationary, Molniya, repeat ground trace, and Sun-synchronous.
|
| StateTransitionMatrix | An extended state transition matrix, if consider parameters are not used then it functions as a normal state transition matrix: mapping the value of the state parameters from one time to another time. The state transition matrix represents the transformation from the state at one time to the state at another time. This can be used as an alternative to propagating a state in time with NumericalPropagator, but is more often used in order to find the time-varying covariance of the state. This is because the construction of a StateTransitionMatrix entails the linearization of the state, and in most cases calculating the derivatives of the state transition matrix takes as long or longer as calculating the derivatives of the state. To find the covariance of a state over time a StateTransitionMatrix is propagated with a NumericalPropagator and the resulting data is used to create the covariance information for the same period using PopulateCovarianceCollection(Matrix, DateMotionCollectionMatrix, TransitionType). |
| StoppableNumericalPropagator |
A StoppablePropagator that wraps a PropagatorDefinition and will
find events and stop based on a set of StoppingConditions.
|
| StoppableNumericalPropagatorResults |
Stores the ephemeris computed by a NumericalPropagator and information about how the
propagation was stopped.
|
| StoppablePropagator |
A propagator that wraps some type that generates states and will sample some
derived value from those states searching for events and eventually an event that will stop propagation with
StoppingConditionEvaluators.
|
| StoppablePropagatorDefinition |
Defines a propagator that can propagate to arbitrary events and stop on any
StoppingCondition. This type is intended to work by wrapping
some other propagator and generate states until a StoppingCondition
is tripped.
|
| StoppablePropagatorResults |
The results of a StoppablePropagator. This type is designed to be extended with
additional data computed during propagation.
|
| StoppablePropagatorStepTakenArgs | |
| TwoBodyPropagator |
Propagates an orbit using a simple two-body model.
|
| TwoBodyStateTransitionMatrixPropagator |
Propagates the state transition matrix of an object using a simple two-body model.
|
| TwoBodyStoppablePropagator |
A StoppablePropagator that propagates an orbit using a simple two-body model.
|
| TwoLineElementSet |
A NORAD two-line element set (TLE). Note that the precision of most TLEs is limited by the
string representations in the TLE. The resulting ephemeris has a precision on the order of kilometers.
When creating a TLE based on orbital elements, it is important to note that information will be lost
when converting precise elements into a string representation.
|
| UsafGeneralPerturbationElements |
United States Air Force (USAF) general perturbation (GP) orbital elements.
|
| WalkerConstellation |
Supports the creation of Walker constellations of satellites.
|
| WalkerConstellationPlaneTPropagator |
A collection of satellite propagators with the same inclination and right ascension of the ascending node but differing true anomalies.
|
| WalkerConstellationResultTPropagator |
A collection of satellite orbital planes with the same inclination but differing right ascensions of the ascending node.
|
| Waypoint |
Defines the characteristics at a waypoint.
|
| WaypointCollection |
A collection of Waypoints.
|
| WaypointPropagator |
Propagates a path connecting waypoints relative to an ellipsoid.
|
Structures| Structure | Description | |
|---|---|---|
 | PropagationStateArray |
Provides a means of specifying an indexable object which represents a set of values mapping a
subset of the overall state elements. The sub-elements are defined by a set of indices
into the overall state.
|
Interfaces| Interface | Description | |
|---|---|---|
 | IGpsElements |
An interface to a GPS element set that contains data items needed for GPS ephemeris propagation.
This interface provides data for one GPS satellite.
|
| IUpdatePriorToStep |
An interface to an object created by a PropagationStateElement that has special behavior
that takes place each time step prior to propagation. The
NumericalPropagator will call the UpdatePriorToStep(JulianDate, PropagationStateArray) method in this class
to perform that behavior.
|
Enumerations| Enumeration | Description | |
|---|---|---|
 | BallisticPropagatorSolutionType |
Species the kind of solution that was calculated by a BallisticPropagator, IE whether the desired trajectory was
successfully calculated, the propagator failed to converge on a solution, or the specified constraint was invalid.
|
| GeneralPerturbationObjectType |
The classification of an orbiting body for a UsafGeneralPerturbationElements.
|
| LambertPathType |
Indicates which type of path to take in the LambertOrbitSolver. This setting is only relevant for
transfer orbits with at least one revolution between the initial and final positions.
|
| LifetimeCalculationLimitType |
Specifies how the LifetimeOrbitPropagator should behave when
determining completion of the computation. This will limit the run time of the
orbit lifetime computation.
|
| LifetimeCalculationStatus |
An indication of the final state of the LifetimeOrbitPropagator calculation.
|
| PropagationEventIndication |
An indication of how the propagator should proceed.
|
| PropagationEventTrigger |
Indicates which kind of propagation method triggered the
StepTaken event.
|
| PropagationStage |
An enumerator that communicates the which stage of propagation an evaluator is called during.
|
| SimpleAscentPropagatorAscentType |
The type of spline to use in the SimpleAscentPropagator.
|
| SimpleAscentPropagatorBurnoutVelocityFrame |
Sets the CentralBody-relative frame used to specify the burnout velocity in SimpleAscentPropagator.
|
| SortingFormat |
An enumeration that defines the order in which entries in a NumericalPropagationStateHistory
are sorted.
|
| TransitionType |
An enumeration that defines the format of transformation described by a StateTransitionMatrix.
|
| WalkerConstellationPattern |
Determines whether a Walker constellation has a delta pattern or a star pattern.
|