fds.models package

Subpackages

Submodules

fds.models.actions module

class fds.models.actions.Action(date: str | datetime, nametag)

Bases: TimestampedRetrievableModel, ABC

FDS_TYPE: Models = 'ACTION'
classmethod api_retrieve_map(obj_data: dict) → dict
class fds.models.actions.ActionAttitude(attitude_mode: str | AttitudeMode, transition_date: str | datetime, quaternions: Sequence[Quaternion] = None, nametag: str = None)

Bases: Action

FDS_TYPE: Models = 'ACTION_ATTITUDE'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property attitude_mode: AttitudeMode
property quaternions: Sequence[Quaternion] | None
property transition_date: datetime
class fds.models.actions.ActionFiring(firing_attitude_mode: str | AttitudeMode, post_firing_attitude_mode: str | AttitudeMode, duration: float, firing_start_date: str | datetime, warm_up_duration: float = 0, warm_up_attitude_mode: str | AttitudeMode = None, nametag: str = None)

Bases: Action

FDS_TYPE: Models = 'ACTION_FIRING'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property duration: float
property firing_attitude_mode: AttitudeMode
property firing_end_date: datetime
property firing_start_date: datetime
classmethod from_firing_date_range(firing_date_range: DateRange, firing_attitude_mode: str | AttitudeMode, post_firing_attitude_mode: str | AttitudeMode, warm_up_duration: float = 0, warm_up_attitude_mode: str | AttitudeMode = None, nametag: str = None)
Parameters:

  • firing_date_range (DateRange) – The date range of the firing.

  • firing_attitude_mode (str | AttitudeMode) – The attitude mode of the satellite during the firing.

  • post_firing_attitude_mode (str | AttitudeMode) – The attitude mode of the satellite after the firing.

  • warm_up_duration (float) – (Unit: s) Defaults to 0.

  • warm_up_attitude_mode (str | AttitudeMode) – Defaults to None.

  • nametag (str) – Defaults to None.

property post_firing_attitude_mode: AttitudeMode
property warm_up_attitude_mode: AttitudeMode
property warm_up_duration: float
property warm_up_end_date: datetime
property warm_up_start_date: datetime
class fds.models.actions.ActionThruster(thruster_mode: str | ThrusterMode, date: str | datetime, nametag: str = None)

Bases: Action

FDS_TYPE: Models = 'ACTION_THRUSTER'
class ThrusterMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

STANDBY = 'STANDBY'
STOP = 'STOP'
THRUSTER_ON = 'THRUSTER_ON'
WARMUP = 'WARMUP'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property thruster_mode: ThrusterMode
class fds.models.actions.AttitudeMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

ANTI_NORMAL = 'ANTI_NORMAL'
ANTI_RADIAL = 'ANTI_RADIAL'
LOF_ALIGNED_LVLH_CCSDS = 'LOF_ALIGNED_LVLH_CCSDS'
NORMAL = 'NORMAL'
PAYLOAD = 'PAYLOAD'
PROGRADE = 'PROGRADE'
QUATERNION = 'QUATERNION'
RADIAL = 'RADIAL'
RETROGRADE = 'RETROGRADE'
RETROGRADE_NADIR = 'RETROGRADE_NADIR'
SUN_POINTING = 'SUN_POINTING'
TELECOM = 'TELECOM'
TRANSITIONAL = 'TRANSITIONAL'

fds.models.ground_station module

class fds.models.ground_station.GroundStation(name: str, latitude: float, longitude: float, altitude: float, min_elevation: float = None, elevation_masks: Sequence[tuple[float, float]] = None, nametag: str = None)

Bases: RetrievableModel

class Coordinates(latitude: float, longitude: float)

Bases: object

latitude: float
longitude: float
class ElevationMask(azimuth: float, elevation: float)

Bases: object

azimuth: float
elevation: float
FDS_TYPE: Models = 'GROUND_STATION'
property altitude: float
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property coordinates: Coordinates
property elevation_masks: Sequence[ElevationMask]
property min_elevation: float
property name: str

fds.models.orbital_state module

class fds.models.orbital_state.CovarianceMatrix(matrix: Sequence[Sequence[float]] | ndarray, frame: str | Frame, date: str | datetime = None, orbit_type: str | OrbitType = OrbitType.CARTESIAN, nametag: str = None)

Bases: TimestampedRetrievableModel

This class is used to represent uncertainties on an orbit position through covariance matrices.

property diagonal: ndarray

Diagonal coefficients of the covariance matrix (i.e variances of all the parameters).

property frame: Frame

The reference frame of the covariance matrix.

classmethod from_diagonal(diagonal: Sequence[float] | ndarray, frame: str | Frame, date: str | datetime = None, orbit_type: str | OrbitType = OrbitType.CARTESIAN, nametag: str = None)

Instantiates a new CovarianceMatrix from its diagonal coefficients.

