BasicLaunchSegment

java.lang.Object
- agi.foundation.infrastructure.DefinitionalObject
- - agi.foundation.segmentpropagation.SegmentDefinition
  - - agi.foundation.segmentpropagation.BasicLaunchSegment

All Implemented Interfaces:

ICloneWithContext, IEnumerateDependencies, IEquatableDefinition, IFreezable
```
public class BasicLaunchSegment
extends SegmentDefinition
```
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.
Note that the reference frame used for the input positions must be set. This is accomplished via SegmentDefinition.setElementAndAdapter(agi.foundation.coordinates.StateElementAdapterDefinition). Both the BurnoutState (get / set) and LaunchState (get / set) location reference frames must be the same.

Constructor Summary

Constructors
Modifier	Constructor and Description
	`BasicLaunchSegment()` Initializes a new launch segment.
`protected`	`BasicLaunchSegment(BasicLaunchSegment existingInstance, CopyContext context)` Initializes a new instance as a copy of an existing instance.
	`BasicLaunchSegment(Duration step)` Initializes a new launch segment with the specified step size.
	`BasicLaunchSegment(Duration step, String motionID, ITimeBasedState launchState)` Initializes a new launch segment with the specified step size, launch state, and motion ID.
	`BasicLaunchSegment(Duration step, String motionID, ITimeBasedState launchState, ITimeBasedState burnoutState)` Initializes a new launch segment with the specified step size, launch state, burnout state, and motion ID.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addPropagationFinishedEvent(EventHandler<SegmentPropagationEventArgs> value)` An event that gets raised when propagation is complete.
`protected boolean`	`checkForSameDefinition(BasicLaunchSegment other)` Checks to determine if another instance has the same definition as this instance and returns `true` if it does.
`protected boolean`	`checkForSameDefinition(SegmentDefinition other)` Checks to determine if another instance has the same definition as this instance and returns `true` if it does.
`Object`	`clone(CopyContext context)` Clones this object using the specified context.
`protected int`	`computeCurrentDefinitionHashCode()` Computes a hash code based on the current properties of this object.
`protected SegmentPropagator`	`createSegmentPropagator(EvaluatorGroup group, SegmentDefinition previousSegment)` Creates, configures, and returns the `SegmentPropagator` for this segment.
`SegmentList`	`createSequenceWithPreLaunchHold(Duration preLaunchHoldTime)` This helper method returns a `SegmentList` that contains three parts; an `InitialStateSegment`, a `HoldSegment` and this `BasicLaunchSegment`.
`void`	`enumerateDependencies(DependencyEnumerator enumerator)` Enumerates the dependencies of this object by calling `DependencyEnumerator#enumerate(T)` for each object that this object directly depends upon.
`SimpleAscentPropagatorAscentType`	`getAscentType()` Gets the interpolation type for the ascent.
`ValueDefinition<Double>`	`getBurnoutFlightPathAngle()` Gets the burnout velocity's flight path angle.
`ITimeBasedState`	`getBurnoutState()` Gets the burnout state.
`ValueDefinition<Double>`	`getBurnoutVelocityAzimuth()` Gets the burnout velocity's azimuth.
`SimpleAscentPropagatorBurnoutVelocityFrame`	`getBurnoutVelocityFrame()` Gets the reference frame that the burnout velocity is specified in.
`ValueDefinition<Double>`	`getBurnoutVelocityMagnitude()` Gets the burnout velocity magnitude in the `CentralBody` (`get` / `set`) reference frame indicated by `BurnoutVelocityFrame` (`get` / `set`).
`CentralBody`	`getCentralBody()` Gets the central body to be used for the launch segment.
`ValueDefinition<Double>`	`getInitialAcceleration()` Gets the initial acceleration at launch.
`ITimeBasedState`	`getLaunchState()` Gets the launch state.
`String`	`getMotionID()` Gets the ID in the state that represents the motion to be computed/manipulated.
`int`	`getNumberOfSamplePoints()` Gets the number of points to be sampled on the interpolation spline.
`int`	`getOrder()` Gets the order of the motion produced by the propagator.
`boolean`	`getPassAllElementsToNextSegment()` Gets a value indicating whether the segment is such that it will not define any `Elements` (`get`) or `StateElementAdapters`.
`Duration`	`getStep()` Gets the default step that the `SegmentPropagator` should create states for.
`void`	`removePropagationFinishedEvent(EventHandler<SegmentPropagationEventArgs> value)` An event that gets raised when propagation is complete.
`void`	`setAscentType(SimpleAscentPropagatorAscentType value)` Sets the interpolation type for the ascent.
`void`	`setBurnoutFlightPathAngle(ValueDefinition<Double> value)` Sets the burnout velocity's flight path angle.
`void`	`setBurnoutState(ITimeBasedState value)` Sets the burnout state.
`void`	`setBurnoutVelocityAzimuth(ValueDefinition<Double> value)` Sets the burnout velocity's azimuth.
`void`	`setBurnoutVelocityFrame(SimpleAscentPropagatorBurnoutVelocityFrame value)` Sets the reference frame that the burnout velocity is specified in.
`void`	`setBurnoutVelocityMagnitude(ValueDefinition<Double> value)` Sets the burnout velocity magnitude in the `CentralBody` (`get` / `set`) reference frame indicated by `BurnoutVelocityFrame` (`get` / `set`).
`void`	`setCentralBody(CentralBody value)` Sets the central body to be used for the launch segment.
`void`	`setInitialAcceleration(ValueDefinition<Double> value)` Sets the initial acceleration at launch.
`void`	`setLaunchState(ITimeBasedState value)` Sets the launch state.
`void`	`setMotionID(String value)` Sets the ID in the state that represents the motion to be computed/manipulated.
`void`	`setNumberOfSamplePoints(int value)` Sets the number of points to be sampled on the interpolation spline.
`void`	`setOrder(int value)` Sets the order of the motion produced by the propagator.
`void`	`setStep(Duration value)` Sets the default step that the `SegmentPropagator` should create states for.

