fds.models.orbit_extrapolation package

Submodules

fds.models.orbit_extrapolation.ephemeris module

class fds.models.orbit_extrapolation.ephemeris.CartesianEphemeris(dates: Sequence[datetime], states: Sequence[CartesianState])

Bases: Ephemeris

classmethod create_from_api_dict(obj_data: dict) → CartesianEphemeris

export_table_data() → list[dict]

property frame: Frame

property states: Sequence[CartesianState]

class fds.models.orbit_extrapolation.ephemeris.Ephemeris(dates: Sequence[datetime])

Bases: ABC

abstract classmethod create_from_api_dict(obj_data: dict) → Ephemeris

property dates: Sequence[datetime]

abstract export_table_data() → list[dict]

class fds.models.orbit_extrapolation.ephemeris.EulerAnglesEphemeris(dates: Sequence[datetime], roll: Sequence[float], pitch: Sequence[float], yaw: Sequence[float], frame_1: str, frame_2: str)

Bases: Ephemeris

classmethod create_from_api_dict(obj_data: dict) → EulerAnglesEphemeris

export_table_data() → list[dict]

property frame_1: str

property frame_2: str

property pitch: ndarray

property roll: ndarray

property yaw: ndarray

class fds.models.orbit_extrapolation.ephemeris.KeplerianEphemeris(dates: Sequence[datetime], orbits: Sequence[KeplerianOrbit])

Bases: Ephemeris

classmethod create_from_api_dict(obj_data: dict) → KeplerianEphemeris

export_table_data() → list[dict]

property orbits: Sequence[KeplerianOrbit]

class fds.models.orbit_extrapolation.ephemeris.PowerEphemeris(dates: Sequence[datetime], battery_charge: Sequence[float], solar_array_collected_power: Sequence[float], thruster_power_consumption: Sequence[float], thruster_warm_up_power_consumption: Sequence[float])

Bases: Ephemeris

property battery_charge: ndarray

classmethod create_from_api_dict(obj_data: dict) → PowerEphemeris

export_table_data() → list[dict]

property solar_array_collected_power: ndarray

property thruster_power_consumption: ndarray

property thruster_warm_up_power_consumption: ndarray

class fds.models.orbit_extrapolation.ephemeris.PropulsionEphemeris(dates: Sequence[datetime], instant_consumption: Sequence[float], total_consumption: Sequence[float], thrust_direction_azimuth: Sequence[float], thrust_direction_elevation: Sequence[float], propellant_mass: Sequence[float], current_wet_mass: Sequence[float])

Bases: Ephemeris

classmethod create_from_api_dict(obj_data: dict) → PropulsionEphemeris

property current_wet_mass: ndarray

export_table_data() → list[dict]

property instant_consumption: ndarray

property propellant_mass: ndarray

property thrust_direction_azimuth: ndarray

property thrust_direction_elevation: ndarray

property total_consumption: ndarray

class fds.models.orbit_extrapolation.ephemeris.QuaternionEphemeris(dates: Sequence[datetime], quaternions: Sequence[Quaternion], frame_1: str, frame_2: str)

Bases: Ephemeris

classmethod create_from_api_dict(obj_data: dict) → QuaternionEphemeris

export_table_data() → list[dict]

property frame_1: str

property frame_2: str

property quaternions: Sequence[Quaternion]

fds.models.orbit_extrapolation.events module

class fds.models.orbit_extrapolation.events.EclipseEvent(start_date: datetime = None, end_date: datetime = None)

Bases: EventWithDuration

This class is used to represent eclipse (enter and exit) events.

class fds.models.orbit_extrapolation.events.EventWithDuration(start_date: datetime = None, end_date: datetime = None)

Bases: ABC

Base class for all events with a time duration.

class EventKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class enumerates all the event types categorized as “events with duration”.

ECLIPSE_ENTER = 'ECLIPSE_ENTER'

ECLIPSE_EXIT = 'ECLIPSE_EXIT'

STATION_ENTER = 'STATION_ENTER'

STATION_EXIT = 'STATION_EXIT'

SUN_IN_FOV_END = 'SUN_IN_FOV_END'

SUN_IN_FOV_START = 'SUN_IN_FOV_START'

property duration_sec: float | None

The duration of the event, expressed in seconds.

property end_date: datetime | None

The end date of the event.

property start_date: datetime | None

The start date of the event

class fds.models.orbit_extrapolation.events.OrbitalEvent(kind: EventKind | str, date: datetime = None)

Bases: object

This class is used to represent all the occurring event related to orbital mechanics.

class EventKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

Enumerates all the types of orbital event.

