fr.cnes.sirius.patrius.progmission

Class EventUtils

java.lang.Object

fr.cnes.sirius.patrius.progmission.EventUtils

public final class EventUtils
extends Object

Utility class describing event features imported from CelestLab.

Since:

4.17

Author:

vermeulenp, guillemettem

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	EventUtils.GMEclipseResults Container class for the results of the computeGMEclipse methods.
static class	EventUtils.VisiParamType Enumerate containing the existing visibility parameter types that can be provided for conversion

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_INTERPOL_ORDER Default interpolation order for the Lagrange interpolator to be used in computeEclipse.
static double	DEFAULT_LIGHTING_RATIO Default lighting ratio: 0 when total eclipse events should be detected, 1 for penumbra events.
static double	DEFAULT_MIN_INTERVAL_DURATION Default interval length limit for eclipse checking to be used in computeEclipse (s).
static double	DEFAULT_THRESHOLD Default convergence threshold to be used in computeEclipse (s).

Method Summary

Modifier and Type	Method and Description
static double[][]	computeAllStaVisParam(double[] satRadius, double[] targetRadius, EventUtils.VisiParamType typeIn, double[] paramIn) Compute all visibility parameters array for each of the provided entries.
static double[]	computeAllStaVisParam(double satRadius, double targetRadius, EventUtils.VisiParamType typeIn, double paramIn) Compute all visibility parameters based on the provided visibility parameter.
static List<AbsoluteDateInterval>	computeEclipse(AbsoluteDate[] dates, List<Vector3D> posObserver, List<Vector3D> posOccultedBody, List<Vector3D> posOccultingBody) Compute the date intervals where an observer is in a total eclipse zone of the Sun by the Earth.
static List<AbsoluteDateInterval>	computeEclipse(AbsoluteDate[] dates, List<Vector3D> posObserver, List<Vector3D> posOccultedBody, List<Vector3D> posOccultingBody, double occultedBodyRadius, double occultingBodyRadius, double lightingRatio, AbsoluteDateInterval evaluationInterval) Compute the date intervals where an observer is in a shadow zone for a given occulted body (ex: Sun) and a given occulting body (ex:Earth).
static List<AbsoluteDateInterval>	computeEclipse(AbsoluteDate[] dates, List<Vector3D> posObserver, List<Vector3D> posOccultedBody, List<Vector3D> posOccultingBody, double occultedBodyRadius, double occultingBodyRadius, double lightingRatio, AbsoluteDateInterval evaluationInterval, double threshold, double minIntervalDuration, int interpolOrder) Compute the date intervals where an observer is in a shadow zone for a given occulted body (ex: Sun) and a given occulting body (ex: Earth).
static EventUtils.GMEclipseResults	computeGMEclipse(double sma, double ecc, double inc, double argp, double raan, double alphaSun, double deltaSun) Computes the eclipsed portion of the provided orbit around the Earth for a given Sun direction.
static EventUtils.GMEclipseResults	computeGMEclipse(double sma, double ecc, double inc, double argp, double raan, double alphaSun, double deltaSun, double earthRadius, double mu) Computes the eclipsed portion of the provided orbit around the Earth for a given Sun direction.
static Map<Integer,List<AbsoluteDateInterval>>	computeStationVisibility(AbsoluteDate[] dates, List<Vector3D> posSat, List<Vector3D> posStations, double[] elevationMin) Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.
static Map<Integer,List<AbsoluteDateInterval>>	computeStationVisibility(AbsoluteDate[] dates, List<Vector3D> posSat, List<Vector3D> posStations, double[] elevationMin, AbsoluteDateInterval evaluationInterval) Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.
static Map<Integer,List<AbsoluteDateInterval>>	computeStationVisibility(AbsoluteDate[] dates, List<Vector3D> posSat, List<Vector3D> posStations, double[] elevationMin, AbsoluteDateInterval evaluationInterval, double threshold, double minIntervalDuration, int interpolOrder) Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.
static Map<Integer,List<AbsoluteDateInterval>>	computeStationVisibility(AbsoluteDate[] dates, List<Vector3D> posSat, List<Vector3D> posStations, double[] elevationMin, AbsoluteDateInterval evaluationInterval, double threshold, double minIntervalDuration, int interpolOrder, double earthRadius, double flattening) Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.
static double[]	computeStaVisParam(double[] satRadius, double[] targetRadius, EventUtils.VisiParamType typeIn, double[] paramIn, EventUtils.VisiParamType typeOut) Compute the chosen visibility parameter array based on the provided visibility parameter array.
static double	computeStaVisParam(double satRadius, double targetRadius, EventUtils.VisiParamType typeIn, double paramIn, EventUtils.VisiParamType typeOut) Compute the chosen visibility parameter based on the provided visibility parameter.

