AGI.Foundation.SegmentPropagation Namespace |
Classes| Class | Description | |
|---|---|---|
 | BasicLaunchSegment |
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.
|
| BasicLaunchSegmentConfiguration |
The configuration for the BasicLaunchSegment. This element is required to successfully use the basic launch segment.
|
| BasicLaunchSegmentResults |
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.
|
| ChangePropagateSegmentsPropagatorOperator |
An operator that changes the wrapped
StoppablePropagator in a PropagateSegment. Note that
this can bypass the limits placed 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).
|
| ChangeReturnSegmentOperator |
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.
|
| ChangeStoppingConditionEnabledOperator |
A TargetedSegmentListOperator that will enable or disable a
StoppingConditionEvaluator in a nested PropagateSegment.
|
| ChangeStoppingConditionThresholdOperatorT |
A TargetedSegmentListOperator that will change the value of a
threshold at propagation time.
|
| ChangeStopSegmentOperator |
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.
|
| FiniteManeuverSegment |
A segment that will run a NumericalPropagator until a
StoppingCondition is satisfied. It is assumed that some sort of rocket thrusting is occurring,
so this segment will handle the configuration pertaining to fuel level stopping conditions and the state at
ignition and propagation start.
|
| FiniteManeuverSegmentResults |
The results produced by a FiniteManeuverSegment.
|
| FollowSegment | 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. |
| FollowSegmentBeginning |
Defines how the initial state of a FollowSegment should be derived.
|
| FollowSegmentBeginningPropagator |
Evaluates the initial state for the propagator
of a FollowSegment.
|
| FollowSegmentEnding |
Defines how to propagate to the final state of a FollowSegment.
|
| FollowSegmentEndingPropagator |
Evaluates the initial state for the propagator
of a FollowSegment.
|
| FollowSegmentEndsAsWithDefaultConditions |
Propagates the FollowSegment to whatever default end StoppingCondition
it is configured with.
|
| FollowSegmentEndsWithStoppingConditions |
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.
|
| FollowSegmentResults |
The results of propagating a FollowSegment.
|
| FollowSegmentStartsAtEndOfBasePropagator |
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.
|
| FollowSegmentStartsWithDefaultInitialState |
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.
|
| FollowSegmentStartsWithStoppingConditions |
Propagates the wrapped SegmentPropagator of a FollowSegment until a user specified
StoppingCondition stops propagation. The state when this condition is met becomes the initial
state for the FollowSegment's propagation. The conditions set on this class will
be added to the wrapped StoppablePropagator but disabled until this evaluator is
called. The evaluator for this will then enable the added conditions, propagate the wrapped segment, and then
disable the added conditions again.
|
| HoldSegment | |
| ImpulsiveManeuverInformation |
Stores all the information needed for a maneuver to be performed by an ImpulsiveManeuverSegment.
|
| ImpulsiveManeuverSegment | A SegmentDefinition that performs an impulsive maneuver. The propagator for this segment will add the delta-V in the Maneuver to the point state element. It will also keep track of the fuel usage if the ImpulsiveManeuverInformation is configured with fuel mass configuration. 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 element 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. If an optional costate vector is implemented in ImpulsiveManeuverInformation, it will also have to be configured appropriately. |
| ImpulsiveManeuverSegmentConfiguration |
The configuration for an ImpulsiveManeuverSegment. A MultivariableFunctionSolver may
edit the items accessed from this object without editing the original maneuver.
|
| ImpulsiveManeuverSegmentResults | SegmentResults augmented with information relevant to the propagation of an
ImpulsiveManeuverSegment.
|
| InitialStateSegmentT |
Represents an initial state for a SegmentPropagator. Generally this should be the first
non-SegmentListsegment to get propagated.
|
| InitialStateSegmentConfiguration |
The configuration of an InitialStateSegmentT. The configuration
for the segment is just a ITimeBasedState.
|
| InvalidFuelStateException |
An exception that indicates a maneuver caused a craft to run out of fuel.
|
| NumericalInitialStateSegment |
An InitialStateSegmentT whose state is represented as a
NumericalPropagatorState derived from a NumericalPropagatorDefinition.
|
| NumericalPropagatorSegment |
A 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.
|
| PropagateSegment |
A 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
segment's propagator.
|
| PropagateSegmentConfiguration |
The configuration of a PropagateSegment which stores and allows the modification
what StoppablePropagator will be used at propagation time of the PropagateSegment.
|
| PropagateSegmentResults |
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.
|
| ReturnSegment |
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.
|
| ReturnSegmentConfiguration |
The configuration for a ReturnSegment.
|
| RunSegmentListOperator |
A TargetedSegmentListOperator that will run the
segment propagators of the parent TargetedSegmentList.
|
| SeedFiniteManeuverOperator |
An operator that will replace an ImpulsiveManeuverSegment with a similarly configured
FiniteManeuverSegment in a
TargetedSegmentList. Due to the fact that a single DurationStoppingCondition is set
with the time needed to perform the required delta-v, only a single maneuver is supported.
|
| SegmentConfiguration | 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. |
| SegmentDefinition | The base class for segments used with the Segment Propagation Library. These segments define how an ITimeBasedState will be propagated. The initial state will be passed into the propagator'sPropagateSegment method. Multiple segments can be linked together in a simple sequential manner, or in a more complex manner dictated by the control flow segments. When linked together the state elements are fed in to the next logical segment via the manner described in the property, StateForNextSegmentBehavior. When designing custom segments, the segment should support being the first segment in a sequence, if it makes logical and physical sense. If it does not, then a detailed Exception should be thrown when GetSegmentPropagator is called and no previous segment is included. Custom segments should have a corresponding custom configuration type that goes along with it. This configuration object will store mutable values that the segment propagation system could modify. The configuration object does not need to have every single property of the segment; only the ones that are required during propagation. |
| SegmentList |
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.
|
| SegmentListConfiguration |
The configuration for a SegmentList. This stores a collection of the configurations of all the
segments in the SegmentList.
|
| SegmentListPropagator |
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.
|
| SegmentListResults |
The results returned by a propagated SegmentList.
|
| SegmentPropagationEventArgs |
Provides information about the current propagator's propagation.
|
| SegmentPropagator |
The abstract type for a segment's propagator.
This will perform the propagation and produce SegmentResults.
|
| SegmentResults |
The results computed by a SegmentPropagator. Most
Segment Propagators return a results type derived from this class,
see the documentation for more information. When a SegmentPropagator
propagates, it must fill in all of the relevant values in this type before it returns its results.
|
| SinglePropagateSegmentResults |
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.
|
| SingleValueStateUpdater |
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.
|
| StateElementAdapterHelpers |
A set of helper methods for working with StateElementAdapters.
|
| StateUpdaterDefinition |
Defines a specific way to update a ITimeBasedState in an
UpdateSegment.
|
| StateUpdaterEvaluator |
Updates the propagated state in an UpdateSegment.
|
| StoppedOnMaximumDurationException |
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.
|
| StopSegment |
A segment that will end the propagation and return the results up to this segment when propagated.
|
| StopSegmentConfiguration |
The configuration for a StopSegment.
|
| SwapSegmentOperator |
A TargetedSegmentListOperator that will replace one SegmentPropagator in a
TargetedSegmentList with another SegmentPropagator.
|
| SwitchableSegment |
A SegmentDefinition that can switch between two
segments.
|
| SwitchableSegmentConfiguration |
The SegmentConfiguration for a SwitchableSegment.
|
| SwitchableSegmentResults |
The SegmentResults for a SwitchableSegment. Regardless
of which segment was propagated, the ephemeris of this set of results will be in the
PrimarySegment's defined-ins (i.e.
ReferenceFrame and Axes).
|
| TargetedSegmentList |
A SegmentList that can control and change properties of the
segments it is propagating by using
operators at propagation time.
|
| TargetedSegmentListConfiguration |
The configuration for a TargetedSegmentList. This stores the
segment propagators that are set at the beginning of the
computation.
|
| TargetedSegmentListOperator |
The definition of a operation that will in some way
modify how the SegmentPropagators in a
TargetedSegmentList are run.
|
| TargetedSegmentListOperatorEvaluator |
The evaluator of an operator that a
TargetedSegmentList uses on its constituent segments.
|
| TargetedSegmentListOperatorResults |
The base class that gets returned when a TargetedSegmentListOperatorEvaluator is computed.
Typically 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.
|
| TargetedSegmentListResults |
A SegmentListResults that is returned when a
TargetedSegmentLists propagator is run.
|
| UpdateSegment |
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.
|
| UpdateSegmentConfiguration |
The mutable SegmentConfiguration for an UpdateSegment.
|
Delegates| Delegate | Description | |
|---|---|---|
 | ComputeNewThresholdCallbackT |
