Click or drag to resize

AGI.Foundation.SegmentPropagation Namespace

Contains types for modeling a trajectory in segments, where the type of propagation varies for each segment.
Classes
  ClassDescription
Public classBasicLaunchSegment
This launch segment provides compatibility with STK Astrogator's launch segment. The design of this segment is relatively simple: form an ellipse in the fixed frame between the launch point and the burnout point and interpolate along this ellipse to produce the output ephemeris. This model is low fidelity, but provides a reasonable visualization for launch to orbit insertion. When the burnout state specifies the final velocity in the fixed frame, the flight path angle is set to zero and the final orbit's inclination is determined by the arc of the ellipse. When the burnout state specifies the burnout velocity in the inertial frame it is possible to specify the characteristics of the final orbit more exactly.
Public classBasicLaunchSegmentConfiguration
The configuration for the BasicLaunchSegment. This element is required to successfully use the basic launch segment.
Public classBasicLaunchSegmentResults
The basic launch segment results. In addition to the results offered in the base type of SegmentResults, this derived type offers several boolean properties used to flag warnings in the propagator which are not fatal to propagation but should be checked.
Public classChangePropagateSegmentsPropagatorOperator
An operator that changes the wrapped StoppablePropagator in a PropagateSegment. Note that this can bypass the limits places on the type of propagator derived propagate segments may have (for example, a normal PropagateSegment that was configured with a TwoBodyStoppablePropagator could be configured to run with a StoppableNumericalPropagator with this operator).
Public classChangeReturnSegmentOperator
An operator for a TargetedSegmentList that will change the Enabled setting for a ReturnSegment that is in the TargetedSegmentList that contains this operator and ReturnSegment.
Public classChangeStoppingConditionEnabledOperator
A TargetedSegmentListOperator that will enable or disable a StoppingConditionEvaluator in a nested PropagateSegment.
Public classChangeStoppingConditionThresholdOperatorT
A TargetedSegmentListOperator that will change the value of a threshold at propagation time.
Public classChangeStopSegmentOperator
An operator for a TargetedSegmentList that will change the StopEnabled setting for a StopSegment that is in the TargetedSegmentList that contains this operator and StopSegment.
Public classFollowSegment

A segment that will start propagating based on a specified strategy, and will end propagating based on another strategy. This is a PropagateSegment, however, due to the nature of how the start and end of propagation are determined, the StoppingConditions can be empty. However if they are not empty, those conditions can end propagation during the evaluation of the initial state derivation or final state derivation.

Note that if this segment is not the first segment being propagated, it is possible that a discontinuity can occur.

Public classFollowSegmentBeginning
Defines how the initial state of a FollowSegment should be derived.
Public classFollowSegmentBeginningPropagator
Evaluates the initial state for the propagator of a FollowSegment.
Public classFollowSegmentEnding
Defines how to propagate to the final state of a FollowSegment.
Public classFollowSegmentEndingPropagator
Evaluates the initial state for the propagator of a FollowSegment.
Public classFollowSegmentEndsAsWithDefaultConditions
Propagates the FollowSegment to whatever default end StoppingCondition it is configured with.
Public classFollowSegmentEndsWithStoppingConditions
Propagates the SegmentPropagator of a FollowSegment to a set of StoppingConditions. These conditions will be automatically added to the StoppablePropagator but disabled until this evaluator is called. Then they will be enabled, propagation will occur, and then disabled again.
Public classFollowSegmentResults
The results of propagating a FollowSegment.
Public classFollowSegmentStartsAtEndOfBasePropagator
Determines the initial state of a FollowSegment by getting the final state of the wrapped StoppablePropagator. If propagation is going forward in time, this will return the final state that can be produced by the propagator, and the earliest point in time if propagation is going backwards in time. If there is no such state (if the StoppablePropagator cannot produce such a state) then an exception will be thrown.
Public classFollowSegmentStartsWithDefaultInitialState
Determines the initial state of a FollowSegment by using the default initial state passed to the segment. In short, this is the same behavior of the default propagation of segments. This will be the previous segment's final state if the FollowSegment is not the first segment, or it will be the initial state passed into the Propagate(ITimeBasedState) method, if it is specified, or it will be the initial state as configured on the wrapped StoppablePropagatorDefinition if it is specified. If none of those are available then this will throw an exception.
Public classFollowSegmentStartsWithStoppingConditions
Propagates the SegmentPropagator of a FollowSegment until a StoppingCondition stops propagation. That final state will then be the official initial state for the FollowSegments propagation. These conditions will be automatically added to the StoppablePropagator but disabled until this evaluator is called. Then they will be enabled, propagation will occur, and then disabled again.
Public classHoldSegment
A segment whose states are held constant in time. This is intended to be used when the object being propagated is fixed in some way, such as landed on a central body or fixed to another vehicle.
Public classImpulsiveManeuverInformation
Stores all the information needed for a maneuver to be performed by an ImpulsiveManeuverSegment.
Public classImpulsiveManeuverSegment