APOGEE = 'APOGEE'

ASCENDING_NODE = 'ASCENDING_NODE'

DESCENDING_NODE = 'DESCENDING_NODE'

ORBITAL_LOCAL_TIME_6AM = 'ORBITAL_LOCAL_TIME_6AM'

ORBITAL_LOCAL_TIME_6PM = 'ORBITAL_LOCAL_TIME_6PM'

ORBITAL_LOCAL_TIME_MIDNIGHT = 'ORBITAL_LOCAL_TIME_MIDNIGHT'

ORBITAL_LOCAL_TIME_NOON = 'ORBITAL_LOCAL_TIME_NOON'

PERIGEE = 'PERIGEE'

property date: datetime

The date of the orbital event.

property kind: EventKind

What type of orbital event this instance represents.

class fds.models.orbit_extrapolation.events.SensorEvent(kind: EventKind, start_date: datetime = None, end_date: datetime = None)

Bases: EventWithDuration

This class is used to represent all the event with duration related to the sensors.

class EventKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

Enumerates the sensors events currently handled.

SUN_IN_FOV = 'SUN_IN_FOV'

property kind: EventKind

The type of sensor event with duration this instance is representing.

class fds.models.orbit_extrapolation.events.StationVisibilityEvent(ground_station: GroundStation, start_date: datetime = None, end_date: datetime = None)

Bases: EventWithDuration

This class is used to represents the station visibility events with duration.

property ground_station: GroundStation

The ground station this event is associated to.

fds.models.orbit_extrapolation.requests module

class fds.models.orbit_extrapolation.requests.EphemeridesRequest(ephemeris_types: Sequence[str | EphemerisType], step: float, nametag: str = None)

Bases: RetrievableModel

Instances of this class are used to configure generation of specific ephemeris.

class EphemerisType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class enumerates the various types of ephemeris that can be generated.

ATTITUDE_EULER_ANGLES = 'ATTITUDE_EULER_ANGLES'

ATTITUDE_QUATERNIONS = 'ATTITUDE_QUATERNIONS'

CARTESIAN = 'CARTESIAN'

KEPLERIAN = 'KEPLERIAN'

POWER = 'POWER'

PROPULSION = 'PROPULSION'

property ephemeris_types: Sequence[EphemerisType]

Types of ephemeris to be computed during the orbit extrapolation.

property step: float

Time interval between each line of the epehemeris.

class fds.models.orbit_extrapolation.requests.EventsRequest(start_date: str | datetime, nametag: str = None)

Bases: RetrievableModel, ABC

This abstract base classe regroups internal features common to all events requests.

property start_date: datetime

The date from which the request starts.

class fds.models.orbit_extrapolation.requests.EventsRequestOrbital(event_kinds: Sequence[str | EventKind], start_date: str | datetime = None, nametag: str = None)

Bases: EventsRequest

Instances of this class are used to specify which orbital events are to be recorded in the result of the orbit extrapolation.

class EventKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class enumerates the orbital events types that can be recorded during an extrapolation.

APSIDE = 'APSIDE'

ECLIPSE = 'ECLIPSE'

NODE = 'NODE'

ORBITAL_6AMPM = 'ORBITAL_6AMPM'

ORBITAL_NOON_MIDNIGHT = 'ORBITAL_NOON_MIDNIGHT'

property event_kinds: Sequence[EventKind]

Which events types are to be recorded.

class fds.models.orbit_extrapolation.requests.EventsRequestSensor(event_kinds: Sequence[str | EventKind], ephemerides_step: float, sensor_axis_in_spacecraft_frame: Sequence[float | int], sensor_field_of_view_half_angle: float, start_date: str | datetime = None, nametag: str = None)

Bases: EventsRequest

Instances of this class are used to specify which sensor events are to be recorded in the result of the orbit extrapolation.

class EventKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class enumerates all the sensor events that the orbit extrapolation can compute.

SUN_IN_FOV = 'SUN_IN_FOV'

property ephemerides_step: float

Time interval between each line of the ephemeris.

property event_kinds: Sequence[EventKind]

The sensor events to be recorded in the results.

property sensor_axis_in_spacecraft_frame: ndarray

Vector of the axis of the sensor (3d array), expressed in the frame of the body of the spacecraft.

property sensor_field_of_view_half_angle: float

Half-angle of aperture of the sensor, defining its conical field of view.

class fds.models.orbit_extrapolation.requests.EventsRequestStationVisibility(ground_stations: Sequence[GroundStation], start_date: str | datetime = None, nametag: str = None)

Bases: EventsRequest