Methods inherited from class agi.foundation.segmentpropagation.SegmentDefinition
checkForSameDefinition, containsElement, getDefinedIn, getElementAdapter, getElements, getName, getNextStateBehavior, getPropagationDirection, getSegmentPropagator, getSegmentPropagator, getSegmentPropagator, getSegmentPropagator, removeElement, setElementAndAdapter, setName, setNextStateBehavior, setPropagationDirection, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - BasicLaunchSegment
```
public BasicLaunchSegment()
```
    Initializes a new launch segment. The segment will need to be configured with the appropriate parameters before propagation can occur.
  - BasicLaunchSegment
```
public BasicLaunchSegment(@Nonnull
                          Duration step)
```
    Initializes a new launch segment with the specified step size.
    
    Parameters:
    
    step - The step size of the segment.
  - BasicLaunchSegment
```
public BasicLaunchSegment(@Nonnull
                          Duration step,
                          String motionID,
                          ITimeBasedState launchState)
```
    Initializes a new launch segment with the specified step size, launch state, and motion ID.
    
    Parameters:
    
    step - The step size of the segment.
    
    motionID - The ID of the motion element in the launch and burnout states that specifies the positions.
    
    launchState - The launch motion state.
  - BasicLaunchSegment
```
public BasicLaunchSegment(@Nonnull
                          Duration step,
                          String motionID,
                          ITimeBasedState launchState,
                          ITimeBasedState burnoutState)
```
    Initializes a new launch segment with the specified step size, launch state, burnout state, and motion ID.
    
    Parameters:
    
    step - The step size of the segment.
    
    motionID - The ID of the motion element in the launch and burnout states that specifies the positions.
    
    launchState - The launch motion state.
    
    burnoutState - The burnout state.
  - BasicLaunchSegment