A SegmentDefinition that performs a set of impulsive maneuvers. For every ImpulsiveManeuverInformation entered into this segments configuration, the propagator will add the delta-V for that element to the state passed into the propagator at propagation time. It will also keep track of the fuel usage if the ImpulsiveManeuverInformation is configured with its mass settings. You can have no more than one ImpulsiveManeuverInformation for each Point element being propagated.

This segment is somewhat unique in that it will pass all of the state elements to the next segment, but it still requires a StateElementAdapter to be available for the point elements it modifies. If this segment is the first or only segment producing ephemeris, then the SetElementAndAdapter(StateElementAdapterDefinition) must be called with an adapter configured to handle the point element. If there is a previous segment with an adapter for the point element, then the adapter on this segment may be omitted if the desired output frame of the ephemeris for this segment is the same as the previous segment.

Public classImpulsiveManeuverSegmentConfiguration
The configuration for an ImpulsiveManeuverSegment, storing all of the ImpulsiveManeuverInformations for the segment. A MultivariableFunctionSolver may edit the items accessed from this object without editing the original maneuvers.
Public classImpulsiveManeuverSegmentResults
A SegmentResults specifically for the results of a ImpulsiveManeuverSegment.
Public classInitialStateSegmentT
Represents an initial state for a SegmentPropagator. Generally this should be the first non-SegmentListsegment to get propagated.
Public classInitialStateSegmentConfiguration
Public classInvalidFuelStateException
An exception that indicates a maneuver caused a craft to run out of fuel.
Public classNumericalInitialStateSegment
Public classNumericalPropagatorSegment
An segment that will run a NumericalPropagator until a StoppingCondition is satisfied. Each StoppingCondition in the AGI.Foundation.StoppingConditions can have an optional SegmentDefinition associated with it that get propagated if that StoppingCondition is the one that stops the propagation of this segments propagator.
Public classPropagateSegment
An segment that will run a StoppablePropagator until a StoppingCondition is satisfied. Each StoppingCondition in the StoppingConditions can have an optional SegmentDefinition associated with it that get propagated if that StoppingCondition is the one that stops the propagation of this segments propagator.
Public classPropagateSegmentConfiguration
The configuration of a PropagateSegment which stores and allows the modification what StoppablePropagator will be used at propagation time of the PropagateSegment.
Public classPropagateSegmentResults
A PropagateSegment can optionally propagate multiple segments with an auto-sequence with stopping conditions. When auto-sequences are run (possibly multiple times), there will be a pattern where the PropagateSegments propagator propagates, then the SegmentPropagator for the stopping conditions auto sequence will run, then the original propagator if the stopping condition is configured to be tripped multiple times. The overall SegmentResults returned will be the PropagateSegmentResults which is a SegmentList of all of the segments propagated.
Public classReturnSegment
A segment that will end propagation of a SegmentList that contains this segment even if there are other segments still in the list. Due to the nature of how this segment works, it is not possible for it to run as a single standalone segment; it must be nested in the SegmentList that it will jump out of.
Public classReturnSegmentConfiguration
The configuration for a ReturnSegment.
Public classSegmentConfiguration

The configuration for a SegmentPropagator. This configuration must be mutable and it must have all of the settings that some outer operation may want to change to drive the segment to propagate towards a common result. SegmentConfigurations will be created by the segment when the propagator is created and potentially changed by a TargetedSegmentListOperator.

If writing your own SegmentDefinition and SegmentPropagator, it is best to create a specific SegmentConfiguration for that new segment. Generally, all of the settings on the SegmentDefinition should be reflected in this configuration.

Public classSegmentDefinition

The base class defining the definition of a SegmentPropagator. Segments will define how an ITimeBasedState will be propagated. That initial state will be passed into the propagatorsPropagateSegment method. Consider wrapping another lower level propagator in your SegmentPropagator. Multiple segments can be strung together, one running after the previous, and the initial state of each segment will be initialized with the final state of the previous one.

It is a good idea to design custom segments to support being the first segment that is run. However if it truly makes no sense for a custom segment to not be the first segment, then a detailed Exception should be thrown when GetSegmentPropagator is called and no previous segment is included.

Segments should also have a specific configuration type that goes along with it. This configuration object will store mutable values that a parent segment could modify. The configuration object should generally not have every single property of the segment, only the ones that make sense. The configuration will assist in editing the properties it stores.