Instances of this class are used to specify which station visibility events are to be recorded in the result of the orbit extrapolation.

property ground_stations: Sequence[GroundStation]

The ground station which should trigger an event recording when the satellite enters or exits their field of view.

class fds.models.orbit_extrapolation.requests.MeasurementsRequest(generation_step: float, nametag: str)

Bases: RetrievableModel, ABC

This class regroups features common to all kind of measurements computation requests.

class StandardDeviation

Bases: object

property generation_step: float

Time interval between each generated measure.

class fds.models.orbit_extrapolation.requests.MeasurementsRequestGpsNmea(standard_deviation_ground_speed: float, standard_deviation_latitude: float, standard_deviation_longitude: float, standard_deviation_altitude: float, generation_step: float, nametag: str = None)

Bases: MeasurementsRequest

Instances of this class are used to configure GPS NMEA measurements generation during orbit extrapolation.

class StandardDeviation(ground_speed: float, latitude: float, longitude: float, altitude: float)

Bases: object

Data class for standard deviation of this kind of measurements.

altitude: float

ground_speed: float

latitude: float

longitude: float

property standard_deviation: StandardDeviation

Standard deviation of the generated measures.

class fds.models.orbit_extrapolation.requests.MeasurementsRequestGpsPv(standard_deviation_position: float, standard_deviation_velocity: float, generation_step: float, frame: Frame | str, nametag: str = None)

Bases: MeasurementsRequest

Instances of this class are used to generate GPS Position-Velocity measurement during the orbit extrapolation.

class StandardDeviation(position: float, velocity: float)

Bases: object

Data class for the standard deviations of this kind of measure.

position: float

velocity: float

property frame: Frame

Frame in which the generated measurements are defined.

property standard_deviation: StandardDeviation

Standard deviation of the generated measurements.

class fds.models.orbit_extrapolation.requests.MeasurementsRequestOptical(azimuth_standard_deviation: float, elevation_standard_deviation: float, ground_station: GroundStation, generation_step: float, nametag: str = None)

Bases: MeasurementsRequestStation

Instances of this class are used to configure optical measurement generation during orbit extrapolation.

property standard_deviation: StandardDeviation

Standard deviations of the generated measures.

class fds.models.orbit_extrapolation.requests.MeasurementsRequestRadar(azimuth_standard_deviation: float, elevation_standard_deviation: float, ground_station: GroundStation, generation_step: float, two_way_measurement: bool, range_standard_deviation: float, range_rate_standard_deviation: float, nametag: str = None)

Bases: MeasurementsRequestStation

Instances of this class are used to configure the generation of radar measurements during the orbit extrapolation.

class StandardDeviation(range: float, range_rate: float, azimuth: float, elevation: float)

Bases: object

Data class for the standard deviations of this kind of measures.

azimuth: float

elevation: float

range: float

range_rate: float

property standard_deviation: StandardDeviation

Standard deviations of the measurement generations.

property two_way_measurement: bool

For two-way measurements, the measurement is considered to be a signal emitted from a ground station, reflected on spacecraft, and received on the same ground station. Its value is the elapsed time between emission and reception divided by 2c were c is the speed of light. For one-way measurements, a signal is emitted by the satellite and received by the ground station. The measurement value is the elapsed time between emission and reception divided by the speed of light. The motion of both the station and the spacecraft during the signal flight time are taken into account. The date of the measurement corresponds to the reception on ground of the emitted or reflected signal.

source https://www.orekit.org/site-orekit-9.2/apidocs/org/orekit/estimation/measurements/Range.html

class fds.models.orbit_extrapolation.requests.MeasurementsRequestStation(ground_station: GroundStation, generation_step: float, nametag: str)

Bases: MeasurementsRequest, ABC

Common features for all measures generated from a ground station.

class StandardDeviation(azimuth: float, elevation: float)

Bases: object

Data class for the standard deviation on different axes.

azimuth: float

elevation: float

property ground_station: GroundStation

The ground station from which the measures are generated.

class fds.models.orbit_extrapolation.requests.OemRequest(creator: str, ephemerides_step: float, frame: str | Frame, object_id: str, object_name: str, write_acceleration: bool = False, write_covariance: bool = False, nametag: str = None)

Bases: OrbitDataMessageRequest

Instances of this class are used to specify that orbit ephemeris message are to be generated during the result of the orbit extrapolation.

property creator: str

Name of the creator of the orbit ephemeris message.

property ephemerides_step: float

Time interval between each line of the ephemeris.

property frame: Frame

Name of the frame of the output ephemeris.

property object_id: str

Object identifier.

property object_name: str

Object name.

property write_acceleration: bool