Methods inherited from class java.lang.Object

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

Field Detail

DEFAULT_THRESHOLD

public static final double DEFAULT_THRESHOLD

Default convergence threshold to be used in computeEclipse (s).

See Also:

Constant Field Values

DEFAULT_MIN_INTERVAL_DURATION

public static final double DEFAULT_MIN_INTERVAL_DURATION

Default interval length limit for eclipse checking to be used in computeEclipse (s).

See Also:

Constant Field Values

DEFAULT_INTERPOL_ORDER

public static final int DEFAULT_INTERPOL_ORDER

Default interpolation order for the Lagrange interpolator to be used in computeEclipse.

See Also:

Constant Field Values

DEFAULT_LIGHTING_RATIO

public static final double DEFAULT_LIGHTING_RATIO

Default lighting ratio: 0 when total eclipse events should be detected, 1 for penumbra events.

See Also:

Constant Field Values

Method Detail

computeEclipse

public static List<AbsoluteDateInterval> computeEclipse(AbsoluteDate[] dates,
                                                        List<Vector3D> posObserver,
                                                        List<Vector3D> posOccultedBody,
                                                        List<Vector3D> posOccultingBody)
                                                 throws PatriusException

Compute the date intervals where an observer is in a total eclipse zone of the Sun by the Earth.
Default values are used for threshold, minIntervalDuration and interpolOrder. The evaluationInterval is the interval between the first record and the last one.

Inspired by the Celestlab method CL_ev_eclipse.

Parameters:

dates - Dates corresponding to each provided position

posObserver - Observer positions

posOccultedBody - Occulted body positions

posOccultingBody - Occulting body positions

Returns:

the computed eclipse intervals

Throws:

PatriusException - if all arrays don't have the same size

computeEclipse

public static List<AbsoluteDateInterval> computeEclipse(AbsoluteDate[] dates,
                                                        List<Vector3D> posObserver,
                                                        List<Vector3D> posOccultedBody,
                                                        List<Vector3D> posOccultingBody,
                                                        double occultedBodyRadius,
                                                        double occultingBodyRadius,
                                                        double lightingRatio,
                                                        AbsoluteDateInterval evaluationInterval)
                                                 throws PatriusException

Compute the date intervals where an observer is in a shadow zone for a given occulted body (ex: Sun) and a given occulting body (ex:Earth).
Default values are used for threshold, minIntervalDuration and interpolOrder.

Inspired by the Celestlab method CL_ev_eclipse.

Parameters:

dates - Dates corresponding to each provided position

posObserver - Observer positions

posOccultedBody - Occulted body positions

posOccultingBody - Occulting body positions

occultedBodyRadius - Occulted body radius (m)

occultingBodyRadius - Occulting body radius (m)

lightingRatio - The lighting ratio: 0 when total eclipse events should be detected, 1 for penumbra events

evaluationInterval - Interval on which we want to evaluate the eclipses

Returns:

the computed eclipse intervals

Throws:

PatriusException - if all arrays don't have the same size

computeEclipse

public static List<AbsoluteDateInterval> computeEclipse(AbsoluteDate[] dates,
                                                        List<Vector3D> posObserver,
                                                        List<Vector3D> posOccultedBody,
                                                        List<Vector3D> posOccultingBody,
                                                        double occultedBodyRadius,
                                                        double occultingBodyRadius,
                                                        double lightingRatio,
                                                        AbsoluteDateInterval evaluationInterval,
                                                        double threshold,
                                                        double minIntervalDuration,
                                                        int interpolOrder)
                                                 throws PatriusException

Compute the date intervals where an observer is in a shadow zone for a given occulted body (ex: Sun) and a given occulting body (ex: Earth).

Inspired by the Celestlab method CL_ev_eclipse.

Parameters:

dates - Dates corresponding to each provided position

posObserver - Observer positions

posOccultedBody - Occulted body positions

posOccultingBody - Occulting body positions

occultedBodyRadius - Occulted body radius (m)

occultingBodyRadius - Occulting body radius (m)

lightingRatio - The lighting ratio: 0 when total eclipse events should be detected, 1 for penumbra events

evaluationInterval - Interval on which we want to evaluate the eclipses

threshold - convergence threshold (s)

minIntervalDuration - Interval length limit for eclipse checking (s)

interpolOrder - Interpolation order for the Lagrange interpolator

Returns:

the computed eclipse intervals

Throws:

PatriusException - if all arrays don't have the same size

computeGMEclipse

public static EventUtils.GMEclipseResults computeGMEclipse(double sma,
                                                           double ecc,
                                                           double inc,
                                                           double argp,
                                                           double raan,
                                                           double alphaSun,
                                                           double deltaSun)
                                                    throws PatriusException

Computes the eclipsed portion of the provided orbit around the Earth for a given Sun direction.
The object is considered to be at the perigee of the orbit at the date t0=AbsoluteDate.J2000_EPOCH.
If the object is eclipsed at t0, the eclipse interval search is performed in [t0-T/2 ; t0+T/2]. Otherwise, it is done in [t0 ; t0 + T].
It is done this way so that one unique and complete eclipse interval is found.

The default gravitational parameter is Constants.EGM96_EARTH_EQUATORIAL_RADIUS and the default Earth radius is Constants.EGM96_EARTH_MU.

Inspired by the Celestlab method CL_gm_eclipse.

Parameters:

sma - Semi-major axis of the considered orbit (m)

ecc - Eccentricity of the considered orbit

inc - Inclination of the considered orbit (rad)

argp - Argument of perigee of the considered orbit (rad)

raan - Right ascension of ascending node of the considered orbit (rad)

alphaSun - Azimuth of the sun in the ITRF frame (rad)

deltaSun - Elevation of the sun in the ITRF frame (rad)

Returns:

an instance of EventUtils.GMEclipseResults corresponding to the computed eclipse interval

Throws:

PatriusException - on an error in Patrius configuration

computeGMEclipse

public static EventUtils.GMEclipseResults computeGMEclipse(double sma,
                                                           double ecc,
                                                           double inc,
                                                           double argp,
                                                           double raan,
                                                           double alphaSun,
                                                           double deltaSun,
                                                           double earthRadius,
                                                           double mu)
                                                    throws PatriusException

Computes the eclipsed portion of the provided orbit around the Earth for a given Sun direction.
The object is considered to be at the perigee of the orbit at the date t0=AbsoluteDate.J2000_EPOCH.
If the object is eclipsed at t0, the eclipse interval search is performed in [t0-T/2 ; t0+T/2]. Otherwise, it is done in [t0 ; t0 + T].
It is done this way so that one unique and complete eclipse interval is found.

Inspired by the Celestlab method CL_gm_eclipse.

Parameters:

sma - Semi-major axis of the considered orbit (m)

ecc - Eccentricity of the considered orbit

inc - Inclination of the considered orbit (rad)

argp - Argument of perigee of the considered orbit (rad)

raan - Right ascension of ascending node of the considered orbit (rad)

alphaSun - Azimuth of the sun in the ITRF frame (rad)

deltaSun - Elevation of the sun in the ITRF frame (rad)

earthRadius - Earth radius considered for the eclipse computation (m)

mu - Earth graviationnal parameter (m³/s²)

Returns:

an instance of EventUtils.GMEclipseResults corresponding to the computed eclipse interval

Throws:

PatriusException - on an error in Patrius configuration

computeStationVisibility

public static Map<Integer,List<AbsoluteDateInterval>> computeStationVisibility(AbsoluteDate[] dates,
                                                                               List<Vector3D> posSat,
                                                                               List<Vector3D> posStations,
                                                                               double[] elevationMin)
                                                                        throws PatriusException

Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.
Default values are used for threshold, minIntervalDuration and interpolOrder. The evaluationInterval is the interval between the first record and the last one. The default Earth radius is Constants.EGM96_EARTH_EQUATORIAL_RADIUS and flattening is Constants.WGS84_EARTH_FLATTENING

