Package org.orekit.orbits

Enum Class OrbitParamsType

java.lang.Object
java.lang.Enum<OrbitParamsType>
org.orekit.orbits.OrbitParamsType
All Implemented Interfaces:
Serializable, Comparable<OrbitParamsType>, Constable
public enum OrbitParamsType extends Enum<OrbitParamsType>
Enumerate for Orbit and FieldOrbit parameters types. They are full physical coordinates (six-dimensional) in the two-body (possibly perturbed) problem.

  • Enum Constant Details

  • Field Details

  • Method Details

    • values

      public static OrbitParamsType[] values()
      Returns an array containing the constants of this enum class, in the order they are declared.
      Returns:
      an array containing the constants of this enum class, in the order they are declared

    • valueOf

      public static OrbitParamsType valueOf(String name)
      Returns the enum constant of this class with the specified name. The string must match exactly an identifier used to declare an enum constant in this class. (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 class 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 OrbitParamsType)
      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 OrbitParamsType)
      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