If true, the acceleration will be included in the OEM. Default is false.

property write_covariance: bool

If true, the uncertainties of the orbits will be outputted as covariance matrices. Default is false.

class fds.models.orbit_extrapolation.requests.OrbitDataMessageRequest(nametag: str = None)

Bases: FromConfigBaseModel, RetrievableModel, ABC

Common class to all Orbit Data Messages that can be generated during the Orbit Extrapolation.

fds.models.orbit_extrapolation.result module

class fds.models.orbit_extrapolation.result.ResultOrbitExtrapolation(computed_events: list[dict] = (), computed_measurements: list[dict] = (), orbit_data_message: str = (), orbital_states: list[dict] = (), ephemerides: list[EphemerisDto] = (), nametag: str = None)

Bases: RetrievableModel

Instances of this class are output of orbit extrapolation computation; they hold all the computed data.

class Ephemerides(power: PowerEphemeris = None, keplerian: KeplerianEphemeris = None, cartesian: CartesianEphemeris = None, propulsion: PropulsionEphemeris = None, attitude_quaternions: QuaternionEphemeris = None, attitude_euler_angles: EulerAnglesEphemeris = None)

Bases: object

This class structures the ephemeris computed during orbit extrapolation.

attitude_euler_angles: EulerAnglesEphemeris = None

attitude_quaternions: QuaternionEphemeris = None

cartesian: CartesianEphemeris = None

property dates: Sequence[datetime]

The dates at which the ephemeris have been computed.

export_ephemeris_data(data_name: EphemerisType) → list[dict]

Extract a subset of the computed ephemeris.

Parameters:

data_name – the data column to be extracted

Returns:

a list, each element being a dict containing the extracted data with its time stamp

keplerian: KeplerianEphemeris = None

power: PowerEphemeris = None

propulsion: PropulsionEphemeris = None

property computed_measurements: list[TelemetryGpsNmea | TelemetryGpsPv] | None

The measurements computed during the computation (defined by the measurements_request property of the OrbitExtrapolation instance which led to the computation of this result).

property eclipse_events: list[EclipseEvent] | None

The eclipse events computed during the computation (if present in the orbital_events_request property of the OrbitExtrapolation instance which led to the computation of this result).

property ephemerides: Ephemerides

The ephemerides computed during the extrapolation.

export_cartesian_ephemeris() → list[dict]

Extract the ephemeris of computed cartesian orbits from the results.

Returns:

a list, each element being a dict containing a cartesian orbit with its time stamp

export_euler_angles_ephemeris() → list[dict]

Extract the ephemeris of computed rotation represented by euler angles from the results.

Returns:

a list, each element being a dict containing a set of euler angles with its time stamp

export_event_gantt_data() → list[dict]

Export data for Gantt chart correctly sorted.

Returns:

List of dictionaries with the following keys: ‘start_date’, ‘end_date’, ‘event’,

’ground_station_name’, ‘ground_station_id’, ‘duration’.

Return type:

list[dict]

export_event_timeline_data() → list[dict]

Export data for a timeline correctly sorted.

Returns:

List of dictionaries with the following keys: ‘date’, ‘event’, ‘ground_station_name’,

’ground_station_id’.

Return type:

list[dict]

export_keplerian_ephemeris() → list[dict]

Extract the ephemeris of computed keplerian orbits from the results.

Returns:

a list, each element being a dict containing a keplerian orbit with its time stamp

export_power_ephemeris() → list[dict]

Extract the ephemeris of computed battery state from the results.

Returns:

a list, each element being a dict containing a battery state with its time stamp

export_propulsion_ephemeris() → list[dict]

Extract the ephemeris of computed thrust from the results.

Returns:

a list, each element being a dict containing a thrust with its time stamp

export_quaternion_ephemeris() → list[dict]

Extract the ephemeris of computed rotation represented by quaternions from the results.

Returns:

a list, each element being a dict containing a computed quaternion with its time stamp

property last_orbital_state: OrbitalState | None

The last one of the computed orbital states.

property orbit_data_message: str | None

The orbit data message computed during the computation (defined by the orbit_data_message_request property of the OrbitExtrapolation instance which led to the computation of this result).

property orbital_events: list[OrbitalEvent] | None

The orbital events computed during the computation (defined by the orbital_events_request property of the OrbitExtrapolation instance which led to the computation of this result).

property orbital_states: list[OrbitalState]

The computed orbital states (defined by the required_orbital_state property of the OrbitExtrapolation instance which led to the computation of this result).

property sensor_events: list[SensorEvent] | None