Inspired by the Celestlab method CL_ev_stationVisibility.

Parameters:

dates - Dates corresponding to each provided position

posSat - Positions of the satellite for each date

posStations - Position of each station as Vector3D {latitude, longitude, height}
The latitude and longitude are expressed in radians and height in meters. These values are in the LLHCoordinatesSystem.ELLIPSODETIC system

elevationMin - Minimum elevation needed to see the satellite per station (rad)
If the array contains only one value, it is applied to all stations

Returns:

a map with the station index as key and a list of date intervals as value

Throws:

PatriusException - if dates and posSat have different sizes or if posStations and elevationMin have different sizes (except if the length of elevationMin is 1)

computeStationVisibility

public static Map<Integer,List<AbsoluteDateInterval>> computeStationVisibility(AbsoluteDate[] dates,
                                                                               List<Vector3D> posSat,
                                                                               List<Vector3D> posStations,
                                                                               double[] elevationMin,
                                                                               AbsoluteDateInterval evaluationInterval)
                                                                        throws PatriusException

Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.
Default values are used for threshold, minIntervalDuration and interpolOrder. The default Earth radius is Constants.EGM96_EARTH_EQUATORIAL_RADIUS and flattening is Constants.WGS84_EARTH_FLATTENING

Inspired by the Celestlab method CL_ev_stationVisibility.

Parameters:

dates - Dates corresponding to each provided position

posSat - Positions of the satellite for each date

posStations - Position of each station as Vector3D {latitude, longitude, height}
The latitude and longitude are expressed in radians and height in meters. These values are in the LLHCoordinatesSystem.ELLIPSODETIC system

elevationMin - Minimum elevation needed to see the satellite per station (rad)
If the array contains only one value, it is applied to all stations

evaluationInterval - The interval on which we want to evaluate visibility of the satellite

Returns:

a map with the station index as key and a list of date intervals as value

Throws:

PatriusException - if dates and posSat have different sizes or if posStations and elevationMin have different sizes (except if the length of elevationMin is 1)

computeStationVisibility

public static Map<Integer,List<AbsoluteDateInterval>> computeStationVisibility(AbsoluteDate[] dates,
                                                                               List<Vector3D> posSat,
                                                                               List<Vector3D> posStations,
                                                                               double[] elevationMin,
                                                                               AbsoluteDateInterval evaluationInterval,
                                                                               double threshold,
                                                                               double minIntervalDuration,
                                                                               int interpolOrder)
                                                                        throws PatriusException

Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.
The default Earth radius is Constants.EGM96_EARTH_EQUATORIAL_RADIUS and flattening is Constants.WGS84_EARTH_FLATTENING

Inspired by the Celestlab method CL_ev_stationVisibility.

Parameters:

dates - Dates corresponding to each provided position

posSat - Positions of the satellite for each date

posStations - Position of each station as Vector3D {latitude, longitude, height}
The latitude and longitude are expressed in radians and height in meters. These values are in the LLHCoordinatesSystem.ELLIPSODETIC system

elevationMin - Minimum elevation needed to see the satellite per station (rad)
If the array contains only one value, it is applied to all stations

evaluationInterval - The interval on which we want to evaluate visibility of the satellite

threshold - Convergence threshold (s)

minIntervalDuration - Interval length limit for eclipse checking (s)

interpolOrder - Interpolation order for the Lagrange interpolator

Returns:

a map with the station index as key and a list of date intervals as value

Throws:

PatriusException - if dates and posSat have different sizes or if posStations and elevationMin have different sizes (except if the length of elevationMin is 1)

computeStationVisibility

public static Map<Integer,List<AbsoluteDateInterval>> computeStationVisibility(AbsoluteDate[] dates,
                                                                               List<Vector3D> posSat,
                                                                               List<Vector3D> posStations,
                                                                               double[] elevationMin,
                                                                               AbsoluteDateInterval evaluationInterval,
                                                                               double threshold,
                                                                               double minIntervalDuration,
                                                                               int interpolOrder,
                                                                               double earthRadius,
                                                                               double flattening)
                                                                        throws PatriusException

Compute the date intervals where the provided satellite is visible from the provided Earth stations considering the minimum elevation.

Inspired by the Celestlab method CL_ev_stationVisibility.

Parameters:

dates - Dates corresponding to each provided position

