FieldAngularCoordinates (ORbit Extrapolation KIT 7.0 API)

java.lang.Object
- org.orekit.utils.FieldAngularCoordinates<T>

Type Parameters:
T - the type of the field elements

All Implemented Interfaces:

Serializable, TimeShiftable<FieldAngularCoordinates<T>>

Direct Known Subclasses:

TimeStampedFieldAngularCoordinates
```
public class FieldAngularCoordinates<T extends RealFieldElement<T>>
extends Object
implements TimeShiftable<FieldAngularCoordinates<T>>, Serializable
```
Simple container for FieldRotation/FieldRotation rate pairs, using RealFieldElement.
The state can be slightly shifted to close dates. This shift is based on a simple quadratic model. It is not intended as a replacement for proper attitude propagation but should be sufficient for either small time shifts or coarse accuracy.

This class is the angular counterpart to FieldPVCoordinates.

Instances of this class are guaranteed to be immutable.

Since:

6.0

Author:

Luc Maisonobe

See Also:
AngularCoordinates, Serialized Form

Constructor Summary

Constructors
Constructor and Description
`FieldAngularCoordinates(FieldRotation<T> rotation, FieldVector3D<T> rotationRate)` Builds a rotation/rotation rate pair.
`FieldAngularCoordinates(FieldRotation<T> rotation, FieldVector3D<T> rotationRate, FieldVector3D<T> rotationAcceleration)` Builds a FieldRotation/FieldRotation rate/FieldRotation acceleration triplet.

Method Summary

Methods
Modifier and Type	Method and Description
`FieldAngularCoordinates<T>`	`addOffset(FieldAngularCoordinates<T> offset)` Add an offset from the instance.
`static <T extends RealFieldElement<T>> FieldVector3D<T>`	`estimateRate(FieldRotation<T> start, FieldRotation<T> end, double dt)` Estimate FieldRotation rate between two orientations.
`FieldRotation<T>`	`getRotation()` Get the FieldRotation.
`FieldVector3D<T>`	`getRotationAcceleration()` Get the rotation acceleration.
`FieldVector3D<T>`	`getRotationRate()` Get the FieldRotation rate.
`static <T extends RealFieldElement<T>> FieldAngularCoordinates<T>`	`interpolate(AbsoluteDate date, boolean useRotationRates, Collection<Pair<AbsoluteDate,FieldAngularCoordinates<T>>> sample)` Deprecated. since 7.0 replaced with `TimeStampedFieldAngularCoordinates.interpolate(AbsoluteDate, AngularDerivativesFilter, Collection)`
`FieldAngularCoordinates<T>`	`revert()` Revert a FieldRotation/FieldRotation/FieldRotation acceleration triplet.
`FieldAngularCoordinates<T>`	`shiftedBy(double dt)` Get a time-shifted state.
`FieldAngularCoordinates<T>`	`subtractOffset(FieldAngularCoordinates<T> offset)` Subtract an offset from the instance.
`AngularCoordinates`	`toAngularCoordinates()` Convert to a regular angular coordinates.

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

- Constructor Detail
  - FieldAngularCoordinates
```
public FieldAngularCoordinates(FieldRotation<T> rotation,
                       FieldVector3D<T> rotationRate)
```
    Builds a rotation/rotation rate pair.
    
    Parameters:
    rotation - rotation
    rotationRate - rotation rate Ω (rad/s)
  - FieldAngularCoordinates
```
public FieldAngularCoordinates(FieldRotation<T> rotation,
                       FieldVector3D<T> rotationRate,
                       FieldVector3D<T> rotationAcceleration)
```
    Builds a FieldRotation/FieldRotation rate/FieldRotation acceleration triplet.
    
    Parameters:
    rotation - FieldRotation
    rotationRate - FieldRotation rate Ω (rad/s)
    rotationAcceleration - FieldRotation acceleration dΩ/dt (rad²/s²)
- Method Detail
  - estimateRate
```
public static <T extends RealFieldElement<T>> FieldVector3D<T> estimateRate(FieldRotation<T> start,
                                                            FieldRotation<T> end,
                                                            double dt)
```
    Estimate FieldRotation rate between two orientations.
    Estimation is based on a simple fixed rate FieldRotation during the time interval between the two orientations.
    
    Type Parameters:
    T - the type of the field elements
    Parameters:
    start - start orientation
    end - end orientation
    dt - time elapsed between the dates of the two orientations
    
    Returns:
    FieldRotation rate allowing to go from start to end orientations
  - revert
```
public FieldAngularCoordinates<T> revert()
```
    Revert a FieldRotation/FieldRotation/FieldRotation acceleration triplet. Build a triplet which reverse the effect of another triplet.
    
    Returns:
    a new triplet whose effect is the reverse of the effect of the instance
  - shiftedBy