The sensor events computed during the computation (defined by the sensor_events_request property of the OrbitExtrapolation instance which led to the computation of this result).

static sort_event_gantt_data(columns, df_data_list)

This functions sorts the all the given events in the chronological order of their end date.

Parameters:

• columns – the labels of events to be sorted

• df_data_list – the dataframe containing all events to be sorted

Returns:

an ordered list of events

property station_visibility_events: list[StationVisibilityEvent] | None

The station visibility events computed during the computation (defined by the station_visibility_events_request property of the OrbitExtrapolation instance which led to the computation of this result).

fds.models.orbit_extrapolation.use_case module

class fds.models.orbit_extrapolation.use_case.OrbitExtrapolation(initial_orbital_state: OrbitalState, measurements_request: MeasurementsRequest = None, orbit_data_message_request: OrbitDataMessageRequest = None, duration: float = None, roadmap: RoadmapFromActions | RoadmapFromSimulation = None, orbital_events_request: EventsRequestOrbital = None, station_visibility_events_request: EventsRequestStationVisibility = None, sensor_events_request: EventsRequestSensor = None, required_orbital_states: str | RequiredOrbitalStates = RequiredOrbitalStates.LAST, ephemerides_request: EphemeridesRequest = None, extrapolate_covariance: bool = False, nametag: str = None)

Bases: OrbitalStateUseCase

This class is used to specify the data needed to perform an orbit extrapolation computation.

property duration: float | None

For how long the orbital state is to be propagated.

property ephemerides_request: EphemeridesRequest

Which ephemerides are to be recorded in the output of the extrapolation.

property extrapolate_covariance: bool

Should the covariance of the extrapolated state(s) be computed as well?

property final_date

The date up to which the orbital state is to be propagated.

property initial_date

The date from which the propagation starts.

property measurements_request: MeasurementsRequest

Which measurements are to be recorded in the output of the extrapolation.

property orbit_data_message_request: OrbitDataMessageRequest

Which ODM (Orbit Data Message) are to be produced in the output of the extrapolation.

property orbital_events_request: EventsRequestOrbital

Which orbital events are to be recorded in the output of the extrapolation.

property required_orbital_states: RequiredOrbitalStates

Which orbital states are to be included in the results? Only the last one or every single computed one?

property result: ResultOrbitExtrapolation

The output of the orbit extrapolation computation.

property roadmap: RoadmapFromSimulation | RoadmapFromActions | None

The maneuver roadmap of the satellite, if any maneuver is to be performed during the extrapolation.

property sensor_events_request: EventsRequestSensor

Which sensor events are to be recorded in the output of the extrapolation.

property station_visibility_events_request: EventsRequestStationVisibility

Which station visibility events are to be recorded in the output of the extrapolation.

classmethod with_target_date(target_date: datetime | str, initial_orbital_state: OrbitalState, measurements_request: MeasurementsRequest = None, orbit_data_message_request: OrbitDataMessageRequest = None, roadmap: RoadmapFromActions | RoadmapFromSimulation = None, orbital_events_request: EventsRequestOrbital = None, station_visibility_events_request: EventsRequestStationVisibility = None, sensor_events_request: EventsRequestSensor = None, required_orbital_states: str | RequiredOrbitalStates = RequiredOrbitalStates.LAST, ephemerides_request: EphemeridesRequest = None, extrapolate_covariance: bool = False, nametag: str = None)

Creates a new orbit extrapolation with a new target date.

Parameters:

• target_date (datetime | str) – The target date (only future dates are allowed).

• initial_orbital_state (OrbitalState) – The initial orbital state object.

• measurements_request (MeasurementsRequest) – The measurements request object. Defaults to None.

• orbit_data_message_request (OrbitDataMessageRequest) – The orbit data message request object. Defaults to None.

• roadmap (RoadmapFromActions | RoadmapFromSimulation) – The roadmap object. Defaults to None. If None, duration is needed.

• orbital_events_request (EventsRequestOrbital) – The orbital events request object. Defaults to None.

• station_visibility_events_request (EventsRequestStationVisibility) – The station visibility events request object. Defaults to None.

• sensor_events_request (EventsRequestSensor) – The sensor events request object. Defaults to None.

• required_orbital_states (str | RequiredOrbitalStates) – The required orbital states included in the output (ALL or LAST). Defaults to LAST.

• ephemerides_request (EphemeridesRequest) – The ephemerides request object. Defaults to None.

• extrapolate_covariance (bool) – Whether to extrapolate the covariance matrix. Defaults to False.

• nametag (str) – The name of the use case. Defaults to None.

Returns:

a new orbit extrapolation use case object.

Module contents