Package org.orekit.orbits

Class FieldOrbit<T extends CalculusFieldElement<T>>

    • Field Detail

      • TOLERANCE_POSITION_ANGLE_RATE

        protected static final double TOLERANCE_POSITION_ANGLE_RATE
        Absolute tolerance when checking if the rate of the position angle is Keplerian or not.
        See Also:
        Constant Field Values

    • Method Detail

      • hasNonKeplerianAcceleration

        protected static <T extends CalculusFieldElement<T>> boolean hasNonKeplerianAcceleration​(FieldPVCoordinates<T> pva,
                                                                                         T mu)
        Check if Cartesian coordinates include non-Keplerian acceleration.
        Type Parameters:
        T - type of the field elements
        Parameters:
        pva - Cartesian coordinates
        mu - central attraction coefficient
        Returns:
        true if Cartesian coordinates include non-Keplerian acceleration

      • isElliptical

        public boolean isElliptical()
        Returns true if and only if the orbit is elliptical i.e. has a non-negative semi-major axis.
        Returns:
        true if getA() is strictly greater than 0
        Since:
        12.0

      • getType

        public abstract OrbitType getType()
        Get the orbit type.
        Returns:
        orbit type

      • getFrame

        public Frame getFrame()
        Get the frame in which the orbital parameters are defined.
        Returns:
        frame in which the orbital parameters are defined

      • toOrbit

        public abstract Orbit toOrbit()
        Transforms the FieldOrbit instance into an Orbit instance.
        Returns:
        Orbit instance with same properties

      • getA

        public abstract T getA()
        Get the semi-major axis.

        Note that the semi-major axis is considered negative for hyperbolic orbits.

        Returns:
        semi-major axis (m)

      • getADot

        public abstract T getADot()
        Get the semi-major axis derivative.

        Note that the semi-major axis is considered negative for hyperbolic orbits.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        semi-major axis derivative (m/s)

      • getEquinoctialEx

        public abstract T getEquinoctialEx()
        Get the first component of the equinoctial eccentricity vector.
        Returns:
        first component of the equinoctial eccentricity vector

      • getEquinoctialExDot

        public abstract T getEquinoctialExDot()
        Get the first component of the equinoctial eccentricity vector derivative.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        first component of the equinoctial eccentricity vector derivative

      • getEquinoctialEy

        public abstract T getEquinoctialEy()
        Get the second component of the equinoctial eccentricity vector.
        Returns:
        second component of the equinoctial eccentricity vector

      • getEquinoctialEyDot

        public abstract T getEquinoctialEyDot()
        Get the second component of the equinoctial eccentricity vector derivative.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        second component of the equinoctial eccentricity vector derivative

      • getHx

        public abstract T getHx()
        Get the first component of the inclination vector.
        Returns:
        first component of the inclination vector

      • getHxDot

        public abstract T getHxDot()
        Get the first component of the inclination vector derivative.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        first component of the inclination vector derivative

      • getHy

        public abstract T getHy()
        Get the second component of the inclination vector.
        Returns:
        second component of the inclination vector

      • getHyDot

        public abstract T getHyDot()
        Get the second component of the inclination vector derivative.
        Returns:
        second component of the inclination vector derivative

      • getLE

        public abstract T getLE()
        Get the eccentric longitude argument.
        Returns:
        E + ω + Ω eccentric longitude argument (rad)

      • getLEDot

        public abstract T getLEDot()
        Get the eccentric longitude argument derivative.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        d(E + ω + Ω)/dt eccentric longitude argument derivative (rad/s)

      • getLv

        public abstract T getLv()
        Get the true longitude argument.
        Returns:
        v + ω + Ω true longitude argument (rad)

      • getLvDot

        public abstract T getLvDot()
        Get the true longitude argument derivative.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        d(v + ω + Ω)/dt true longitude argument derivative (rad/s)

      • getLM

        public abstract T getLM()
        Get the mean longitude argument.
        Returns:
        M + ω + Ω mean longitude argument (rad)

      • getLMDot

        public abstract T getLMDot()
        Get the mean longitude argument derivative.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        d(M + ω + Ω)/dt mean longitude argument derivative (rad/s)

      • getE

        public abstract T getE()
        Get the eccentricity.
        Returns:
        eccentricity

      • getEDot

        public abstract T getEDot()
        Get the eccentricity derivative.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        eccentricity derivative

      • getI

        public abstract T getI()
        Get the inclination.

        If the orbit was created without derivatives, the value returned is null.

        Returns:
        inclination (rad)

      • getIDot

        public abstract T getIDot()
        Get the inclination derivative.
        Returns:
        inclination derivative (rad/s)

      • getMu

        public T getMu()
        Get the central attraction coefficient used for position and velocity conversions (m³/s²).
        Returns:
        central attraction coefficient used for position and velocity conversions (m³/s²)

      • getKeplerianPeriod

        public T getKeplerianPeriod()
        Get the Keplerian period.

        The Keplerian period is computed directly from semi major axis and central acceleration constant.

        Returns:
        Keplerian period in seconds, or positive infinity for hyperbolic orbits

      • getKeplerianMeanMotion

        public T getKeplerianMeanMotion()
        Get the Keplerian mean motion.

        The Keplerian mean motion is computed directly from semi major axis and central acceleration constant.

        Returns:
        Keplerian mean motion in radians per second

      • getMeanAnomalyDotWrtA

        public T getMeanAnomalyDotWrtA()
        Get the derivative of the mean anomaly with respect to the semi major axis.
        Returns:
        derivative of the mean anomaly with respect to the semi major axis

      • getPosition

        public FieldVector3D<T> getPosition​(Frame outputFrame)
        Get the position in a specified frame.
        Parameters:
        outputFrame - frame in which the position coordinates shall be computed
        Returns:
        position in the specified output frame
        Since:
        12.0
        See Also:
        getPosition()

      • getPosition

        public FieldVector3D<T> getPosition()
        Get the position in definition frame.
        Returns:
        position in the definition frame
        Since:
        12.0
        See Also:
        getPVCoordinates()

      • getOne

        protected T getOne()
        Getter for Field-valued one.
        Returns:
        one

      • getZero

        protected T getZero()
        Getter for Field-valued zero.
        Returns:
        zero

      • getField

        protected Field<T> getField()
        Getter for Field.
        Returns:
        CalculusField

      • initPosition

        protected abstract FieldVector3D<T> initPosition()
        Compute the position coordinates from the canonical parameters.
        Returns:
        computed position coordinates
        Since:
        12.0

      • initPVCoordinates

        protected abstract TimeStampedFieldPVCoordinates<T> initPVCoordinates()
        Compute the position/velocity coordinates from the canonical parameters.
        Returns:
        computed position/velocity coordinates

      • withFrame

        public abstract FieldOrbit<T> withFrame​(Frame inertialFrame)
        Create a new object representing the same physical orbital state, but attached to a different reference frame. If the new frame is not inertial, an exception will be thrown.
        Parameters:
        inertialFrame - reference frame of output orbit
        Returns:
        orbit with different frame
        Since:
        13.0

      • shiftedBy

        public abstract FieldOrbit<T> shiftedBy​(T dt)
        Get a time-shifted orbit.

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

        Specified by:
        shiftedBy in interface FieldTimeShiftable<FieldOrbit<T extends CalculusFieldElement<T>>,​T extends CalculusFieldElement<T>>
        Parameters:
        dt - time shift in seconds
        Returns:
        a new orbit, shifted with respect to the instance (which is immutable)

      • getJacobianWrtCartesian

        public void getJacobianWrtCartesian​(PositionAngleType type,
                                    T[][] jacobian)
        Compute the Jacobian of the orbital parameters with respect to the Cartesian parameters.

        Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row corresponds to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.

        Parameters:
        type - type of the position angle to use
        jacobian - placeholder 6x6 (or larger) matrix to be filled with the Jacobian, if matrix is larger than 6x6, only the 6x6 upper left corner will be modified

      • getJacobianWrtParameters

        public void getJacobianWrtParameters​(PositionAngleType type,
                                     T[][] jacobian)
        Compute the Jacobian of the Cartesian parameters with respect to the orbital parameters.

        Element jacobian[i][j] is the derivative of Cartesian coordinate i of the orbit with respect to orbital parameter j. This means each row corresponds to one Cartesian coordinate x, y, z, xdot, ydot, zdot whereas columns 0 to 5 correspond to the orbital parameters.

        Parameters:
        type - type of the position angle to use
        jacobian - placeholder 6x6 (or larger) matrix to be filled with the Jacobian, if matrix is larger than 6x6, only the 6x6 upper left corner will be modified

      • computeJacobianMeanWrtCartesian

        protected abstract T[][] computeJacobianMeanWrtCartesian()
        Compute the Jacobian of the orbital parameters with mean angle with respect to the Cartesian parameters.

        Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.

        Returns:
        6x6 Jacobian matrix
        See Also:
        computeJacobianEccentricWrtCartesian(), computeJacobianTrueWrtCartesian()

      • computeJacobianEccentricWrtCartesian

        protected abstract T[][] computeJacobianEccentricWrtCartesian()
        Compute the Jacobian of the orbital parameters with eccentric angle with respect to the Cartesian parameters.

        Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.

        Returns:
        6x6 Jacobian matrix
        See Also:
        computeJacobianMeanWrtCartesian(), computeJacobianTrueWrtCartesian()

      • computeJacobianTrueWrtCartesian

        protected abstract T[][] computeJacobianTrueWrtCartesian()
        Compute the Jacobian of the orbital parameters with true angle with respect to the Cartesian parameters.

        Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.

        Returns:
        6x6 Jacobian matrix
        See Also:
        computeJacobianMeanWrtCartesian(), computeJacobianEccentricWrtCartesian()

      • addKeplerContribution

        public abstract void addKeplerContribution​(PositionAngleType type,
                                           T gm,
                                           T[] pDot)
        Add the contribution of the Keplerian motion to parameters derivatives

        This method is used by integration-based propagators to evaluate the part of Keplerian motion to evolution of the orbital state.

        Parameters:
        type - type of the position angle in the state
        gm - attraction coefficient to use
        pDot - array containing orbital state derivatives to update (the Keplerian part must be added to the array components, as the array may already contain some non-zero elements corresponding to non-Keplerian parts)

      • fillHalfRow

        protected void fillHalfRow​(T a,
                           FieldVector3D<T> v,
                           T[] row,
                           int j)
        Fill a Jacobian half row with a single vector.
        Parameters:
        a - coefficient of the vector
        v - vector
        row - Jacobian matrix row
        j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)

      • fillHalfRow

        protected void fillHalfRow​(T a1,
                           FieldVector3D<T> v1,
                           T a2,
                           FieldVector3D<T> v2,
                           T[] row,
                           int j)
        Fill a Jacobian half row with a linear combination of vectors.
        Parameters:
        a1 - coefficient of the first vector
        v1 - first vector
        a2 - coefficient of the second vector
        v2 - second vector
        row - Jacobian matrix row
        j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)

      • fillHalfRow

        protected void fillHalfRow​(T a1,
                           FieldVector3D<T> v1,
                           T a2,
                           FieldVector3D<T> v2,
                           T a3,
                           FieldVector3D<T> v3,
                           T[] row,
                           int j)
        Fill a Jacobian half row with a linear combination of vectors.
        Parameters:
        a1 - coefficient of the first vector
        v1 - first vector
        a2 - coefficient of the second vector
        v2 - second vector
        a3 - coefficient of the third vector
        v3 - third vector
        row - Jacobian matrix row
        j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)

      • fillHalfRow

        protected void fillHalfRow​(T a1,
                           FieldVector3D<T> v1,
                           T a2,
                           FieldVector3D<T> v2,
                           T a3,
                           FieldVector3D<T> v3,
                           T a4,
                           FieldVector3D<T> v4,
                           T[] row,
                           int j)
        Fill a Jacobian half row with a linear combination of vectors.
        Parameters:
        a1 - coefficient of the first vector
        v1 - first vector
        a2 - coefficient of the second vector
        v2 - second vector
        a3 - coefficient of the third vector
        v3 - third vector
        a4 - coefficient of the fourth vector
        v4 - fourth vector
        row - Jacobian matrix row
        j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)

      • fillHalfRow

        protected void fillHalfRow​(T a1,
                           FieldVector3D<T> v1,
                           T a2,
                           FieldVector3D<T> v2,
                           T a3,
                           FieldVector3D<T> v3,
                           T a4,
                           FieldVector3D<T> v4,
                           T a5,
                           FieldVector3D<T> v5,
                           T[] row,
                           int j)
        Fill a Jacobian half row with a linear combination of vectors.
        Parameters:
        a1 - coefficient of the first vector
        v1 - first vector
        a2 - coefficient of the second vector
        v2 - second vector
        a3 - coefficient of the third vector
        v3 - third vector
        a4 - coefficient of the fourth vector
        v4 - fourth vector
        a5 - coefficient of the fifth vector
        v5 - fifth vector
        row - Jacobian matrix row
        j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)

      • fillHalfRow

        protected void fillHalfRow​(T a1,
                           FieldVector3D<T> v1,
                           T a2,
                           FieldVector3D<T> v2,
                           T a3,
                           FieldVector3D<T> v3,
                           T a4,
                           FieldVector3D<T> v4,
                           T a5,
                           FieldVector3D<T> v5,
                           T a6,
                           FieldVector3D<T> v6,
                           T[] row,
                           int j)
        Fill a Jacobian half row with a linear combination of vectors.
        Parameters:
        a1 - coefficient of the first vector
        v1 - first vector
        a2 - coefficient of the second vector
        v2 - second vector
        a3 - coefficient of the third vector
        v3 - third vector
        a4 - coefficient of the fourth vector
        v4 - fourth vector
        a5 - coefficient of the fifth vector
        v5 - fifth vector
        a6 - coefficient of the sixth vector
        v6 - sixth vector
        row - Jacobian matrix row
        j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)