Package org.orekit.orbits

Enum OrbitType

    • Method Detail

      • values

        public static OrbitType[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows: 
        for (OrbitType c : OrbitType.values())
    System.out.println(c);
        Returns:
        an array containing the constants of this enum type, in the order they are declared

      • valueOf

        public static OrbitType valueOf​(String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        Parameters:
        name - the name of the enum constant to be returned.
        Returns:
        the enum constant with the specified name
        Throws:
        IllegalArgumentException - if this enum type has no constant with the specified name
        NullPointerException - if the argument is null

      • convertType

        public abstract Orbit convertType​(Orbit orbit)
        Convert an orbit to the instance type.

        The returned orbit is the specified instance itself if its type already matches, otherwise, a new orbit of the proper type created

        Parameters:
        orbit - orbit to convert
        Returns:
        converted orbit with type guaranteed to match (so it can be cast safely)

      • mapOrbitToArray

        public abstract void mapOrbitToArray​(Orbit orbit,
                                     PositionAngleType type,
                                     double[] stateVector,
                                     double[] stateVectorDot)
        Convert orbit to state array.

        Note that all implementations of this method must be consistent with the implementation of the Orbit.getJacobianWrtCartesian method for the corresponding orbit type in terms of parameters order and meaning.

        Parameters:
        orbit - orbit to map
        type - type of the angle
        stateVector - flat array into which the state vector should be mapped (it can have more than 6 elements, extra elements are untouched)
        stateVectorDot - flat array into which the state vector derivative should be mapped (it can be null if derivatives are not desired, and it can have more than 6 elements, extra elements are untouched)

      • mapArrayToOrbit

        public abstract Orbit mapArrayToOrbit​(double[] array,
                                      double[] arrayDot,
                                      PositionAngleType type,
                                      AbsoluteDate date,
                                      double mu,
                                      Frame frame)
        Convert state array to orbital parameters.

        Note that all implementations of this method must be consistent with the implementation of the Orbit.getJacobianWrtCartesian method for the corresponding orbit type in terms of parameters order and meaning.

        Parameters:
        array - state as a flat array (it can have more than 6 elements, extra elements are ignored)
        arrayDot - state derivative as a flat array (it can be null, in which case Keplerian motion is assumed, and it can have more than 6 elements, extra elements are ignored)
        type - type of the angle
        date - integration date
        mu - central attraction coefficient used for propagation (m³/s²)
        frame - frame in which integration is performed
        Returns:
        orbit corresponding to the flat array as a space dynamics object

      • convertType

        public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertType​(FieldOrbit<T> orbit)
        Convert an orbit to the instance type.

        The returned orbit is the specified instance itself if its type already matches, otherwise, a new orbit of the proper type created

        Type Parameters:
        T - CalculusFieldElement used
        Parameters:
        orbit - orbit to convert
        Returns:
        converted orbit with type guaranteed to match (so it can be cast safely)

      • mapOrbitToArray

        public abstract <T extends CalculusFieldElement<T>> void mapOrbitToArray​(FieldOrbit<T> orbit,
                                                                         PositionAngleType type,
                                                                         T[] stateVector,
                                                                         T[] stateVectorDot)
        Convert orbit to state array.

        Note that all implementations of this method must be consistent with the implementation of the Orbit.getJacobianWrtCartesian method for the corresponding orbit type in terms of parameters order and meaning.

        Type Parameters:
        T - CalculusFieldElement used
        Parameters:
        orbit - orbit to map
        type - type of the angle
        stateVector - flat array into which the state vector should be mapped (it can have more than 6 elements, extra elements are untouched)
        stateVectorDot - flat array into which the state vector derivative should be mapped (it can be null if derivatives are not desired, and it can have more than 6 elements, extra elements are untouched)

      • mapArrayToOrbit

        public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> mapArrayToOrbit​(T[] array,
                                                                                  T[] arrayDot,
                                                                                  PositionAngleType type,
                                                                                  FieldAbsoluteDate<T> date,
                                                                                  T mu,
                                                                                  Frame frame)
        Convert state array to orbital parameters.

        Note that all implementations of this method must be consistent with the implementation of the Orbit.getJacobianWrtCartesian method for the corresponding orbit type in terms of parameters order and meaning.

        Type Parameters:
        T - CalculusFieldElement used
        Parameters:
        array - state as a flat array (it can have more than 6 elements, extra elements are ignored)
        arrayDot - state derivative as a flat array (it can be null, in which case Keplerian motion is assumed,
        type - type of the angle
        date - integration date
        mu - central attraction coefficient used for propagation (m³/s²)
        frame - frame in which integration is performed
        Returns:
        orbit corresponding to the flat array as a space dynamics object

      • convertToFieldOrbit

        public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertToFieldOrbit​(Field<T> field,
                                                                                      Orbit orbit)
        Convert an orbit to the "Fielded" instance type.
        Type Parameters:
        T - CalculusFieldElement used
        Parameters:
        field - CalculusField
        orbit - base orbit
        Returns:
        converted FieldOrbit with type guaranteed to match (so it can be cast safely)
        Since:
        12.0

      • getDrivers

        public abstract ParameterDriversList getDrivers​(double dP,
                                                Orbit orbit,
                                                PositionAngleType type)
        Get parameters drivers initialized from a reference orbit.
        Parameters:
        dP - user specified position error
        orbit - reference orbit
        type - type of the angle
        Returns:
        parameters drivers initialized from reference orbit

      • normalize

        public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> normalize​(FieldOrbit<T> orbit,
                                                                            FieldOrbit<T> reference)
        Normalize one orbit with respect to a reference one.

        Given a, angular component ζ of an orbit and the corresponding angular component ζᵣ in the reference orbit, the angular component ζₙ of the normalized orbit will be ζₙ = ζ + 2kπ where k is chosen such that ζᵣ - π ≤ ζₙ ≤ ζᵣ + π. This is intended to avoid too large discontinuities and is particularly useful for normalizing the orbit after an impulsive maneuver with respect to the reference picked up before the maneuver.

        Type Parameters:
        T - CalculusFieldElement used
        Parameters:
        orbit - orbit to normalize
        reference - reference orbit
        Returns:
        normalized orbit (the type is guaranteed to match OrbitType)
        Since:
        11.1

      • normalize

        public abstract Orbit normalize​(Orbit orbit,
                                Orbit reference)
        Normalize one orbit with respect to a reference one.

        Given a, angular component ζ of an orbit and the corresponding angular component ζᵣ in the reference orbit, the angular component ζₙ of the normalized orbit will be ζₙ = ζ + 2kπ where k is chosen such that ζᵣ - π ≤ ζₙ ≤ ζᵣ + π. This is intended to avoid too large discontinuities and is particularly useful for normalizing the orbit after an impulsive maneuver with respect to the reference picked up before the maneuver.

        Parameters:
        orbit - orbit to normalize
        reference - reference orbit
        Returns:
        normalized orbit (the type is guaranteed to match OrbitType)
        Since:
        11.1

      • isPositionAngleBased

        public abstract boolean isPositionAngleBased()
        Tells if the orbit type is based on position angles or not.
        Returns:
        true if based on PositionAngleType
        Since:
        12.0

      • scale

        protected double[] scale​(double dP,
                         Orbit orbit)
        Compute scaling factor for parameters drivers.

        The scales are estimated from partial derivatives properties of orbits, starting from a scalar position error specified by the user. Considering the energy conservation equation V = sqrt(mu (2/r - 1/a)), we get at constant energy (i.e. on a Keplerian trajectory): 

         V r² |dV| = mu |dr|

        So we deduce a scalar velocity error consistent with the position error. From here, we apply orbits Jacobians matrices to get consistent scales on orbital parameters.

        Parameters:
        dP - user specified position error
        orbit - reference orbit
        Returns:
        scaling factor array