Package org.orekit.utils

Class TimeStampedFieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>>

  • Type Parameters:
    T - the type of the field elements
    public class TimeStampedFieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>>
extends FieldAngularCoordinates<T>
    time-stamped version of FieldAngularCoordinates.

    Instances of this class are guaranteed to be immutable.

    Since:
    7.0
    Author:
    Luc Maisonobe

    • Constructor Detail

      • TimeStampedFieldAngularCoordinates

        public TimeStampedFieldAngularCoordinates​(AbsoluteDate date,
                                          FieldPVCoordinates<T> u1,
                                          FieldPVCoordinates<T> u2,
                                          FieldPVCoordinates<T> v1,
                                          FieldPVCoordinates<T> v2,
                                          double tolerance)
        Build the rotation that transforms a pair of pv coordinates into another pair.

        WARNING! This method requires much more stringent assumptions on its parameters than the similar constructor from the Rotation class. As far as the Rotation constructor is concerned, the v₂ vector from the second pair can be slightly misaligned. The Rotation constructor will compensate for this misalignment and create a rotation that ensure v₁ = r(u₁) and v₂ ∈ plane (r(u₁), r(u₂)). THIS IS NOT TRUE ANYMORE IN THIS CLASS! As derivatives are involved and must be preserved, this constructor works only if the two pairs are fully consistent, i.e. if a rotation exists that fulfill all the requirements: v₁ = r(u₁), v₂ = r(u₂), dv₁/dt = dr(u₁)/dt, dv₂/dt = dr(u₂)/dt, d²v₁/dt² = d²r(u₁)/dt², d²v₂/dt² = d²r(u₂)/dt².

        Parameters:
        date - coordinates date
        u1 - first vector of the origin pair
        u2 - second vector of the origin pair
        v1 - desired image of u1 by the rotation
        v2 - desired image of u2 by the rotation
        tolerance - relative tolerance factor used to check singularities

      • TimeStampedFieldAngularCoordinates

        public TimeStampedFieldAngularCoordinates​(FieldAbsoluteDate<T> date,
                                          FieldPVCoordinates<T> u1,
                                          FieldPVCoordinates<T> u2,
                                          FieldPVCoordinates<T> v1,
                                          FieldPVCoordinates<T> v2,
                                          double tolerance)
        Build the rotation that transforms a pair of pv coordinates into another pair.

        WARNING! This method requires much more stringent assumptions on its parameters than the similar constructor from the Rotation class. As far as the Rotation constructor is concerned, the v₂ vector from the second pair can be slightly misaligned. The Rotation constructor will compensate for this misalignment and create a rotation that ensure v₁ = r(u₁) and v₂ ∈ plane (r(u₁), r(u₂)). THIS IS NOT TRUE ANYMORE IN THIS CLASS! As derivatives are involved and must be preserved, this constructor works only if the two pairs are fully consistent, i.e. if a rotation exists that fulfill all the requirements: v₁ = r(u₁), v₂ = r(u₂), dv₁/dt = dr(u₁)/dt, dv₂/dt = dr(u₂)/dt, d²v₁/dt² = d²r(u₁)/dt², d²v₂/dt² = d²r(u₂)/dt².

        Parameters:
        date - coordinates date
        u1 - first vector of the origin pair
        u2 - second vector of the origin pair
        v1 - desired image of u1 by the rotation
        v2 - desired image of u2 by the rotation
        tolerance - relative tolerance factor used to check singularities

      • TimeStampedFieldAngularCoordinates

        public TimeStampedFieldAngularCoordinates​(AbsoluteDate date,
                                          org.hipparchus.geometry.euclidean.threed.FieldRotation<T> rotation,
                                          org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationRate,
                                          org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationAcceleration)
        Builds a rotation/rotation rate pair.
        Parameters:
        date - coordinates date
        rotation - rotation
        rotationRate - rotation rate Ω (rad/s)
        rotationAcceleration - rotation acceleration dΩ/dt (rad²/s²)

      • TimeStampedFieldAngularCoordinates

        public TimeStampedFieldAngularCoordinates​(FieldAbsoluteDate<T> date,
                                          org.hipparchus.geometry.euclidean.threed.FieldRotation<T> rotation,
                                          org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationRate,
                                          org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationAcceleration)
        Builds a rotation/rotation rate pair.
        Parameters:
        date - coordinates date
        rotation - rotation
        rotationRate - rotation rate Ω (rad/s)
        rotationAcceleration - rotation acceleration dΩ/dt (rad²/s²)

      • TimeStampedFieldAngularCoordinates

        public TimeStampedFieldAngularCoordinates​(org.hipparchus.Field<T> field,
                                          TimeStampedAngularCoordinates ac)
        Builds an instance for a regular TimeStampedAngularCoordinates.
        Parameters:
        field - fields to which the elements belong
        ac - coordinates to convert
        Since:
        9.0

      • TimeStampedFieldAngularCoordinates

        public TimeStampedFieldAngularCoordinates​(FieldAbsoluteDate<T> date,
                                          org.hipparchus.geometry.euclidean.threed.FieldRotation<org.hipparchus.analysis.differentiation.FieldDerivativeStructure<T>> r)
        Builds a TimeStampedFieldAngularCoordinates from a FieldRotation<FieldDerivativeStructure>.

        The rotation components must have time as their only derivation parameter and have consistent derivation orders.

        Parameters:
        date - coordinates date
        r - rotation with time-derivatives embedded within the coordinates
        Since:
        9.2

    • Method Detail

      • revert

        public TimeStampedFieldAngularCoordinates<T> revert()
        Revert a rotation/rotation rate pair. Build a pair which reverse the effect of another pair.
        Overrides:
        revert in class FieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>>
        Returns:
        a new pair whose effect is the reverse of the effect of the instance

      • shiftedBy

        public TimeStampedFieldAngularCoordinates<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 linear model. It is not intended as a replacement for proper attitude propagation but should be sufficient for either small time shifts or coarse accuracy.

        Overrides:
        shiftedBy in class FieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>>
        Parameters:
        dt - time shift in seconds
        Returns:
        a new state, shifted with respect to the instance (which is immutable)

      • shiftedBy

        public TimeStampedFieldAngularCoordinates<T> shiftedBy​(T dt)
        Get a time-shifted state.

        The state can be slightly shifted to close dates. This shift is based on a simple linear model. It is not intended as a replacement for proper attitude propagation but should be sufficient for either small time shifts or coarse accuracy.

        Overrides:
        shiftedBy in class FieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>>
        Parameters:
        dt - time shift in seconds
        Returns:
        a new state, shifted with respect to the instance (which is immutable)

      • addOffset

        public TimeStampedFieldAngularCoordinates<T> addOffset​(FieldAngularCoordinates<T> offset)
        Add 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.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.

        Overrides:
        addOffset in class FieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>>
        Parameters:
        offset - offset to subtract
        Returns:
        new instance, with offset subtracted
        See Also:
        subtractOffset(FieldAngularCoordinates)

      • subtractOffset

        public TimeStampedFieldAngularCoordinates<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.

        Overrides:
        subtractOffset in class FieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>>
        Parameters:
        offset - offset to subtract
        Returns:
        new instance, with offset subtracted
        See Also:
        addOffset(FieldAngularCoordinates)

      • interpolate

        public static <T extends org.hipparchus.RealFieldElement<T>> TimeStampedFieldAngularCoordinates<T> interpolate​(AbsoluteDate date,
                                                                                                               AngularDerivativesFilter filter,
                                                                                                               Collection<TimeStampedFieldAngularCoordinates<T>> sample)
        Interpolate angular coordinates.

        The interpolated instance is created by polynomial Hermite interpolation on Rodrigues vector ensuring rotation rate remains the exact derivative of rotation.

        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 rotations when this singularity is detected.

        Note that even if first time derivatives (rotation 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 rotations.

        Type Parameters:
        T - the type of the field elements
        Parameters:
        date - interpolation date
        filter - filter for derivatives from the sample to use in interpolation
        sample - sample points on which interpolation should be done
        Returns:
        a new position-velocity, interpolated at specified date

      • interpolate

        public static <T extends org.hipparchus.RealFieldElement<T>> TimeStampedFieldAngularCoordinates<T> interpolate​(FieldAbsoluteDate<T> date,
                                                                                                               AngularDerivativesFilter filter,
                                                                                                               Collection<TimeStampedFieldAngularCoordinates<T>> sample)
        Interpolate angular coordinates.

        The interpolated instance is created by polynomial Hermite interpolation on Rodrigues vector ensuring rotation rate remains the exact derivative of rotation.

        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 rotations when this singularity is detected.

        Note that even if first time derivatives (rotation 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 rotations.

        Type Parameters:
        T - the type of the field elements
        Parameters:
        date - interpolation date
        filter - filter for derivatives from the sample to use in interpolation
        sample - sample points on which interpolation should be done
        Returns:
        a new position-velocity, interpolated at specified date