```
protected BasicLaunchSegment(@Nonnull
                             BasicLaunchSegment existingInstance,
                             @Nonnull
                             CopyContext context)
```
    Initializes a new instance as a copy of an existing instance.
    See ICloneWithContext.clone(CopyContext) for more information about how to implement this constructor in a derived class.
    
    Parameters:
    
    existingInstance - The existing instance to copy.
    
    context - A CopyContext that controls the depth of the copy.
    
    Throws:
    
    ArgumentNullException - Thrown when existingInstance or context is null.
- Method Detail
  - clone
```
public Object clone(CopyContext context)
```
    Clones this object using the specified context.
    
    This method should be implemented to call a copy constructor on the class of the object being cloned. The copy constructor should take the CopyContext as a parameter in addition to the existing instance to copy. The copy constructor should first call CopyContext.addObjectMapping(T, T) to identify the newly constructed instance as a copy of the existing instance. It should then copy all fields, using CopyContext.updateReference(T) to copy any reference fields.
    
    A typical implementation of ICloneWithContext:
```
public static class MyClass implements ICloneWithContext {
    public MyClass(MyClass existingInstance, CopyContext context) {
        context.addObjectMapping(existingInstance, this);
        someReference = context.updateReference(existingInstance.someReference);
    }

    @Override
    public final Object clone(CopyContext context) {
        return new MyClass(this, context);
    }

    private Object someReference;
}
```
    In general, all fields that are reference types should be copied with a call to CopyContext.updateReference(T). There are a couple of exceptions:
    1. Fields that are aggregate parts of the object should always be copied. A referenced object is an aggregate if properties or methods on the object being copied can modify the externally-visible value of the referenced object.
    2. If the semantics of the referenced object require that it have a single parent, owner, context, etc., and the object being copied is that parent, owner, or context, then the referenced object should always be copied.
    If one of these exceptions applies, the CopyContext should be given an opportunity to update the reference before the reference is copied explicitly. Use CopyContext.updateReference(T) to update the reference. If CopyContext.updateReference(T) returns the original object, indicating that the context does not have a replacement registered, then copy the object manually by invoking a Clone method, a copy constructor, or by manually constructing a new instance and copying the values.
```
alwaysCopy = context.updateReference(existingInstance.alwaysCopy);
if (existingInstance.alwaysCopy != null && alwaysCopy == existingInstance.alwaysCopy) {
    alwaysCopy = (AlwaysCopy) existingInstance.alwaysCopy.clone(context);
}
```
    If you are implementing an evaluator (a class that implements IEvaluator), the IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) method shares some responsibilities with the copy context constructor. Code duplication can be avoided by doing the following:
    1. For references to other evaluators ONLY, simply assign the reference in the constructor instead of calling CopyContext.updateReference(T). You should still call CopyContext.updateReference(T) on any references to non-evaluators.
    2. Call IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) as the last line in the constructor and pass it the same CopyContext passed to the constructor.
    3. Implement IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) as normal. See the reference documentation for IEvaluator.updateEvaluatorReferences(agi.foundation.infrastructure.CopyContext) for more information on implementing that method.
```
public MyClass(MyClass existingInstance, CopyContext context) {
    super(existingInstance, context);
    someReference = context.updateReference(existingInstance.someReference);
    evaluatorReference = existingInstance.evaluatorReference;
    updateEvaluatorReferences(context);
}

@Override
public void updateEvaluatorReferences(CopyContext context) {
    evaluatorReference = context.updateReference(evaluatorReference);
}

@Override
public Object clone(CopyContext context) {
    return new MyClass(this, context);
}

private Object someReference;
private IEvaluator evaluatorReference;
```
    Specified by:
    
    clone in interface ICloneWithContext
    
    Specified by:
    
    clone in class DefinitionalObject
    
    Parameters:
    
    context - The context to use to perform the copy.
    
    Returns:
    
    A new instance which is a copy of this object.
  - checkForSameDefinition
