fr.cnes.sirius.patrius.progmission

Class InterplanetaryUtils

java.lang.Object

fr.cnes.sirius.patrius.progmission.InterplanetaryUtils

public final class InterplanetaryUtils
extends Object

Utility class describing interplanetary features imported from CelestLab.

Since:

4.17

Author:

vermeulenp, guillemettem

Method Summary

Modifier and Type	Method and Description
static List<double[]>	computeEscapeDV(double[] sma, double[] ecc, double[] vinf) Compute the instantaneous DV needed at the perigee to reach each targeted hyperbolic orbit given the associated elliptic orbit around the Earth.
static List<double[]>	computeEscapeDV(double[] sma, double[] ecc, double[] vinf, double[] trueAnomaly, double mu) Compute the instantaneous DV needed to reach each targeted hyperbolic orbit given the associated elliptic orbit.
static double[]	computeEscapeDV(double sma, double ecc, double vinf) Compute the instantaneous DV needed at the perigee to reach the targeted hyperbolic orbit from the current elliptic orbit around the Earth.
static double[]	computeEscapeDV(double sma, double ecc, double vinf, double trueAnomaly, double mu) Compute the instantaneous DV needed to reach the targeted hyperbolic orbit from the current elliptic orbit.
static List<Pair<Orbit,Double>>	computeEscapeDV(List<Orbit> orbitList, double[] vinf) Compute the instantaneous DV needed to reach each targeted hyperbolic orbit given the associated elliptic orbit that is provided.
static Pair<Orbit,Double>	computeEscapeDV(Orbit orbit, double vinf) Compute the instantaneous DV needed to reach the targeted hyperbolic orbit given the provided elliptic orbit.
static List<double[]>	computeInsertionDV(double[] vinf, double[] rph, double[] sma) Compute the instantaneous DV needed at the perigee to reach each targeted elliptic orbit given the associated hyperbolic orbit around the Earth.
static List<double[]>	computeInsertionDV(double[] vinf, double[] rph, double[] sma, double[] trueAnomaly, double mu) Compute the instantaneous DV needed to reach each targeted elliptic orbit given the associated hyperbolic orbit.
static double[]	computeInsertionDV(double vinf, double rph, double sma) Compute the instantaneous DV needed at the perigee to reach the targeted elliptic orbit from the current hyperbolic orbit around the Earth.
static double[]	computeInsertionDV(double vinf, double rph, double sma, double trueAnomaly, double mu) Compute the instantaneous DV needed to reach the targeted elliptic orbit from the current hyperbolic orbit.
static List<Pair<Orbit,Double>>	computeInsertionDV(List<Orbit> orbitList, double[] sma) Compute the instantaneous DV needed to reach each targeted elliptic orbit given the associated hyperbolic orbit that is provided.
static Pair<Orbit,Double>	computeInsertionDV(Orbit orbit, double sma) Compute the instantaneous DV needed to reach the targeted elliptic orbit given the provided hyperbolic orbit.
static double	computeSphereInfluenceRadius(CelestialBody body1, CelestialBody body2, AbsoluteDate date) Compute the sphere of influence (SOI) radius around the lightest body for the provided body couple at the given date.
static double[]	computeSphereInfluenceRadius(double[] mu1, double[] mu2, double[] distance) Compute the sphere of influence (SOI) radius around the lightest body (smallest mu) given the provided mu couples and distances.
static double	computeSphereInfluenceRadius(double mu1, double mu2, double distance) Compute the sphere of influence (SOI) radius around the lightest body (smallest mu) given the provided mu values and distance.
static double[]	computeSphereInfluenceRadius(List<CelestialBody> bodiesList1, List<CelestialBody> bodiesList2, List<AbsoluteDate> dates) Compute the sphere of influence (SOI) radius around the lightest body for each body couple at a given date.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

computeSphereInfluenceRadius

public static double computeSphereInfluenceRadius(double mu1,
                                                  double mu2,
                                                  double distance)
                                           throws PatriusException

Compute the sphere of influence (SOI) radius around the lightest body (smallest mu) given the provided mu values and distance.

Inspired by the Celestlab method CL_ip_sphereInfluence.

Parameters:

mu1 - Gravitational parameter for the first body (m^3/s^2)

mu2 - Gravitational parameter for the second body (m^3/s^2)

distance - Distance between the two bodies (m)

Returns:

the computed SOI radius

Throws:

PatriusException - if one of the gravitational parameters is not strictly positive

computeSphereInfluenceRadius

public static double[] computeSphereInfluenceRadius(double[] mu1,
                                                    double[] mu2,
                                                    double[] distance)
                                             throws PatriusException

Compute the sphere of influence (SOI) radius around the lightest body (smallest mu) given the provided mu couples and distances.

Inspired by the Celestlab method CL_ip_sphereInfluence.