posSat - Positions of the satellite for each date in the ECEF frame

posStations - Position of each station as Vector3D {latitude, longitude, height}
The latitude and longitude are expressed in radians and height in meters. These values are in the LLHCoordinatesSystem.ELLIPSODETIC system

elevationMin - Minimum elevation needed to see the satellite per station (rad)
If the array contains only one value, it is applied to all stations

evaluationInterval - The interval on which we want to evaluate visibility of the satellite

threshold - Convergence threshold (s)

minIntervalDuration - Interval length limit for eclipse checking (s)

interpolOrder - Interpolation order for the Lagrange interpolator

earthRadius - Earth radius considered for the ellispoid definition (m)

flattening - Flattening factor of the Earth considered for the ellipsoid definition

Returns:

a map with the station index as key and a list of date intervals as value

Throws:

PatriusException - if dates and posSat have different sizes or if posStations and elevationMin have different sizes (except if the length of elevationMin is 1)

computeAllStaVisParam

public static double[][] computeAllStaVisParam(double[] satRadius,
                                               double[] targetRadius,
                                               EventUtils.VisiParamType typeIn,
                                               double[] paramIn)
                                        throws PatriusException

Compute all visibility parameters array for each of the provided entries.

Will return NaN for entries where the provided inputs leads to an impossible case.

Inspired by the Celestlab method CL_gm_visiParams.

Parameters:

satRadius - Distance array between the satellite and the planet center (m)

targetRadius - Distance array between the target and the planet center (m)

typeIn - Type of the provided visibility parameter

paramIn - Value array of the provided parameter

Returns:

the array of values of all the visibility parameters for each entry.

Throws:

PatriusException - if satRadius, targetRadius and paramIn have not the same length

computeAllStaVisParam

public static double[] computeAllStaVisParam(double satRadius,
                                             double targetRadius,
                                             EventUtils.VisiParamType typeIn,
                                             double paramIn)
                                      throws PatriusException

Compute all visibility parameters based on the provided visibility parameter.

Will return a NaN array if the provided inputs leads to an impossible case. Each visibility parameter can be accessed in the returned array by using the EventUtils.VisiParamType.getIndex() method.

Inspired by the Celestlab method CL_gm_visiParams.

Parameters:

satRadius - Distance between the satellite and the planet center (m)

targetRadius - Distance between the target and the planet center (m)

typeIn - Type of the provided visibility parameter

paramIn - Value of the provided parameter

Returns:

the value array of the corresponding expected visibility parameter

Throws:

PatriusException - if VisiParamType.ALL is provided as typeOut

computeStaVisParam

public static double[] computeStaVisParam(double[] satRadius,
                                          double[] targetRadius,
                                          EventUtils.VisiParamType typeIn,
                                          double[] paramIn,
                                          EventUtils.VisiParamType typeOut)
                                   throws PatriusException

Compute the chosen visibility parameter array based on the provided visibility parameter array.

Will return NaN for entries where the provided inputs leads to an impossible case.

Inspired by the Celestlab method CL_gm_visiParams.

Parameters:

satRadius - Distance array between the satellite and the planet center (m)

targetRadius - Distance array between the target and the planet center (m)

typeIn - Type of the provided visibility parameter

paramIn - Value array of the provided parameter

typeOut - Type of the expected visibility parameter

Returns:

the array of values of the corresponding expected visibility parameter

Throws:

PatriusException - if satRadius, targetRadius and paramIn have not the same length

computeStaVisParam

public static double computeStaVisParam(double satRadius,
                                        double targetRadius,
                                        EventUtils.VisiParamType typeIn,
                                        double paramIn,
                                        EventUtils.VisiParamType typeOut)
                                 throws PatriusException

Compute the chosen visibility parameter based on the provided visibility parameter.

Will return NaN if the provided inputs leads to an impossible case.

Inspired by the Celestlab method CL_gm_visiParams.

Parameters:

satRadius - Distance between the satellite and the planet center (m)

targetRadius - Distance between the target and the planet center (m)

typeIn - Type of the provided visibility parameter

paramIn - Value of the provided parameter

typeOut - Type of the expected visibility parameter

Returns:

the value of the corresponding expected visibility parameter

Throws:

PatriusException - if VisiParamType.ALL is provided as typeOut