```
protected final boolean checkForSameDefinition(SegmentDefinition other)
```
    Checks to determine if another instance has the same definition as this instance and returns true if it does. Derived classes MUST override this method and check all new fields introduced by the derived class for definitional equivalence. It is NOT necessary to check base class fields because the base class will already have done that. When overriding this method, you should NOT call the base implementation because it will return false for all derived-class instances. Derived classes should check the type of other to preserve the symmetric nature of IEquatableDefinition.isSameDefinition(java.lang.Object).
    
    Specified by:
    
    checkForSameDefinition in class SegmentDefinition
    
    Parameters:
    
    other - The other instance to compare to this one.
    
    Returns:
    
    true if the two objects are defined equivalently; otherwise false.
  - checkForSameDefinition
```
protected boolean checkForSameDefinition(BasicLaunchSegment other)
```
    Checks to determine if another instance has the same definition as this instance and returns true if it does. Derived classes MUST override this method and check all new fields introduced by the derived class for definitional equivalence. It is NOT necessary to check base class fields because the base class will already have done that. When overriding this method, you should NOT call the base implementation because it will return false for all derived-class instances. Derived classes should check the type of other to preserve the symmetric nature of IEquatableDefinition.isSameDefinition(java.lang.Object).
    
    Parameters:
    
    other - The other instance to compare to this one.
    
    Returns:
    
    true if the two objects are defined equivalently; otherwise false.
  - computeCurrentDefinitionHashCode
```
protected int computeCurrentDefinitionHashCode()
```
    Computes a hash code based on the current properties of this object. Derived classes MUST override this method and compute a hash code that combines: a unique hash code seed, the base implementation result, and the hash codes of all new fields introduced by the derived class which are used in the BasicLaunchSegment.checkForSameDefinition(agi.foundation.segmentpropagation.SegmentDefinition) method.
    
    Overrides:
    
    computeCurrentDefinitionHashCode in class SegmentDefinition
    
    Returns:
    
    The computed hash code.
  - enumerateDependencies
```
public void enumerateDependencies(DependencyEnumerator enumerator)
```
    Enumerates the dependencies of this object by calling DependencyEnumerator#enumerate(T) for each object that this object directly depends upon. Derived classes which contain additional dependencies MUST override this method, call the base implementation, and enumerate dependencies introduced by the derived class.
    
    Specified by:
    
    enumerateDependencies in interface IEnumerateDependencies
    
    Overrides:
    
    enumerateDependencies in class DefinitionalObject
    
    Parameters:
    
    enumerator - The enumerator that is informed of the dependencies of this object.
  - getStep
```
@Nonnull
public final Duration getStep()
```
    Gets the default step that the SegmentPropagator should create states for. This must be a positive duration.
  - setStep
```
public final void setStep(@Nonnull
                          Duration value)
```
    Sets the default step that the SegmentPropagator should create states for. This must be a positive duration.
  - createSequenceWithPreLaunchHold
```
public final SegmentList createSequenceWithPreLaunchHold(@Nonnull
                                                         Duration preLaunchHoldTime)
```
    This helper method returns a SegmentList that contains three parts; an InitialStateSegment, a HoldSegment and this BasicLaunchSegment. This sequence may then be used to model a launch segment with a pre-launch hold time. The epoch of the produced initial state segment will be the launch epoch minus the hold time.
    Note that all the required properties must be set before calling this helper method.
    
    Parameters:
    
    preLaunchHoldTime - The duration of time preceding the launch.
    
    Returns:
    
    A SegmentList that represents a launch with a hold of the input Duration.
  - getMotionID
```
public final String getMotionID()
```
    Gets the ID in the state that represents the motion to be computed/manipulated.
  - setMotionID