Public classSegmentList
A class that holds a list of SegmentDefinitions that gets propagated in series. When this types propagator is propagated, you may always safely cast the results returned to SegmentListResults. This is a SegmentDefinition, so you can nest a SegmentList in another SegmentList.
Public classSegmentListConfiguration
The configuration for a SegmentList. This stores a collection of the configurations of all the segments in the SegmentList.
Public classSegmentListPropagator
The SegmentPropagator for SegmentList. Each SegmentPropagator in the list will be propagated sequentially and a SegmentListResults will be returned. Note that there are several virtual methods on this type that must be overridden if you are extending this type.
Public classSegmentListResults
The results returned by a propagated SegmentList. Note that if your custom segment has the possibility of propagating multiple segments sequentially, it should return a SegmentListResults even if it ends up propagating a single segment.
Public classSegmentPropagationEventArgs
Provides information about the current propagator's propagation.
Public classSegmentPropagator
The abstract type for a segment's propagator. This is the type that will actually perform the propagation and produce SegmentResults.
Public classSegmentResults
The results computed by a SegmentPropagator. Most Segment Propagators return a type derived from this type; see the documentation for those segments for more information. When a SegmentPropagator propagates, it must fill in all of the relevant values in this type before it returns its results.
Public classSinglePropagateSegmentResults
A PropagateSegment can optionally propagate multiple segments with an auto-sequence with stopping conditions. When auto-sequences are run (possibly multiple times), there will be a pattern where the PropagateSegments propagator propagates, then the SegmentPropagator for the stopping conditions auto sequence will run, then the original propagator if the stopping condition is configured to be tripped multiple times. The overall SegmentResults returned will be the PropagateSegmentResults which is a SegmentList. This is the results for those single run of the PropagateSegment that gets run initially and after an auto-sequence finishes.
Public classSingleValueStateUpdater
Updates the propagated state where a single value will change a value or values in the state. This can add the single value to a scalar, or multiple several values in the state by the single value, or set a value in the state to a specific value. The single value is a value that a variable in a TargetedSegmentListDifferentialCorrector can edit.
Public classStateElementAdapterHelpers
A set of helper methods for working with StateElementAdapters.
Public classStateUpdaterDefinition
Defines a specific way to update a ITimeBasedState in an UpdateSegment.
Public classStateUpdaterEvaluator
Updates the propagated state in an UpdateSegment.
Public classStoppedOnMaximumDurationException
The Exception that gets thrown when a PropagateSegmentResults was stopped on its MaximumDuration and if the segment was set to throw if the Duration was exceeded.
Public classStopSegment
A segment that will end the propagation and return the results up to this segment when propagated.
Public classStopSegmentConfiguration
The configuration for a StopSegment.
Public classTargetedSegmentList
A SegmentList that can control and change properties of the segments it is propagating by using operators at propagation time.
Public classTargetedSegmentListConfiguration
The configuration for a TargetedSegmentList. This stores the segment propagators that are set at the beginning of the computation.
Public classTargetedSegmentListOperator
The definition of a operation that will in some way modify how the SegmentPropagators in a TargetedSegmentList are run.
Public classTargetedSegmentListOperatorEvaluator
The evaluator of an operator that a TargetedSegmentList will use on its segments. These get created by a TargetedSegmentListOperator for use at propagation time to change some setting in the SegmentPropagators getting propagated by the TargetedSegmentList that held this in its Operators.
Public classTargetedSegmentListOperatorResults
The base class that gets returned when a TargetedSegmentListOperatorEvaluator is computed. Often this class should be extended unless the operation produces no results itself. In addition to the properties in this type, any other data that your operator computed that an end user might care about should be added to your type inheriting from this one.
Public classTargetedSegmentListResults
A SegmentListResults that is returned when a TargetedSegmentLists propagator is run.
Public classUpdateSegment
A segment that will update the final state of the previous segment. The returned SegmentResults will have two states in its ephemeris, the final state of the previous segment, and the modified state.
Public classUpdateSegmentConfiguration
The mutable SegmentConfiguration for an UpdateSegment.
Delegates
Enumerations
  EnumerationDescription
Public enumerationChangeStoppingConditionOption
The options for enabling or disabling a StoppingCondition for the ChangeStoppingConditionEnabledOperator
Public enumerationInvalidFuelStateBehavior
An enum that will let a maneuver segment know what to do if an maneuver can not be completed due to lack of fuel.
Public enumerationMaximumDurationBehavior
Defines the behavior that a NumericalPropagatorSegment should use when its MaximumDuration is reached during propagation.
Public enumerationReturnSegmentBehavior
The possible behaviors of a ReturnSegments propagation.
Public enumerationStateForNextSegmentBehavior
Defines the different behaviors for passing a state from one segment to another.
Public enumerationTargetedSegmentListOperatorBehavior
Defines the behavior of the operators in the TargetedSegmentList. These options are mainly for operators that compute iteratively, such as the TargetedSegmentListDifferentialCorrector.
Public enumerationTargetedSegmentListOperatorConvergenceBehavior
Allows the user to specify the behavior of the parent TargetedSegmentList when an operator finishes successfully.