The callback to compute a new threshold based on the old threshold.
|
| SingleValueUpdaterCallback |
The callback for the SingleValueStateUpdater.
|
Enumerations| Enumeration | Description | |
|---|---|---|
 | ChangeStoppingConditionOption |
The options for enabling or disabling a StoppingCondition for the
ChangeStoppingConditionEnabledOperator |
| InvalidFuelStateBehavior |
An enum that will let a maneuver segment know what to do if an maneuver can not
be completed due to lack of fuel.
|
| MaximumDurationBehavior |
Defines the behavior that a NumericalPropagatorSegment should use when its
MaximumDuration is reached during propagation.
|
| ReturnSegmentBehavior |
The possible behaviors of a ReturnSegment's propagation.
|
| StateForNextSegmentBehavior |
Enumerates the behaviors used in passing a state from one segment to another.
|
| SwitchableSegmentOption |
The options for which segment will be run by default.
|
| TargetedSegmentListOperatorBehavior |
Defines the behavior of the operators
in the TargetedSegmentList. These options are mainly for operators that
compute iteratively, such as the
TargetedSegmentListDifferentialCorrector.
|
| TargetedSegmentListOperatorConvergenceBehavior |
Allows the user to specify the behavior of the parent TargetedSegmentList
when an operator finishes successfully.
|