```
public FieldAngularCoordinates<T> shiftedBy(double dt)
```
    Get a time-shifted state.
    The state can be slightly shifted to close dates. This shift is based on a simple quadratic model. It is not intended as a replacement for proper attitude propagation but should be sufficient for either small time shifts or coarse accuracy.
    
    Specified by:
    
    shiftedBy in interface TimeShiftable<FieldAngularCoordinates<T extends RealFieldElement<T>>>
    
    Parameters:
    dt - time shift in seconds
    
    Returns:
    a new state, shifted with respect to the instance (which is immutable)
  - getRotation
```
public FieldRotation<T> getRotation()
```
    Get the FieldRotation.
    
    Returns:
    the FieldRotation.
  - getRotationRate
```
public FieldVector3D<T> getRotationRate()
```
    Get the FieldRotation rate.
    
    Returns:
    the FieldRotation rate vector (rad/s).
  - getRotationAcceleration
```
public FieldVector3D<T> getRotationAcceleration()
```
    Get the rotation acceleration.
    
    Returns:
    the rotation acceleration vector dΩ/dt (rad²/s²).
  - addOffset
```
public FieldAngularCoordinates<T> addOffset(FieldAngularCoordinates<T> offset)
```
    Add an offset from the instance.
    We consider here that the offset FieldRotation is applied first and the instance is applied afterward. Note that angular coordinates do not commute under this operation, i.e. a.addOffset(b) and b.addOffset(a) lead to different results in most cases.
    
    The two methods addOffset and subtractOffset are designed so that round trip applications are possible. This means that both ac1.subtractOffset(ac2).addOffset(ac2) and ac1.addOffset(ac2).subtractOffset(ac2) return angular coordinates equal to ac1.
    
    Parameters:
    offset - offset to subtract
    
    Returns:
    new instance, with offset subtracted
    See Also:
    subtractOffset(FieldAngularCoordinates)
  - subtractOffset
```
public FieldAngularCoordinates<T> subtractOffset(FieldAngularCoordinates<T> offset)
```
    Subtract an offset from the instance.
    We consider here that the offset Rotation is applied first and the instance is applied afterward. Note that angular coordinates do not commute under this operation, i.e. a.subtractOffset(b) and b.subtractOffset(a) lead to different results in most cases.
    
    The two methods addOffset and subtractOffset are designed so that round trip applications are possible. This means that both ac1.subtractOffset(ac2).addOffset(ac2) and ac1.addOffset(ac2).subtractOffset(ac2) return angular coordinates equal to ac1.
    
    Parameters:
    offset - offset to subtract
    
    Returns:
    new instance, with offset subtracted
    See Also:
    addOffset(FieldAngularCoordinates)
  - toAngularCoordinates
```
public AngularCoordinates toAngularCoordinates()
```
    Convert to a regular angular coordinates.
    
    Returns:
    a regular angular coordinates
  - interpolate
```
@Deprecated
public static <T extends RealFieldElement<T>> FieldAngularCoordinates<T> interpolate(AbsoluteDate date,
                                                                                boolean useRotationRates,
                                                                                Collection<Pair<AbsoluteDate,FieldAngularCoordinates<T>>> sample)
                                                                          throws OrekitException
```
    Deprecated. since 7.0 replaced with TimeStampedFieldAngularCoordinates.interpolate(AbsoluteDate, AngularDerivativesFilter, Collection)
    
    Interpolate angular coordinates.
    The interpolated instance is created by polynomial Hermite interpolation on Rodrigues vector ensuring FieldRotation rate remains the exact derivative of FieldRotation.
    
    This method is based on Sergei Tanygin's paper Attitude Interpolation, changing the norm of the vector to match the modified Rodrigues vector as described in Malcolm D. Shuster's paper A Survey of Attitude Representations. This change avoids the singularity at π. There is still a singularity at 2π, which is handled by slightly offsetting all FieldRotations when this singularity is detected.
    
    Note that even if first time derivatives (FieldRotation rates) from sample can be ignored, the interpolated instance always includes interpolated derivatives. This feature can be used explicitly to compute these derivatives when it would be too complex to compute them from an analytical formula: just compute a few sample points from the explicit formula and set the derivatives to zero in these sample points, then use interpolation to add derivatives consistent with the FieldRotations.
    
    Type Parameters:
    T - the type of the field elements
    Parameters:
    date - interpolation date
    useRotationRates - if true, use sample points FieldRotation rates, otherwise ignore them and use only FieldRotations
    sample - sample points on which interpolation should be done
    
    Returns:
    a new position-velocity, interpolated at specified date
    
    Throws:
    
    OrekitException - if the number of point is too small for interpolating

Class FieldAngularCoordinates<T extends RealFieldElement<T>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FieldAngularCoordinates

FieldAngularCoordinates

Method Detail

estimateRate

revert

shiftedBy

getRotation

getRotationRate

getRotationAcceleration

addOffset

subtractOffset

toAngularCoordinates

interpolate