Parameters:

mu1 - Array of gravitational parameter for the first body of the couple (m^3/s^2)

mu2 - Array of gravitational parameter for the second body of the couple (m^3/s^2)

distance - Array of distances between the two bodies of the couple (m)

Returns:

the array containing the SOI radius for each couple

Throws:

PatriusException - if the lists size don't match

computeSphereInfluenceRadius

public static double computeSphereInfluenceRadius(CelestialBody body1,
                                                  CelestialBody body2,
                                                  AbsoluteDate date)
                                           throws PatriusException

Compute the sphere of influence (SOI) radius around the lightest body for the provided body couple at the given date.
The lightest body is determined by comparing the gravitational parameter of the two bodies.

Inspired by the Celestlab method CL_ip_sphereInfluence.

Parameters:

body1 - Celestial body (first part of the couple)

body2 - Celestial body (second part of the couple)

date - Date at which we want to compute the SOI radius

Returns:

the computed SOI radius

Throws:

PatriusException - if one of the gravitational parameters is not strictly positive

computeSphereInfluenceRadius

public static double[] computeSphereInfluenceRadius(List<CelestialBody> bodiesList1,
                                                    List<CelestialBody> bodiesList2,
                                                    List<AbsoluteDate> dates)
                                             throws PatriusException

Compute the sphere of influence (SOI) radius around the lightest body for each body couple at a given date.
A body couple is formed by an entry in bodiesList1 and bodiesList2 and the lightest body is determined by comparing the gravitational parameter of the two bodies.

Inspired by the Celestlab method CL_ip_sphereInfluence.

Parameters:

bodiesList1 - List of celestial bodies (first part of the couple)

bodiesList2 - List of celestial bodies (second part of the couple)

dates - List of dates at which we want to compute the SOI radius

Returns:

the array containing the SOI radius for each couple at the given date

Throws:

PatriusException - if the lists size don't match

computeEscapeDV

public static double[] computeEscapeDV(double sma,
                                       double ecc,
                                       double vinf)
                                throws PatriusException

Compute the instantaneous DV needed at the perigee to reach the targeted hyperbolic orbit from the current elliptic orbit around the Earth.
By default, this method defined the true anomaly on the elliptic orbit as 0rad and the gravitational parameter of the central first body as Constants.EGM96_EARTH_MU m^3/s^2.

Inspired by the Celestlab method CL_ip_escapeDv.

Parameters:

sma - Semi-major axis of the initial elliptic orbit (m)

ecc - Eccentricity of the initial elliptic orbit

vinf - Target hyperbolic excess velocity (m/s)

Returns:

the array { dv, rpHyp, trueAnomalyHyp } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• rpHyp being the radius of the periapsis of the target orbit (m)
• trueAnomalyHyp being the true anomaly on the hyperbolic orbit after the maneuver (rad)

Throws:

PatriusException - if sma or vinf are negative or the eccentricity doesn't correspond to an elliptic orbit

computeEscapeDV

public static double[] computeEscapeDV(double sma,
                                       double ecc,
                                       double vinf,
                                       double trueAnomaly,
                                       double mu)
                                throws PatriusException

Compute the instantaneous DV needed to reach the targeted hyperbolic orbit from the current elliptic orbit.

Inspired by the Celestlab method CL_ip_escapeDv.

Parameters:

sma - Semi-major axis of the initial elliptic orbit (m)

ecc - Eccentricity of the initial elliptic orbit

vinf - Target hyperbolic excess velocity (m/s)

trueAnomaly - True anomaly on the elliptic orbit (rad)

mu - Gravitational parameter of the central first body (m^3/s^2)

Returns:

the array { dv, rpHyp, trueAnomalyHyp } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• rpHyp being the radius of the periapsis of the target orbit (m)
• trueAnomalyHyp being the true anomaly on the hyperbolic orbit after the maneuver (rad)

Throws:

PatriusException - if sma, vinf or mu are negative or the eccentricity doesn't correspond to an elliptic orbit

computeEscapeDV

public static List<double[]> computeEscapeDV(double[] sma,
                                             double[] ecc,
                                             double[] vinf)
                                      throws PatriusException

Compute the instantaneous DV needed at the perigee to reach each targeted hyperbolic orbit given the associated elliptic orbit around the Earth.
By default, this method defined the true anomaly on the elliptic orbit as 0rad and the gravitational parameter of the central first body as Constants.EGM96_EARTH_MU m^3/s^2.

Inspired by the Celestlab method CL_ip_escapeDv.

Parameters:

sma - Array of semi-major axis value for each initial elliptic orbit (m)

ecc - Array of eccentricity for each initial elliptic orbit

vinf - Array of targeted hyperbolic excess velocity (m/s).
Can contain only one element in which case this value is reused for each entry.

Returns:

the list of arrays { dv, rpHyp, trueAnomalyHyp } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• rpHyp being the radius of the periapsis of the target orbit (m)
• trueAnomalyHyp being the true anomaly on the hyperbolic orbit after the maneuver (rad)

Throws:

PatriusException - if all provided arrays don't have the same size (except for the case where vinf contains only 1 value)
if sma or vinf are negative or the eccentricity doesn't correspond to an elliptic orbit

computeEscapeDV

public static List<double[]> computeEscapeDV(double[] sma,
                                             double[] ecc,
                                             double[] vinf,
                                             double[] trueAnomaly,
                                             double mu)
                                      throws PatriusException

Compute the instantaneous DV needed to reach each targeted hyperbolic orbit given the associated elliptic orbit.

Inspired by the Celestlab method CL_ip_escapeDv.

Parameters:

sma - Array of semi-major axis value for each initial elliptic orbit (m)

ecc - Array of eccentricity for each initial elliptic orbit

vinf - Array of targeted hyperbolic excess velocity (m/s).
Can contain only one element in which case this value is reused for each entry.

trueAnomaly - Array of true anomaly for each initial elliptic orbit (rad)

mu - Gravitational parameter of the central first body (m^3/s^2)

Returns:

the list of arrays { dv, rpHyp, trueAnomalyHyp } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• rpHyp being the radius of the periapsis of the target orbit (m)
• trueAnomalyHyp being the true anomaly on the hyperbolic orbit after the maneuver (rad)

Throws:

PatriusException - if all provided arrays don't have the same size (except for the case where vinf contains only 1 value)
if sma, vinf or mu are negative or the eccentricity doesn't correspond to an elliptic orbit

computeEscapeDV

public static Pair<Orbit,Double> computeEscapeDV(Orbit orbit,
                                                 double vinf)
                                          throws PatriusException

Compute the instantaneous DV needed to reach the targeted hyperbolic orbit given the provided elliptic orbit.

Inspired by the Celestlab method CL_ip_escapeDv.

Parameters:

orbit - Initial elliptic orbit

vinf - Targeted hyperbolic excess velocity (m/s)

Returns:

the pair { orbit, dv } with:

• orbit being the resulting hyperbolic orbit after applying the instantaneous DV
• dv being the instantaneous DV needed to reach the target orbit (m/s)

Throws:

PatriusException - if sma, vinf or mu are negative or the eccentricity doesn't correspond to an elliptic orbit

computeEscapeDV

public static List<Pair<Orbit,Double>> computeEscapeDV(List<Orbit> orbitList,
                                                       double[] vinf)
                                                throws PatriusException

Compute the instantaneous DV needed to reach each targeted hyperbolic orbit given the associated elliptic orbit that is provided.

Inspired by the Celestlab method CL_ip_escapeDv.

Parameters:

orbitList - List of Orbit representing the initial elliptic orbits

vinf - Array of targeted hyperbolic excess velocity (m/s).
Can contain only one element in which case this value is reused for each entry.

Returns:

the list of pairs { orbit, dv } with:

• orbit being the resulting hyperbolic orbit after applying the instantaneous DV
• dv being the instantaneous DV needed to reach the target orbit (m/s)

Throws:

PatriusException - if all provided arrays don't have the same size (except for the case where vinf contains only 1 value)
if sma, vinf or mu are negative or the eccentricity doesn't correspond to an elliptic orbit

computeInsertionDV

public static double[] computeInsertionDV(double vinf,
                                          double rph,
                                          double sma)
                                   throws PatriusException

Compute the instantaneous DV needed at the perigee to reach the targeted elliptic orbit from the current hyperbolic orbit around the Earth.
By default, this method defined the true anomaly on the hyperbolic orbit as 0rad and the gravitational parameter of the central first body as Constants.EGM96_EARTH_MU m^3/s^2.

Inspired by the Celestlab method CL_ip_insertionDv.

Parameters:

vinf - Hyperbolic excess velocity of the initial orbit (m/s)

rph - Radius of the periapsis of the target orbit (m)

sma - Semi-major axis of the targeted elliptic orbit (m)

Returns:

the array { dv, ecc, trueAnomalyEll } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• ecc being the eccentricity of the target orbit
• trueAnomalyEll being the true anomaly on the elliptic orbit after the maneuver (rad)

Throws:

PatriusException - if vinf, rph or sma are negative

computeInsertionDV

public static double[] computeInsertionDV(double vinf,
                                          double rph,
                                          double sma,
                                          double trueAnomaly,
                                          double mu)
                                   throws PatriusException

Compute the instantaneous DV needed to reach the targeted elliptic orbit from the current hyperbolic orbit.

Inspired by the Celestlab method CL_ip_insertionDv.

Parameters:

vinf - Hyperbolic excess velocity of the initial orbit (m/s)