Parameters:

  • diagonal (Sequence[float] | np.ndarray) – The diagonal of the covariance matrix.

  • frame (str | Frame) – The reference frame of the covariance matrix.

  • date (str | datetime) – The date of the covariance matrix.

  • orbit_type (str | OrbitType) – The orbit type of the covariance matrix.

  • nametag (str) – Defaults to None.

Returns:

a new CovarianceMatrix instance.

property matrix: ndarray

The covariance matrix.

property orbit_type: OrbitType

If the orbit this covariance matrix describes the uncertainties of is mean or osculating.

property standard_deviation: ndarray

Standard deviation of the covariance matrix.

class fds.models.orbital_state.OrbitalState(creation_date: str | datetime, fitted_tle: TwoLineElement | str, mean_orbit: KeplerianOrbit, osculating_orbit: KeplerianOrbit, propagation_context: PropagationContext, source: str | Source, spacecraft: SpacecraftSphere | SpacecraftBox, covariance_matrix: CovarianceMatrix = None, nametag: str = None)

Bases: TimestampedRetrievableModel

This class represents all the information known about a satellite at a given date, including but not limited to its mean and osculating orbits and their associated uncertainties, as well as the architecture of the spacecraft.

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

Bases: EnumFromInput

This class describes what was the source for the orbital position of the orbital state.