```
public final void setMotionID(String value)
```
    Sets the ID in the state that represents the motion to be computed/manipulated.
  - getLaunchState
```
public final ITimeBasedState getLaunchState()
```
    Gets the launch state. This needs to include a launch date and a motion whose ID matches the ID specified in MotionID (get / set).
  - setLaunchState
```
public final void setLaunchState(ITimeBasedState value)
```
    Sets the launch state. This needs to include a launch date and a motion whose ID matches the ID specified in MotionID (get / set).
  - getBurnoutState
```
public final ITimeBasedState getBurnoutState()
```
    Gets the burnout state. The state's motion element, if set, must contain the ID specified with MotionID (get / set).
  - setBurnoutState
```
public final void setBurnoutState(ITimeBasedState value)
```
    Sets the burnout state. The state's motion element, if set, must contain the ID specified with MotionID (get / set).
  - getCentralBody
```
public final CentralBody getCentralBody()
```
    Gets the central body to be used for the launch segment.
  - setCentralBody
```
public final void setCentralBody(CentralBody value)
```
    Sets the central body to be used for the launch segment.
  - getNumberOfSamplePoints
```
public final int getNumberOfSamplePoints()
```
    Gets the number of points to be sampled on the interpolation spline.
    STK's Astrogator sets this to a fixed value of 2000, which is the default.
  - setNumberOfSamplePoints
```
public final void setNumberOfSamplePoints(int value)
```
    Sets the number of points to be sampled on the interpolation spline.
    STK's Astrogator sets this to a fixed value of 2000, which is the default.
  - getBurnoutVelocityFrame
```
@Nonnull
public final SimpleAscentPropagatorBurnoutVelocityFrame getBurnoutVelocityFrame()
```
    Gets the reference frame that the burnout velocity is specified in.
  - setBurnoutVelocityFrame
```
public final void setBurnoutVelocityFrame(@Nonnull
                                          SimpleAscentPropagatorBurnoutVelocityFrame value)
```
    Sets the reference frame that the burnout velocity is specified in.
  - getAscentType
```
@Nonnull
public final SimpleAscentPropagatorAscentType getAscentType()
```
    Gets the interpolation type for the ascent. Use the quartic type when specifying an initial acceleration.
  - setAscentType
```
public final void setAscentType(@Nonnull
                                SimpleAscentPropagatorAscentType value)
```
    Sets the interpolation type for the ascent. Use the quartic type when specifying an initial acceleration.
  - getBurnoutVelocityAzimuth
```
public final ValueDefinition<Double> getBurnoutVelocityAzimuth()
```
    Gets the burnout velocity's azimuth. This defaults to zero.
  - setBurnoutVelocityAzimuth
```
public final void setBurnoutVelocityAzimuth(ValueDefinition<Double> value)
```
    Sets the burnout velocity's azimuth. This defaults to zero.
  - getBurnoutFlightPathAngle
```
public final ValueDefinition<Double> getBurnoutFlightPathAngle()
```
    Gets the burnout velocity's flight path angle. This defaults to zero.
  - setBurnoutFlightPathAngle
```
public final void setBurnoutFlightPathAngle(ValueDefinition<Double> value)
```
    Sets the burnout velocity's flight path angle. This defaults to zero.
  - getOrder
```
public final int getOrder()
```
    Gets the order of the motion produced by the propagator. This may be up to jerk (order 3).
  - setOrder
```
public final void setOrder(int value)
```
    Sets the order of the motion produced by the propagator. This may be up to jerk (order 3).
  - getBurnoutVelocityMagnitude
```
public final ValueDefinition<Double> getBurnoutVelocityMagnitude()
```
    Gets the burnout velocity magnitude in the CentralBody (get / set) reference frame indicated by BurnoutVelocityFrame (get / set). This defaults to zero m/s.
  - setBurnoutVelocityMagnitude