rph - Radius of the periapsis of the target orbit (m)

sma - Semi-major axis of the targeted elliptic orbit (m)

trueAnomaly - True anomaly on the hyperbolic orbit (rad)

mu - Gravitational parameter of the central first body (m^3/s^2)

Returns:

the array { dv, ecc, trueAnomalyEll } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• ecc being the eccentricity of the target orbit
• trueAnomalyEll being the true anomaly on the elliptic orbit after the maneuver (rad)

Throws:

PatriusException - if vinf, rph, sma or mu are negative

computeInsertionDV

public static List<double[]> computeInsertionDV(double[] vinf,
                                                double[] rph,
                                                double[] sma)
                                         throws PatriusException

Compute the instantaneous DV needed at the perigee to reach each targeted elliptic orbit given the associated hyperbolic orbit around the Earth.
By default, this method defined the true anomaly on the initial hyperbolic orbit as 0rad and the gravitational parameter of the central first body as Constants.EGM96_EARTH_MU m^3/s^2.

Inspired by the Celestlab method CL_ip_insertionDv.

Parameters:

vinf - Array of hyperbolic excess velocity for each initial orbit (m/s)

rph - Array containing the radius of the periapsis value of each initial orbit (m)

sma - Array of semi-major axis of the targeted elliptic orbit (m).
Can contain only one element in which case this value is reused for each entry.

Returns:

the array { dv, ecc, trueAnomalyEll } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• ecc being the eccentricity of the target orbit
• trueAnomalyEll being the true anomaly on the elliptic orbit after the maneuver (rad)

Throws:

PatriusException - if all provided arrays don't have the same size (except for the case where sma contains only 1 value)
if vinf, rph or sma are negative

computeInsertionDV

public static List<double[]> computeInsertionDV(double[] vinf,
                                                double[] rph,
                                                double[] sma,
                                                double[] trueAnomaly,
                                                double mu)
                                         throws PatriusException

Compute the instantaneous DV needed to reach each targeted elliptic orbit given the associated hyperbolic orbit.

Inspired by the Celestlab method CL_ip_insertionDv.

Parameters:

vinf - Array of hyperbolic excess velocity for each initial orbit (m/s)

rph - Array containing the radius of the periapsis value of each initial orbit (m)

sma - Array of semi-major axis of the targeted elliptic orbit (m).
Can contain only one element in which case this value is reused for each entry.

trueAnomaly - Array of true anomaly for each initial hyperbolic orbit (rad)

mu - Gravitational parameter of the central first body (m^3/s^2)

Returns:

the array { dv, ecc, trueAnomalyEll } with:

• dv being the instantaneous DV needed to reach the target orbit (m/s)
• ecc being the eccentricity of the target orbit
• trueAnomalyEll being the true anomaly on the elliptic orbit after the maneuver (rad)

Throws:

PatriusException - if all provided arrays don't have the same size (except for the case where sma contains only 1 value)
if vinf, rph, sma or mu are negative

computeInsertionDV

public static Pair<Orbit,Double> computeInsertionDV(Orbit orbit,
                                                    double sma)
                                             throws PatriusException

Compute the instantaneous DV needed to reach the targeted elliptic orbit given the provided hyperbolic orbit.

Inspired by the Celestlab method CL_ip_insertionDv.

Parameters:

orbit - Initial hyperbolic orbit

sma - Semi-major axis of the targeted elliptic orbit (m)

Returns:

the pair { orbit, dv } with:

• orbit being the resulting elliptic orbit after applying the instantaneous DV
• dv being the instantaneous DV needed to reach the target orbit (m/s)

Throws:

PatriusException - if the initial orbit isn't hyperbolic (hence, it describes a positive semi-major axis)
if the targeted elliptic orbit describes a negative semi-major axis

computeInsertionDV

public static List<Pair<Orbit,Double>> computeInsertionDV(List<Orbit> orbitList,
                                                          double[] sma)
                                                   throws PatriusException

Compute the instantaneous DV needed to reach each targeted elliptic orbit given the associated hyperbolic orbit that is provided.

Inspired by the Celestlab method CL_ip_insertionDv.

Parameters:

orbitList - List of Orbit representing the initial hyperbolic orbits

sma - Array of semi-major axis of the targeted elliptic orbit (m).
Can contain only one element in which case this value is reused for each entry.

Returns:

the pair { orbit, dv } with:

• orbit being the resulting hyperbolic orbit after applying the instantaneous DV
• dv being the instantaneous DV needed to reach the target orbit (m/s)

Throws:

PatriusException - if all provided arrays don't have the same size (except for the case where sma contains only 1 value)
if one of the initial orbits isn't hyperbolic (hence, it describes a positive semi-major axis)
if one of the targeted elliptic orbits describes a negative semi-major axis