FROM_MEAN_ORBIT = 'FROM_MEAN_ORBIT'
FROM_OSCULATING_ORBIT = 'FROM_OSCULATING_ORBIT'
FROM_TLE = 'FROM_TLE'
class Source(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class describes how the orbital state has been created.

MANEUVER_GENERATION = 'MANEUVER_GENERATION'
MANUAL = 'MANUAL'
ORBIT_DETERMINATION = 'ORBIT_DETERMINATION'
ORBIT_EXTRAPOLATION = 'ORBIT_EXTRAPOLATION'
property covariance_matrix: CovarianceMatrix

The uncertainties associated with the OSCULATING orbit.

property creation_date: datetime

The date at which this orbital state instance has been created. (Not the date at which the data hold by this orbital state instance is expressed!)

property fitted_tle: TwoLineElement

The TLE representing the orbital state. It is exact if the orbital state has been initiated from a TLE, or recomputed otherwise.

classmethod from_orbit(propagation_context: PropagationContext, spacecraft: SpacecraftSphere | SpacecraftBox, orbit: Orbit, covariance_matrix: CovarianceMatrix = None, nametag: str = None)

Creates a new orbital state from an orbit.

Parameters:

  • propagation_context – Configuration of the space dynamics models and the numerical integrator used to

  • state. (perform computation on this orbital)

  • spacecraft – The model of the spacecraft in itself (mass, geometry, components …).

  • orbit – The orbit from which this new orbital state is to be created from.

  • covariance_matrix – The uncertainties associated with the OSCULATING orbit.

  • nametag – Nickname of the orbital state. Default value is none.

Returns:

a new orbital state.

classmethod from_tle(propagation_context: PropagationContext, spacecraft: SpacecraftSphere | SpacecraftBox, tle: TwoLineElement | str, covariance_matrix: CovarianceMatrix = None, nametag: str = None)

Creates a new orbital state from a TLE.

Parameters:

  • propagation_context – Configuration of the space dynamics models and the numerical integrator used to

  • state. (perform computation on this orbital)

  • spacecraft – The model of the spacecraft in itself (mass, geometry, components …).

  • tle – The TLE from which this new orbital state is to be created from.

  • covariance_matrix – The uncertainties associated with the OSCULATING orbit.

  • nametag – Nickname of the orbital state. Default value is none.

Returns:

a new orbital state.

property initialisation: Initialisation

Has the orbital state been initialized from a mean orbit, an osculating orbit, or a TLE?

property initialisation_orbit: KeplerianOrbit | None

The orbit from which the orbital state has been initiated. Will return none if the orbital state has been initiated from a TLE.

property mean_orbit: KeplerianOrbit

The mean orbit of the satellite. It is exact if the orbital state has been initiated from a mean orbit, or recomputed otherwise.

property osculating_orbit: KeplerianOrbit

The osculating orbit of the satellite. It is exact if the orbital state has been initiated from a osculating orbit, or recomputed otherwise.

property propagation_context: PropagationContext

Configuration of the space dynamics models and the numerical integrator used to perform computation on this orbital state.

property source: Source

Has the orbital state been created by the user, or is it the output of a space mechanics computation? (and if so, which one?)

property spacecraft: SpacecraftSphere | SpacecraftBox

The model of the spacecraft in itself (mass, geometry, components …).

class fds.models.orbital_state.PropagationContext(integrator_min_step: float = None, integrator_max_step: float = None, integrator_kind: str | IntegratorKind = None, model_perturbations: Sequence[str | Perturbation] = None, model_solar_flux: float = None, model_earth_potential_deg: int = None, model_earth_potential_ord: int = None, model_atmosphere_kind: str | AtmosphereModel = None, nametag: str = None)

Bases: FromConfigBaseModel, RetrievableModel

This class holds all the data configuring the physics and mathematical model used in the space mechanics computation. It is used to describe everything other than the spacecraft in itself.

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

Bases: EnumFromInput

This class enumerates all the atmosphere models that can be simulated in the space mechanics computations.

HARRIS_PRIESTER = 'HARRIS_PRIESTER'
NRL_MSISE00 = 'NRL_MSISE00'
class IntegratorData(kind: IntegratorKind, min_step: float, max_step: float)

Bases: object

This class holds the data relevant for numerical integrator specification.

kind: IntegratorKind
max_step: float
min_step: float
class IntegratorKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class enumerates all the numerical integrator supported.

ADAMS_MOULTON = 'ADAMS_MOULTON'
DORMAND_PRINCE_54 = 'DORMAND_PRINCE_54'
DORMAND_PRINCE_853 = 'DORMAND_PRINCE_853'
RUNGE_KUTTA = 'RUNGE_KUTTA'
class ModelData(perturbations: Sequence[Perturbation], solar_flux: float, earth_potential_deg: int, earth_potential_ord: int, atmosphere_kind: AtmosphereModel)

Bases: object

This class holds all the physical data for the perturbations considered in the space mechanics computation.

atmosphere_kind: AtmosphereModel
earth_potential_deg: int
earth_potential_ord: int
perturbations: Sequence[Perturbation]
solar_flux: float
class Perturbation(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class enumerates all the perturbations that can be simulated in the space mechanics computations.

CONSTANT_THRUST = 'CONSTANT_THRUST'
DRAG = 'DRAG'
EARTH_POTENTIAL = 'EARTH_POTENTIAL'
IMPULSIVE_THRUST = 'IMPULSIVE_THRUST'
SRP = 'SRP'
THIRD_BODY = 'THIRD_BODY'
property integrator: IntegratorData

The configuration of the integrator used in the computations.

property model: ModelData

The configuration of the perturbations models used in the computations.

class fds.models.orbital_state.RequiredOrbitalStates(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

This class enumerates if the computation should return all the computed orbital states or just the last one.

ALL = 'ALL'
LAST = 'LAST'

fds.models.orbits module

class fds.models.orbits.CartesianState(position_x: float, position_y: float, position_z: float, velocity_x: float, velocity_y: float, velocity_z: float, date: str | datetime, frame: str | Frame, nametag: str = None)

Bases: Orbit

Data container objects for orbits defined with cartesian parameters.

classmethod from_position_velocity(position: Sequence[float] | ndarray, velocity: Sequence[float] | ndarray, date: str | datetime, frame: str | Frame, nametag: str = None)

Instantiate a new CartesianOrbit a Position vector and a Velocity vector

Parameters:

  • position (Sequence[float]) – Position (Unit: km)

  • velocity (Sequence[float]) – Velocity (Unit: km/s)

  • date (str) – Date in UTC format

  • frame (str | Frame) – Frame

  • nametag (str, optional) – Defaults to None.

Returns:

A new CartesianOrbit instance.

classmethod from_state(state: ndarray, date: str | datetime, frame: str | Frame, nametag: str = None)

Instantiate a CartesianOrbit from a given state vector.

Parameters:

  • state (np.ndarray) – State vector with shape (6,), for position and velocity (Unit: km and km/s)

  • date (str) – Date in UTC format

  • frame (str | Frame) – Frame

  • nametag (str, optional) – Defaults to None.

Returns:

A new CartesianOrbit instance.

property position: ndarray

Position vector of the orbit. All components are expressed in km.

property position_x: float

Position along the X axis of the orbit [km].

property position_y: float

Position along the Y axis of the orbit [km].

property position_z: float

Position along the Z axis of the orbit [km].

property state: ndarray

State vector of the orbit as an array.

property velocity: ndarray

Velocity vector of the orbit. All components are expressed in km/s.

property velocity_x: float

Velocity along the X axis of the orbit [km/s].

property velocity_y: float

Velocity along the Y axis of the orbit [km/s].

property velocity_z: float

Velocity along the Z axis of the orbit [km/s].

class fds.models.orbits.KeplerianOrbit(semi_major_axis: float, anomaly: float, argument_of_perigee: float, eccentricity: float, inclination: float, raan: float, anomaly_kind: str | PositionAngleType, kind: str | OrbitMeanOsculatingType, date: str | datetime, frame: str | Frame = Frame.GCRF, nametag: str = None)

Bases: Orbit

Data container for orbits defined with Keplerian parameters.

property anomaly_kind: PositionAngleType

Is the anomaly true, mean or eccentric?

property keplerian_period: float

Period of the orbit [s]

property orbital_elements: OrbitalElements

Orbital elements defining the keplerian orbit.

class fds.models.orbits.Orbit(kind: str | OrbitMeanOsculatingType, date: str | datetime, frame: str | Frame, nametag: str = None)

Bases: TimestampedRetrievableModel, ABC

Base class for all data container orbits objects which holds features shared by all.

property frame: Frame

Frame in which the orbit instance is defined.

property kind: OrbitMeanOsculatingType

Is this instance a mean orbit or an osculating one?

classmethod retrieve_generic_by_id(client_id: str, nametag: str = None)

Creates an orbit by retrieving the corresponding data stored in persistence.

Parameters:

  • client_id – ID of the object

  • nametag – nametag

class fds.models.orbits.OrbitMeanOsculatingType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

MEAN = 'MEAN'
OSCULATING = 'OSC'
class fds.models.orbits.OrbitType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

CARTESIAN = 'CARTESIAN'
CIRCULAR = 'CIRCULAR'
EQUINOCTIAL = 'EQUINOCTIAL'
KEPLERIAN = 'KEPLERIAN'
class fds.models.orbits.PositionAngleType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

MEAN = 'MEAN'
TRUE = 'TRUE'

fds.models.quaternion module

class fds.models.quaternion.Quaternion(real: float, i: float, j: float, k: float, date: datetime | str = None, frame_1: str = None, frame_2: str = None)

Bases: object

This class is used to represent a representation through a quaternion description.

conjugate() → Self

Computes the conjugate of the quaternion.

Returns:

a new Quaternion instance representing the conjugate of this quaternion.

property date: datetime | None

The date at which the quaternion is defined (if any).

property frame_1: str

Name of the frame from which the rotation starts.

property frame_2: str

Name of the frame to which the rotation ends.

classmethod from_angle_axis(angle: float, axis: Sequence[float] | ndarray, date: datetime | str = None, frame_1: str = None, frame_2: str = None) → Self

Convert an angle and an axis to a quaternion.

Parameters:

  • angle (float) – angle [rad]

  • axis (np.ndarray | Sequence[float]) – axis [3x1]

  • date (datetime | str) – date of the quaternion (default: None)

  • frame_1 (str) – name of the starting frame (default: None)

  • frame_2 (str) – name of the ending frame (default: None)

Returns:

quaternion

Return type:

quaternion (Quaternion)

Source:

Celestlab (v 3.4.2), https://atoms.scilab.org/toolboxes/celestlab, CL_rot_axAng2quat

classmethod from_angles(angles: ndarray | Sequence[float], rot_order: str = 'XYZ', date: datetime | str = None, frame_1: str = None, frame_2: str = None) → Self

Convert angles to a quaternion.

Parameters:

  • angles (np.ndarray | Sequence[float]) – angles [rad]

  • rot_order (str) – rotation order

  • date (datetime | str) – date of the quaternion (default: None)

  • frame_1 (str) – name of the starting frame (default: None)

  • frame_2 (str) – name of the ending frame (default: None)

Returns:

quaternion

Return type:

quaternion (Quaternion)

Source:

Celestlab (v 3.4.2), https://atoms.scilab.org/toolboxes/celestlab, CL_rot_angles2quat

classmethod from_collection(data: Collection[float], date: datetime | str = None, frame_1: str = None, frame_2: str = None) → Self

Create a Quaternion object from an iterable with 4 elements.

Parameters:

  • data (list[float]) – list with 4 elements (real, i, j, k)

  • date (datetime | str) – date of the quaternion (default: None)

  • frame_1 (str) – name of the starting frame (default: None)

  • frame_2 (str) – name of the ending frame (default: None)

Returns:

quaternion

Return type:

quaternion (Quaternion)

classmethod from_collections(data: Collection[Collection[float]], dates: Collection[datetime | str] = None, frame_1: str = None, frame_2: str = None) → list[Self]

Create a list of Quaternion objects from a list of iterables with 4 elements.

Parameters:

  • data (list[list[float]]) – list of list with 4 elements (real, i, j, k)

  • dates (list[list | str]) – list of dates of the quaternions (default: None)

  • frame_1 (str) – name of the starting frame (default: None)

  • frame_2 (str) – name of the ending frame (default: None)

Returns:

list of quaternions

Return type:

list[Quaternion]

classmethod from_rotation_matrix(rot_mat: ndarray, date: datetime | str = None, frame_1: str = None, frame_2: str = None) → Self

Convert a rotation matrix to a quaternion.

Parameters:

  • rot_mat – rotation matrix 3x3

  • date (datetime | str) – date of the quaternion (default: None)

  • frame_1 (str) – name of the starting frame (default: None)

  • frame_2 (str) – name of the ending frame (default: None)

Returns:

quaternion

Return type:

quaternion (Quaternion)

Source:

Celestlab (v 3.4.2), https://atoms.scilab.org/toolboxes/celestlab, CL_rot_matrix2quat

property i: float

Component of the quaternion on the i axis.

imag() → ndarray

Get the imaginary part of the quaternion.

Returns:

an array with the components on the i, j and k axis of the quaternion.

property j: float

Component of the quaternion on the j axis.

property k: float

Component of the quaternion on the k axis.

norm() → float

Compute the norm of the quaternion.

property real: float

Component of the quaternion on the real axis.

rotate(vector: ndarray | Sequence[float]) → ndarray

Rotate a vector using the quaternion with the formula v’ = qvq*. The result of this operation is the image of v in the starting frame. To obtain the vector in the new frame, use the conjugate of the quaternion.

Parameters:

vector (np.ndarray | Sequence[float]) – vector to rotate [3x1]

Returns:

rotated vector in the starting frame

Return type:

np.ndarray

Source:

Celestlab (v 3.4.2), https://atoms.scilab.org/toolboxes/celestlab, CL_rot_rotVect

to_angle_axis() → tuple[float, ndarray]

Convert a quaternion to angle-axis representation.

Returns:

float

Angle of rotation in radians.

axis: np.ndarray

Axis of rotation as a NumPy array.

Return type:

angle

to_angles(rot_order: str = 'XYZ') → tuple[ndarray, ndarray]

Convert the quaternion to angles set in the order given by rot_order: - 6 Cardan rotations (for which all axes are different): XYZ, XZY, YXZ, YZX, ZXY and ZYX - 6 Euler rotations (for which 2 axes are the same): XYX, XZX, YXY, YZY, ZXZ and ZYZ

Returns:

3 Angles [rad] np.ndarray: 3 Alternative angles [rad]

Return type:

np.ndarray

Source:

Celestlab (v 3.4.2), https://atoms.scilab.org/toolboxes/celestlab, CL_rot_quat2angles

to_rotation_matrix() → ndarray

Convert the quaternion to a rotation matrix R that rotates a vector v to v’ = Rv. The result of this operation is a vector v expressed in the new frame.

Returns:

rotation matrix 3x3

Return type:

np.ndarray

Source:

Celestlab (v 3.4.2), https://atoms.scilab.org/toolboxes/celestlab, CL_rot_quat2matrix

unit() → Self

Normalizes the quaternion.

fds.models.quaternion.get_univoque_list_of_dated_quaternions(quaternions: Collection[Quaternion], ignore_different_quaternions_at_same_date: bool = False) → list[Quaternion]

This method takes a list of dated quaternions and returns a list of dated quaternions without duplicates. If two quaternions have the same date and they are the same, only one is kept. If two quaternions have the same date but they are different, an exception is raised if ignore_different_quaternions_at_same_date is False, otherwise no quaternion is kept. The list is then sorted by date.

Parameters:

  • quaternions (list[Quaternion]) – list of dated quaternions

  • ignore_different_quaternions_at_same_date (bool) – if False, an exception is raised if two quaternions have the same date but they are different (default: False)

fds.models.roadmaps module

class fds.models.roadmaps.Roadmap(nametag: str = None, **kwargs)

Bases: RetrievableModel, ABC

abstract property end_date: datetime
export_attitude_gantt() → list[dict]
export_thruster_gantt() → list[dict]
abstract property start_date: datetime
abstract property timeline: list[dict]
class fds.models.roadmaps.RoadmapFromActions(actions: Sequence[ActionAttitude | ActionFiring], start_date: str | datetime = None, end_date: str | datetime = None, nametag: str = None)

Bases: Roadmap, RetrievableModel

FDS_TYPE: Models = 'ROADMAP_FROM_ACTIONS'
property actions: Sequence[ActionAttitude | ActionFiring]
api_create_map(force_save: bool = False) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
create_new_extended_after(final_date: datetime) → Self
property duration
property end_date: datetime
property start_date: datetime
property timeline
class fds.models.roadmaps.RoadmapFromSimulation(attitude_actions: list[ActionAttitude], thruster_actions: list[ActionThruster], metadata: dict = None, creation_date: str | datetime = None, nametag: str = None)

Bases: Roadmap, RetrievableModel

FDS_TYPE: Models = 'ROADMAP_FROM_SIMULATION'
api_create_map(force_save: bool = False) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property attitude_actions: list[ActionAttitude]
property creation_date: datetime
property duration
property end_date
property metadata: dict
property start_date: datetime
property thruster_actions: list[ActionThruster]
property timeline

fds.models.spacecraft module

class fds.models.spacecraft.Battery(depth_of_discharge: float, nominal_capacity: float, minimum_charge_for_firing: float, initial_charge: float, nametag: str = None)

Bases: FromConfigBaseModel, RetrievableModel

FDS_TYPE: Models = 'BATTERY'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property depth_of_discharge: float
property initial_charge: float
property minimum_charge_for_firing: float
property nominal_capacity: float
class fds.models.spacecraft.SolarArray(kind: str | Kind, initialisation_kind: InitialisationKind | str, efficiency: float, normal_in_satellite_frame: tuple[float, float, float], maximum_power: float = None, surface: float = None, axis_in_satellite_frame: tuple[float, float, float] = None, satellite_faces: Sequence[str | SatelliteFace] = None, nametag: str = None)

Bases: FromConfigBaseModel, RetrievableModel

FDS_TYPE: Models = 'SOLAR_ARRAY'
class InitialisationKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

MAXIMUM_POWER = 'MAXIMUM_POWER'
SURFACE = 'SURFACE'
SURFACE_AND_POWER = 'SURFACE_AND_POWER'
class Kind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

BODY = 'BODY'
DEPLOYABLE_FIXED = 'DEPLOYABLE_FIXED'
DEPLOYABLE_ROTATING = 'DEPLOYABLE_ROTATING'
NONE = 'NONE'
class SatelliteFace(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

MINUS_X = 'MINUS_X'
MINUS_Y = 'MINUS_Y'
MINUS_Z = 'MINUS_Z'
PLUS_X = 'PLUS_X'
PLUS_Y = 'PLUS_Y'
PLUS_Z = 'PLUS_Z'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property axis_in_satellite_frame: ndarray
property efficiency: float
property initialisation_kind: InitialisationKind
property kind: Kind
property maximum_power: float
property normal_in_satellite_frame: ndarray
property satellite_faces: Sequence[SatelliteFace]
property surface: float
class fds.models.spacecraft.Spacecraft(platform_mass: float, drag_coefficient: float, reflectivity_coefficient: float, nametag: str = None)

Bases: RetrievableModel, ABC

FDS_TYPE: Models = 'SPACECRAFT'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property drag_coefficient: float
property platform_mass: float
property reflectivity_coefficient: float
classmethod retrieve_generic_by_id(client_id: str, nametag: str = None)
class fds.models.spacecraft.SpacecraftBox(battery: Battery, thruster: ThrusterElectrical | ThrusterChemical, solar_array: SolarArray, platform_mass: float, drag_coefficient: float, max_angular_acceleration: float, max_angular_velocity: float, length_x: float, length_y: float, length_z: float, reflectivity_coefficient: float = None, nametag: str = None)

Bases: Spacecraft, FromConfigBaseModel

FDS_TYPE: Models = 'SPACECRAFT_BOX'
class LengthContainer(x: float, y: float, z: float)

Bases: object

x: float
y: float
z: float
api_create_map(force_save: bool = False) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property battery: Battery
compute_maneuver_delta_v(initial_mass: float, final_mass: float) → float
destroy(destroy_subcomponents: bool = False)
property dry_mass: float
classmethod import_from_config_file(config_filepath: str | Path, battery: Battery = None, solar_array: SolarArray = None, thruster: ThrusterElectrical | ThrusterChemical = None) → Self
property length: LengthContainer
property max_angular_acceleration: float
property max_angular_velocity: float
property propellant_mass: float
property propulsion_kind: str
property solar_array: SolarArray
property thruster: ThrusterElectrical | ThrusterChemical
class fds.models.spacecraft.SpacecraftSphere(platform_mass: float, cross_section: float, drag_coefficient: float, reflectivity_coefficient: float, nametag: str = None)

Bases: Spacecraft, FromConfigBaseModel

FDS_TYPE: Models = 'SPACECRAFT_SPHERE'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property cross_section: float
class fds.models.spacecraft.Thruster(impulse: float, maximum_thrust_duration: float, propellant_mass: float, thrust: float, axis_in_satellite_frame: tuple[float, float, float], isp: float, wet_mass: float, warm_up_duration: float, nametag: str = None)

Bases: FromConfigBaseModel, RetrievableModel, ABC

FDS_TYPE: Models = 'THRUSTER'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property axis_in_satellite_frame: ndarray
property dry_mass: float
property impulse: float
property isp: float
property maximum_thrust_duration: float
property propellant_mass: float
classmethod retrieve_generic_by_id(client_id: str, nametag: str = None)
property thrust: float
property warm_up_duration: float
property wet_mass: float
class fds.models.spacecraft.ThrusterChemical(impulse: float, maximum_thrust_duration: float, propellant_mass: float, thrust: float, axis_in_satellite_frame: tuple[float, float, float], isp: float, wet_mass: float, warm_up_duration: float, nametag: str = None)

Bases: Thruster

FDS_TYPE: Models = 'THRUSTER_CHEMICAL'
class fds.models.spacecraft.ThrusterElectrical(impulse: float, maximum_thrust_duration: float, propellant_mass: float, thrust: float, axis_in_satellite_frame: tuple[float, float, float], isp: float, wet_mass: float, warm_up_duration: float, power: float, stand_by_power: float, warm_up_power: float, nametag: str = None)

Bases: Thruster

FDS_TYPE: Models = 'THRUSTER_ELECTRICAL'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property power: float
property stand_by_power: float
property warm_up_power: float

fds.models.strategy module

class fds.models.strategy.CustomArcPosition(reference: str | Reference, delta_mean_longitude_argument: float = None)

Bases: object

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

Bases: EnumFromInput

APOGEE_AND_PERIGEE = 'APOGEE_AND_PERIGEE'
ASCENDING_AND_DESCENDING_ANTINODES = 'ASCENDING_AND_DESCENDING_ANTINODES'
ASCENDING_AND_DESCENDING_NODES = 'ASCENDING_AND_DESCENDING_NODES'
property delta_mean_longitude_argument: float
property reference: Reference
to_microservice_format()
class fds.models.strategy.Strategy(thrust_arcs_position: str | ThrustArcPosition, thrust_arcs_number: str | ThrustArcNumber, number_of_thrust_orbits: int, number_of_rest_orbits: int, number_of_shift_orbits: int, stop_thrust_at_eclipse: bool, thrust_arc_initialisation_kind: str | ThrustArcInitialisationKind, orbital_duty_cycle: float = None, thrust_arc_duration: float = None, custom_thrust_arc_position: CustomArcPosition = None, thrust_arc_mean_longitude_argument: float = None)

Bases: ABC

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

Bases: EnumFromInput

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

Bases: EnumFromInput

ONE = 'ONE'
TWO = 'TWO'
to_int()
class ThrustArcPosition(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: EnumFromInput

APOGEE = 'APOGEE'
APOGEE_AND_PERIGEE = 'APOGEE_AND_PERIGEE'
ASCENDING_AND_DESCENDING_ANTINODES = 'ASCENDING_AND_DESCENDING_ANTINODES'
ASCENDING_AND_DESCENDING_NODES = 'ASCENDING_AND_DESCENDING_NODES'
ASCENDING_ANTINODE = 'ASCENDING_ANTINODE'
ASCENDING_NODE = 'ASCENDING_NODE'
CUSTOM = 'CUSTOM'
DESCENDING_ANTINODE = 'DESCENDING_ANTINODE'
DESCENDING_NODE = 'DESCENDING_NODE'
MEAN_LONGITUDE = 'MEAN_LONGITUDE'
PERIGEE = 'PERIGEE'
check_initialisation_kind(orbital_duty_cycle, thrust_arc_duration, thrust_arc_initialisation_kind) → tuple[ThrustArcInitialisationKind, float, float]
property custom_thrust_arc_position: CustomArcPosition
property number_of_rest_orbits: int
property number_of_shift_orbits: int
property number_of_thrust_orbits: int
property orbital_duty_cycle
property stop_thrust_at_eclipse: bool
property thrust_arc_duration
property thrust_arc_initialisation_kind: ThrustArcInitialisationKind
property thrust_arc_mean_longitude_argument: float
property thrust_arcs_number: ThrustArcNumber
property thrust_arcs_position: ThrustArcPosition

fds.models.telemetry module

class fds.models.telemetry.Telemetry(nametag: str)

Bases: FromConfigBaseModel, RetrievableModel, ABC

FDS_TYPE: Models = 'TELEMETRY'
classmethod api_retrieve_map(obj_data: dict) → dict
classmethod retrieve_generic_by_id(client_id: str, nametag: str = None)
class fds.models.telemetry.TelemetryGpsNmea(measurements: Sequence[Sequence[float]], dates: Sequence[str] | Sequence[datetime], standard_deviation_ground_speed: float, standard_deviation_latitude: float, standard_deviation_longitude: float, standard_deviation_altitude: float, nametag: str = None)

Bases: TelemetryNmea

FDS_TYPE: Models = 'TELEMETRY_GPS_NMEA'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property dates: Sequence[datetime]
property end_date: datetime
classmethod import_from_config_file(config_filepath: str | Path, measurements: Sequence[Sequence[float]] = None, dates: Sequence[str] = None)
property measurements: Sequence[Sequence[float]]
property start_date: datetime
class fds.models.telemetry.TelemetryGpsNmeaRaw(nmea_sentences: Sequence[str], standard_deviation_ground_speed: float, standard_deviation_latitude: float, standard_deviation_longitude: float, standard_deviation_altitude: float, nametag: str = None)

Bases: TelemetryNmea

FDS_TYPE: Models = 'TELEMETRY_GPS_NMEA_RAW'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property end_date: datetime
get_end_date() → datetime
get_start_date() → datetime
classmethod import_from_config_file(config_filepath: str | Path, nmea_sentences: Sequence[str] = None)
property nmea_sentences: list[str]
property start_date: datetime
class fds.models.telemetry.TelemetryGpsPv(dates: Sequence[str] | Sequence[datetime], frame: str | Frame, measurements: Sequence[Sequence[float]], standard_deviation_position: float, standard_deviation_velocity: float, nametag: str = None)

Bases: Telemetry

FDS_TYPE: Models = 'TELEMETRY_GPS_PV'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property dates: Sequence[datetime]
property end_date: datetime
property frame
classmethod import_from_config_file(config_filepath: str | Path, frame: Frame = None, dates: Sequence[str] = None, measurements: Sequence[Sequence[float]] = None)
property measurements: Sequence[Sequence[float]]
property standard_deviation: StandardDeviation
property start_date: datetime
class fds.models.telemetry.TelemetryGroundBased(dates: Sequence[datetime] | Sequence[str], measurements: Sequence[Sequence[float]], ground_station: GroundStation, nametag: str)

Bases: Telemetry, ABC

api_create_map(force_save: bool = False) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property dates: Sequence[datetime]
property end_date: datetime
property ground_station: GroundStation
property measurements: Sequence[Sequence[float]]
property start_date: datetime
class fds.models.telemetry.TelemetryNmea(standard_deviation_ground_speed: float, standard_deviation_latitude: float, standard_deviation_longitude: float, standard_deviation_altitude: float, nametag: str)

Bases: Telemetry, ABC

api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
property standard_deviation: StandardDeviation
class fds.models.telemetry.TelemetryOptical(dates: Sequence[datetime] | Sequence[str], measurements: Sequence[Sequence[float]], ground_station: GroundStation, standard_deviation_azimuth: float, standard_deviation_elevation: float, nametag: str = None)

Bases: TelemetryGroundBased

FDS_TYPE: Models = 'TELEMETRY_OPTICAL'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
classmethod import_from_config_file(config_filepath: str | Path, ground_station: GroundStation = None, dates: Sequence[str] = None, measurements: Sequence[Sequence[float]] = None)
property standard_deviation: StandardDeviation
class fds.models.telemetry.TelemetryRadar(dates: Sequence[datetime] | Sequence[str], measurements: Sequence[Sequence[float]], ground_station: GroundStation, two_way_measurement: bool, standard_deviation_range: float, standard_deviation_range_rate: float, standard_deviation_azimuth: float, standard_deviation_elevation: float, nametag: str = None)

Bases: TelemetryGroundBased

FDS_TYPE: Models = 'TELEMETRY_RADAR'
api_create_map(**kwargs) → dict
classmethod api_retrieve_map(obj_data: dict) → dict
classmethod import_from_config_file(config_filepath: str | Path, ground_station: GroundStation = None, dates: Sequence[str] = None, measurements: Sequence[Sequence[float]] = None)
property standard_deviation: StandardDeviation
property two_way_measurement: bool

fds.models.two_line_element module

class fds.models.two_line_element.TwoLineElement(line_1: str, line_2: str)

Bases: object

Represents the TLE (Two Line Elements) in spacetower Python SDK.

static check_line(line: str) → str

Checks if a TLE is correctly formed. If not, an exception is raised.

Parameters:

line – the line to check

Returns:

the checked line

Return type:

str

classmethod create_from_string_list(tles)

Creates a list of TwoLineElement objects from a given list of TLEs, given line by line.

Parameters:

tles – List of the TLE lines to parse. Each element of the line is expected to be one LINE of a TLE, hence a TLE is defined by two elements of the list.

Returns:

the parsed TwoLineElement objects

Return type:

List[TwoLineElement]

property date: datetime

The date of the TLE.

classmethod from_api_tle(tle: TLE)

Converts a TLE object (DTO used by spacetower API) to a TwoLineElement object (this class).

classmethod from_single_line(single_line_tle: str)

Creates a TLE object from a string containing both its lines.

Parameters:

single_line_tle (str) – Single line TLE

classmethod from_spacetrack(spacetrack_client, norad_cat_id: int, closest_date: datetime = datetime.datetime(2024, 7, 17, 8, 28, 15, 868567, tzinfo=datetime.timezone.utc), force_past: bool = False)

Fetches the TLE of a given object from spacetrack.

Parameters:

  • spacetrack_client (SpaceTrackClient) – SpaceTrackClient object from spacetrack package

  • norad_cat_id (int) – NORAD Catalogue ID

  • closest_date (datetime, optional) – Date limit, gets the TLE closest to this date. Defaults to None.

  • force_past (bool, optional) – If True, gets the TLE closest to the date but before it. Defaults to False.

Returns:

The found parsed TLEs.

Return type:

List[TwoLineElement]

property launch_data

Launch data (launch year, day, piece).

property line_1

First line of the TLE.

property line_2

Second line of the TLE.

classmethod select_from_tle_list(tle_list: list[Self], closest_date: datetime = datetime.datetime(2024, 7, 17, 8, 28, 15, 868555, tzinfo=datetime.timezone.utc), force_past: bool = False)

Selects the TLE in the list given that is the closest to the given date.

Parameters:

  • tle_list – The list of TLEs in which to search

  • closest_date – The date to search to closest TLE from. Default is current time.

  • force_past – If true, will only consider TLE prior to the given date. Default is false.

Returns:

The TLE closest to the given date.

Return type:

TwoLineElement

property single_line

Returns both lines of the TLE in one string.

property spacecraft_data

Spacecraft ID + object type.

to_api_tle() → TLE

Converts a TwoLineElement (this class) object to a TLE one (DTO used by spacetower API).

Module contents