```
public final void setBurnoutVelocityMagnitude(ValueDefinition<Double> value)
```
    Sets the burnout velocity magnitude in the CentralBody (get / set) reference frame indicated by BurnoutVelocityFrame (get / set). This defaults to zero m/s.
  - getInitialAcceleration
```
public final ValueDefinition<Double> getInitialAcceleration()
```
    Gets the initial acceleration at launch. The AscentType (get / set) type must be set to quartic to use. This defaults to zero m/s^2.
  - setInitialAcceleration
```
public final void setInitialAcceleration(ValueDefinition<Double> value)
```
    Sets the initial acceleration at launch. The AscentType (get / set) type must be set to quartic to use. This defaults to zero m/s^2.
  - getPassAllElementsToNextSegment
```
public boolean getPassAllElementsToNextSegment()
```
    Gets a value indicating whether the segment is such that it will not define any Elements (get) or StateElementAdapters. Such a segment typically affects the control flow of multiple segments instead of propagating state elements. By default this is false, but if the specific derived segment can use the previous segment's adapters, override this property to always return true. Even if this is true some segments may require adapters to be set with the SegmentDefinition.setElementAndAdapter(agi.foundation.coordinates.StateElementAdapterDefinition) method.
    
    Overrides:
    
    getPassAllElementsToNextSegment in class SegmentDefinition
  - createSegmentPropagator
```
protected SegmentPropagator createSegmentPropagator(EvaluatorGroup group,
                                                    SegmentDefinition previousSegment)
```
    Creates, configures, and returns the SegmentPropagator for this segment. This method should check that all of the required properties on the concrete instance are configured properly before constructing the SegmentPropagator to be returned.
    
    Specified by:
    
    createSegmentPropagator in class SegmentDefinition
    
    Parameters:
    
    group - The group to use during creation.
    
    previousSegment - The previous segment. Some segments will require the previousSegment to be set, whereas other will require that the previous segment not be null, whereas others will only use information from it if provided. It is up to you writing a concrete type to enforce what makes sense for your particular segment in this method.
    
    Returns:
    
    The propagator for this segment.
  - addPropagationFinishedEvent
```
public void addPropagationFinishedEvent(EventHandler<SegmentPropagationEventArgs> value)
```
    An event that gets raised when propagation is complete.
    
    Specified by:
    
    addPropagationFinishedEvent in class SegmentDefinition
  - removePropagationFinishedEvent
```
public void removePropagationFinishedEvent(EventHandler<SegmentPropagationEventArgs> value)
```
    An event that gets raised when propagation is complete.
    
    Specified by:
    
    removePropagationFinishedEvent in class SegmentDefinition

Class BasicLaunchSegment

Constructor Summary

Method Summary

Methods inherited from class agi.foundation.segmentpropagation.SegmentDefinition

Methods inherited from class agi.foundation.infrastructure.DefinitionalObject

Methods inherited from class java.lang.Object

Constructor Detail

BasicLaunchSegment

BasicLaunchSegment

BasicLaunchSegment

BasicLaunchSegment

Method Detail

clone

checkForSameDefinition

checkForSameDefinition

computeCurrentDefinitionHashCode

enumerateDependencies

getStep

setStep

createSequenceWithPreLaunchHold

getMotionID

setMotionID

getLaunchState

setLaunchState

getBurnoutState

setBurnoutState

getCentralBody

setCentralBody

getNumberOfSamplePoints

setNumberOfSamplePoints

getBurnoutVelocityFrame

setBurnoutVelocityFrame

getAscentType

setAscentType

getBurnoutVelocityAzimuth

setBurnoutVelocityAzimuth

getBurnoutFlightPathAngle

setBurnoutFlightPathAngle

getOrder

setOrder

getBurnoutVelocityMagnitude

setBurnoutVelocityMagnitude

getInitialAcceleration

setInitialAcceleration

getPassAllElementsToNextSegment

createSegmentPropagator

addPropagationFinishedEvent

removePropagationFinishedEvent