Class FieldAbsolutePVCoordinates<T extends CalculusFieldElement<T>>

    • Constructor Detail

      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(Frame frame,
                                          FieldAbsoluteDate<T> date,
                                          FieldVector3D<T> position,
                                          FieldVector3D<T> velocity,
                                          FieldVector3D<T> acceleration)
        Build from position, velocity, acceleration.
        Parameters:
        frame - the frame in which the coordinates are defined
        date - coordinates date
        position - the position vector (m)
        velocity - the velocity vector (m/s)
        acceleration - the acceleration vector (m/sÂý)
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(Frame frame,
                                          FieldAbsoluteDate<T> date,
                                          FieldVector3D<T> position,
                                          FieldVector3D<T> velocity)
        Build from position and velocity. Acceleration is set to zero.
        Parameters:
        frame - the frame in which the coordinates are defined
        date - coordinates date
        position - the position vector (m)
        velocity - the velocity vector (m/s)
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(Frame frame,
                                          FieldAbsoluteDate<T> date,
                                          FieldPVCoordinates<T> pva)
        Build from frame, date and FieldPVA coordinates.
        Parameters:
        frame - the frame in which the coordinates are defined
        date - date of the coordinates
        pva - TimeStampedPVCoordinates
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(Frame frame,
                                          TimeStampedFieldPVCoordinates<T> pva)
        Build from frame and TimeStampedFieldPVCoordinates.
        Parameters:
        frame - the frame in which the coordinates are defined
        pva - TimeStampedFieldPVCoordinates
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(FieldAbsoluteDate<T> date,
                                          T a,
                                          FieldAbsolutePVCoordinates<T> AbsPva)
        Multiplicative constructor

        Build a FieldAbsolutePVCoordinates from another one and a scale factor.

        The TimeStampedFieldPVCoordinates built will be a * AbsPva

        Parameters:
        date - date of the built coordinates
        a - scale factor
        AbsPva - base (unscaled) FieldAbsolutePVCoordinates
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(FieldAbsoluteDate<T> date,
                                          FieldAbsolutePVCoordinates<T> start,
                                          FieldAbsolutePVCoordinates<T> end)
        Subtractive constructor

        Build a relative FieldAbsolutePVCoordinates from a start and an end position.

        The FieldAbsolutePVCoordinates built will be end - start.

        In case start and end use two different pseudo-inertial frames, the new FieldAbsolutePVCoordinates arbitrarily be defined in the start frame.

        Parameters:
        date - date of the built coordinates
        start - Starting FieldAbsolutePVCoordinates
        end - ending FieldAbsolutePVCoordinates
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(FieldAbsoluteDate<T> date,
                                          T a1,
                                          FieldAbsolutePVCoordinates<T> absPv1,
                                          T a2,
                                          FieldAbsolutePVCoordinates<T> absPv2)
        Linear constructor

        Build a FieldAbsolutePVCoordinates from two other ones and corresponding scale factors.

        The FieldAbsolutePVCoordinates built will be a1 * u1 + a2 * u2

        In case the FieldAbsolutePVCoordinates use different pseudo-inertial frames, the new FieldAbsolutePVCoordinates arbitrarily be defined in the first frame.

        Parameters:
        date - date of the built coordinates
        a1 - first scale factor
        absPv1 - first base (unscaled) FieldAbsolutePVCoordinates
        a2 - second scale factor
        absPv2 - second base (unscaled) FieldAbsolutePVCoordinates
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(FieldAbsoluteDate<T> date,
                                          T a1,
                                          FieldAbsolutePVCoordinates<T> absPv1,
                                          T a2,
                                          FieldAbsolutePVCoordinates<T> absPv2,
                                          T a3,
                                          FieldAbsolutePVCoordinates<T> absPv3)
        Linear constructor

        Build a FieldAbsolutePVCoordinates from three other ones and corresponding scale factors.

        The FieldAbsolutePVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3

        In case the FieldAbsolutePVCoordinates use different pseudo-inertial frames, the new FieldAbsolutePVCoordinates arbitrarily be defined in the first frame.

        Parameters:
        date - date of the built coordinates
        a1 - first scale factor
        absPv1 - first base (unscaled) FieldAbsolutePVCoordinates
        a2 - second scale factor
        absPv2 - second base (unscaled) FieldAbsolutePVCoordinates
        a3 - third scale factor
        absPv3 - third base (unscaled) FieldAbsolutePVCoordinates
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(FieldAbsoluteDate<T> date,
                                          T a1,
                                          FieldAbsolutePVCoordinates<T> absPv1,
                                          T a2,
                                          FieldAbsolutePVCoordinates<T> absPv2,
                                          T a3,
                                          FieldAbsolutePVCoordinates<T> absPv3,
                                          T a4,
                                          FieldAbsolutePVCoordinates<T> absPv4)
        Linear constructor

        Build a FieldAbsolutePVCoordinates from four other ones and corresponding scale factors.

        The FieldAbsolutePVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4

        In case the FieldAbsolutePVCoordinates use different pseudo-inertial frames, the new AbsolutePVCoordinates arbitrarily be defined in the first frame.

        Parameters:
        date - date of the built coordinates
        a1 - first scale factor
        absPv1 - first base (unscaled) FieldAbsolutePVCoordinates
        a2 - second scale factor
        absPv2 - second base (unscaled) FieldAbsolutePVCoordinates
        a3 - third scale factor
        absPv3 - third base (unscaled) FieldAbsolutePVCoordinates
        a4 - fourth scale factor
        absPv4 - fourth base (unscaled) FieldAbsolutePVCoordinates
      • FieldAbsolutePVCoordinates

        public FieldAbsolutePVCoordinates​(Frame frame,
                                          FieldAbsoluteDate<T> date,
                                          FieldVector3D<U> p)
        Builds a FieldAbsolutePVCoordinates triplet from a FieldVector3D<DerivativeStructure>.

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

        Type Parameters:
        U - type of the derivative
        Parameters:
        frame - the frame in which the parameters are defined
        date - date of the built coordinates
        p - vector with time-derivatives embedded within the coordinates
    • Method Detail

      • shiftedBy

        public FieldAbsolutePVCoordinates<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 Taylor expansion. It is not intended as a replacement for proper orbit propagation (it is not even Keplerian!) but should be sufficient for either small time shifts or coarse accuracy.

        Overrides:
        shiftedBy in class TimeStampedFieldPVCoordinates<T extends CalculusFieldElement<T>>
        Parameters:
        dt - time shift in seconds
        Returns:
        a new state, shifted with respect to the instance (which is immutable)
      • shiftedBy

        public FieldAbsolutePVCoordinates<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 Taylor expansion. It is not intended as a replacement for proper orbit propagation (it is not even Keplerian!) but should be sufficient for either small time shifts or coarse accuracy.

        Specified by:
        shiftedBy in interface TimeShiftable<T extends CalculusFieldElement<T>>
        Overrides:
        shiftedBy in class TimeStampedFieldPVCoordinates<T extends CalculusFieldElement<T>>
        Parameters:
        dt - time shift in seconds
        Returns:
        a new state, shifted with respect to the instance (which is immutable)
      • toTaylorProvider

        public FieldPVCoordinatesProvider<T> toTaylorProvider()
        Create a local provider using simply Taylor expansion through shiftedBy(double).

        The time evolution is based on a simple Taylor expansion. It is not intended as a replacement for proper orbit propagation (it is not even Keplerian!) but should be sufficient for either small time shifts or coarse accuracy.

        Returns:
        provider based on Taylor expansion, for small time shifts around instance date
      • getFrame

        public Frame getFrame()
        Get the frame in which the coordinates are defined.
        Returns:
        frame in which the coordinates are defined
      • getPVCoordinates

        public TimeStampedFieldPVCoordinates<T> getPVCoordinates()
        Get the TimeStampedFieldPVCoordinates.
        Returns:
        TimeStampedFieldPVCoordinates
      • getPVCoordinates

        public TimeStampedFieldPVCoordinates<T> getPVCoordinates​(Frame outputFrame)
        Get the TimeStampedFieldPVCoordinates in a specified frame.
        Parameters:
        outputFrame - frame in which the position/velocity coordinates shall be computed
        Returns:
        TimeStampedFieldPVCoordinates
        Throws:
        OrekitException - if transformation between frames cannot be computed
        See Also:
        getPVCoordinates()
      • interpolate

        public FieldAbsolutePVCoordinates<T> interpolate​(FieldAbsoluteDate<T> date,
                                                         Stream<FieldAbsolutePVCoordinates<T>> sample)
        Description copied from interface: FieldTimeInterpolable
        Get an interpolated instance.

        Note that the state of the current instance may not be used in the interpolation process, only its type and non interpolable fields are used (for example central attraction coefficient or frame when interpolating orbits). The interpolable fields taken into account are taken only from the states of the sample points. So if the state of the instance must be used, the instance should be included in the sample points.

        Note that this method is designed for small samples only (say up to about 10-20 points) so it can be implemented using polynomial interpolation (typically Hermite interpolation). Using too much points may induce Runge's phenomenon and numerical problems (including NaN appearing).

        Specified by:
        interpolate in interface FieldTimeInterpolable<FieldAbsolutePVCoordinates<T extends CalculusFieldElement<T>>,​T extends CalculusFieldElement<T>>
        Parameters:
        date - interpolation date
        sample - sample points on which interpolation should be done
        Returns:
        a new instance, interpolated at specified date
      • interpolate

        public static <T extends CalculusFieldElement<T>> FieldAbsolutePVCoordinates<T> interpolate​(Frame frame,
                                                                                                    FieldAbsoluteDate<T> date,
                                                                                                    CartesianDerivativesFilter filter,
                                                                                                    Stream<FieldAbsolutePVCoordinates<T>> sample)
        Interpolate position-velocity.

        The interpolated instance is created by polynomial Hermite interpolation ensuring velocity remains the exact derivative of position.

        Note that even if first time derivatives (velocities) 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 positions.

        Type Parameters:
        T - the type of the field elements
        Parameters:
        frame - frame for the interpolted instance
        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
        Throws:
        OrekitIllegalArgumentException - if some elements in the sample do not have the same defining frame as other
      • toAbsolutePVCoordinates

        public AbsolutePVCoordinates toAbsolutePVCoordinates()
        Converts to an AbsolutePVCoordinates instance.
        Returns:
        AbsolutePVCoordinates with same properties