Orbit Models

General Perturbations Orbit

pydantic model tatc.schemas.GeneralPerturbationsOrbit[source]

Orbit defined with general perturbations (GP) elements.

The orbit is propagated with SGP4, using whichever element’s epoch is closest to each time, or, if element_switch_times are given, the element between the switches before and after each time (see get_element_index). Optionally (with repeat_cycle and remove_drag), it is propagated as an orbit maintained against drag on a repeat ground track, which SGP4 does not model: if the orbit declares a repeat cycle or one is found (see GeneralPerturbationsElements.get_repeat_cycle), times before the first element’s epoch and after the last element’s epoch are instead propagated with that element maintained on its repeat ground track and repeated with its repeat cycle (see get_repeat_element). For an orbit with a single element, this applies to all times.

Show JSON schema
{
   "title": "GeneralPerturbationsOrbit",
   "description": "Orbit defined with general perturbations (GP) elements.\n\nThe orbit is propagated with SGP4, using whichever element's epoch is\nclosest to each time, or, if `element_switch_times` are given, the\nelement between the switches before and after each time (see\n`get_element_index`). Optionally (with `repeat_cycle` and `remove_drag`),\nit is propagated as an orbit maintained against drag on a repeat ground\ntrack, which SGP4 does not model: if the orbit declares a repeat cycle or\none is found (see `GeneralPerturbationsElements.get_repeat_cycle`), times\nbefore the first element's epoch and after the last element's epoch are\ninstead propagated with that element maintained on its repeat ground\ntrack and repeated with its repeat cycle (see `get_repeat_element`). For\nan orbit with a single element, this applies to all times.",
   "type": "object",
   "properties": {
      "type": {
         "const": "gp",
         "default": "gp",
         "description": "Orbit type discriminator.",
         "title": "Type",
         "type": "string"
      },
      "elements": {
         "description": "General perturbations elements.",
         "items": {
            "$ref": "#/$defs/GeneralPerturbationsElements"
         },
         "minItems": 1,
         "title": "Elements",
         "type": "array"
      },
      "remove_drag": {
         "default": false,
         "description": "True, to propagate the orbit without drag, as for an orbit maintained against drag: the elements' drag terms (B* and the derivatives of mean motion) are ignored, while the Earth's oblateness (and, for deep-space orbits, the Moon and Sun) still perturb the orbit.",
         "title": "Remove Drag",
         "type": "boolean"
      },
      "repeat_cycle": {
         "anyOf": [
            {
               "format": "duration",
               "type": "string"
            },
            {
               "const": "auto",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Repeat cycle with which the orbit is propagated as maintained on a repeat ground track: None (the default), to propagate the elements directly; `auto`, to use the repeat cycle found from the elements, if any (see `GeneralPerturbationsElements.get_repeat_cycle`); or a duration, to declare the repeat cycle (for example, 91 days, which is refined to the nearest whole number of nodal days, or for a sun-synchronous orbit mean solar days, of the elements maintained on the repeat ground track; see `GeneralPerturbationsElements.get_repeat_element`). A repeat cycle requires `remove_drag`, as the orbit is maintained against drag.",
         "title": "Repeat Cycle"
      },
      "element_switch_times": {
         "anyOf": [
            {
               "items": {
                  "format": "date-time",
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Times at which propagation switches from each element (sorted by epoch) to the next, one fewer than the elements, each between the epochs of the elements before and after it: element k is used from switch k - 1 until switch k. None (the default) switches midway between consecutive epochs, using the element whose epoch is closest to each time. Common switch times keep satellites whose elements are published at slightly different times (as in a formation) on elements of the same epochs; see `tatc.utils.align_element_switches`.",
         "title": "Element Switch Times"
      }
   },
   "$defs": {
      "GeneralPerturbationsElements": {
         "description": "General perturbations orbital elements for a satellite.",
         "properties": {
            "object_name": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Object name.",
               "title": "Object Name"
            },
            "epoch": {
               "description": "Epoch.",
               "format": "date-time",
               "title": "Epoch",
               "type": "string"
            },
            "mean_motion": {
               "description": "Mean motion (degrees/second).",
               "exclusiveMinimum": 0,
               "title": "Mean Motion",
               "type": "number"
            },
            "eccentricity": {
               "description": "Eccentricity.",
               "maximum": 1,
               "minimum": 0,
               "title": "Eccentricity",
               "type": "number"
            },
            "inclination": {
               "description": "Inclination (degrees).",
               "maximum": 180,
               "minimum": 0,
               "title": "Inclination",
               "type": "number"
            },
            "ra_of_asc_node": {
               "description": "Right ascension of ascending node (degrees).",
               "exclusiveMaximum": 360,
               "minimum": 0,
               "title": "Ra Of Asc Node",
               "type": "number"
            },
            "arg_of_pericenter": {
               "description": "Argument of pericenter (degrees).",
               "exclusiveMaximum": 360,
               "minimum": 0,
               "title": "Arg Of Pericenter",
               "type": "number"
            },
            "mean_anomaly": {
               "description": "Mean anomaly (degrees).",
               "exclusiveMaximum": 360,
               "minimum": 0,
               "title": "Mean Anomaly",
               "type": "number"
            },
            "norad_cat_id": {
               "default": 0,
               "description": "NORAD catalog identifier.",
               "minimum": 0,
               "title": "Norad Cat Id",
               "type": "integer"
            },
            "bstar": {
               "default": 0,
               "description": "Starred ballistic coefficient.",
               "title": "Bstar",
               "type": "number"
            },
            "mean_motion_dot": {
               "default": 0,
               "description": "First derivative of mean motion (degrees/second^2).",
               "title": "Mean Motion Dot",
               "type": "number"
            },
            "mean_motion_ddot": {
               "default": 0,
               "description": "Second derivative of mean motion (degrees/second^3).",
               "title": "Mean Motion Ddot",
               "type": "number"
            },
            "classification": {
               "default": "U",
               "description": "Classification type.",
               "title": "Classification",
               "type": "string"
            },
            "international_designator": {
               "default": "00000A",
               "description": "International designator.",
               "title": "International Designator",
               "type": "string"
            },
            "ephemeris_type": {
               "default": 0,
               "description": "Ephemeris type.",
               "title": "Ephemeris Type",
               "type": "integer"
            },
            "element_set_num": {
               "default": 0,
               "description": "Element set number.",
               "title": "Element Set Num",
               "type": "integer"
            },
            "revolution_num": {
               "default": 0,
               "description": "Revolution number at epoch.",
               "title": "Revolution Num",
               "type": "integer"
            }
         },
         "required": [
            "epoch",
            "mean_motion",
            "eccentricity",
            "inclination",
            "ra_of_asc_node",
            "arg_of_pericenter",
            "mean_anomaly"
         ],
         "title": "GeneralPerturbationsElements",
         "type": "object"
      }
   },
   "required": [
      "elements"
   ]
}

Fields:
  • element_switch_times (list[pydantic.types.AwareDatetime] | None)

  • elements (list[tatc.schemas.orbit.gp_elements.GeneralPerturbationsElements])

  • remove_drag (bool)

  • repeat_cycle (datetime.timedelta | Literal['auto'] | None)

  • type (Literal['gp'])

Validators:
  • _sort_elements_by_epoch » all fields

  • _validate_element_switch_times » all fields

  • _validate_repeat_cycle » all fields

field element_switch_times: list[AwareDatetime] | None = None

Times at which propagation switches from each element (sorted by epoch) to the next, one fewer than the elements, each between the epochs of the elements before and after it: element k is used from switch k - 1 until switch k. None (the default) switches midway between consecutive epochs, using the element whose epoch is closest to each time. Common switch times keep satellites whose elements are published at slightly different times (as in a formation) on elements of the same epochs; see tatc.utils.align_element_switches.

Validated by:
  • _sort_elements_by_epoch

  • _validate_element_switch_times

  • _validate_repeat_cycle

field elements: list[GeneralPerturbationsElements] [Required]

General perturbations elements.

Constraints:
  • min_length = 1

Validated by:
  • _sort_elements_by_epoch

  • _validate_element_switch_times

  • _validate_repeat_cycle

field remove_drag: bool = False

True, to propagate the orbit without drag, as for an orbit maintained against drag: the elements’ drag terms (B* and the derivatives of mean motion) are ignored, while the Earth’s oblateness (and, for deep-space orbits, the Moon and Sun) still perturb the orbit.

Validated by:
  • _sort_elements_by_epoch

  • _validate_element_switch_times

  • _validate_repeat_cycle

field repeat_cycle: RepeatCycle = None

Repeat cycle with which the orbit is propagated as maintained on a repeat ground track: None (the default), to propagate the elements directly; auto, to use the repeat cycle found from the elements, if any (see GeneralPerturbationsElements.get_repeat_cycle); or a duration, to declare the repeat cycle (for example, 91 days, which is refined to the nearest whole number of nodal days, or for a sun-synchronous orbit mean solar days, of the elements maintained on the repeat ground track; see GeneralPerturbationsElements.get_repeat_element). A repeat cycle requires remove_drag, as the orbit is maintained against drag.

Validated by:
  • _sort_elements_by_epoch

  • _validate_element_switch_times

  • _validate_repeat_cycle

field type: Literal['gp'] = 'gp'

Orbit type discriminator.

Validated by:
  • _sort_elements_by_epoch

  • _validate_element_switch_times

  • _validate_repeat_cycle

classmethod from_omm_csv(omm_csv: list[str], remove_drag: bool = False, repeat_cycle: Annotated[timedelta, FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=datetime.timedelta(0))])] | Literal['auto'] | None = None) → GeneralPerturbationsOrbit[source]

Creates a GP orbit from OMM CSV lines, using every data row (unlike GeneralPerturbationsElements.from_omm_csv, which only uses the first) to build one element per row.

Parameters:
  • omm_csv (list[str]) – The OMM CSV lines, including a header row.

  • remove_drag (bool) – True, to propagate the orbit without drag.

  • repeat_cycle (timedelta | Literal["auto"] | None) – The repeat cycle: None (direct propagation), “auto” (found from the elements), or declared; a repeat cycle requires remove_drag.

Returns:

the GP orbit

Return type:

GeneralPerturbationsOrbit

classmethod from_omm_json(omm_json: str, remove_drag: bool = False, repeat_cycle: Annotated[timedelta, FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=datetime.timedelta(0))])] | Literal['auto'] | None = None) → GeneralPerturbationsOrbit[source]

Creates a GP orbit from an OMM JSON string, using every entry (unlike GeneralPerturbationsElements.from_omm_json, which only uses the first) to build one element per entry.

Parameters:
  • omm_json (str) – The OMM JSON string, encoding a list of OMM records.

  • remove_drag (bool) – True, to propagate the orbit without drag.

  • repeat_cycle (timedelta | Literal["auto"] | None) – The repeat cycle: None (direct propagation), “auto” (found from the elements), or declared; a repeat cycle requires remove_drag.

Returns:

the GP orbit

Return type:

GeneralPerturbationsOrbit

classmethod from_tle(tle_lines: list[str], remove_drag: bool = False, repeat_cycle: Annotated[timedelta, FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=datetime.timedelta(0))])] | Literal['auto'] | None = None) → GeneralPerturbationsOrbit[source]

Creates a GP orbit from two line element (TLE) lines. Multiple TLEs (e.g. a history of element sets for one satellite) may be concatenated into a single flat list of lines, two per element set, to construct an orbit with multiple elements.

Parameters:
  • tle_lines (list[str]) – the two line element lines

  • remove_drag (bool) – True, to propagate the orbit without drag.

  • repeat_cycle (timedelta | Literal["auto"] | None) – The repeat cycle: None (direct propagation), “auto” (found from the elements), or declared; a repeat cycle requires remove_drag.

Returns:

the GP orbit

Return type:

GeneralPerturbationsOrbit

get_bstar(index: int = 0) → float[source]

Gets the starred ballistic coefficient of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the starred ballistic coefficient

Return type:

float

get_catalog_number(index: int = 0) → int[source]

Gets the NORAD catalog number of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the NORAD catalog number

Return type:

int

get_closest_element(at_times: None) → GeneralPerturbationsElements[source]
get_closest_element(at_times: datetime) → GeneralPerturbationsElements
get_closest_element(at_times: list[datetime]) → list[GeneralPerturbationsElements]
get_closest_element(at_times: ndarray[tuple[int, ...], dtype[datetime64]]) → list[GeneralPerturbationsElements]

Gets the closest element to specified time(s).

Parameters:

at_times (datetime | list[datetime] | npt.NDArray[np.datetime64] | None) – specified times, or None to always select the first element (index 0)

Returns:

closest element or elements

Return type:

GeneralPerturbationsElements | list[GeneralPerturbationsElements]

get_closest_element_index(at_times: None) → int[source]
get_closest_element_index(at_times: datetime) → int
get_closest_element_index(at_times: list[datetime]) → list[int]
get_closest_element_index(at_times: ndarray[tuple[int, ...], dtype[datetime64]]) → list[int]
get_closest_element_index(at_times: Time) → int | list[int]

Gets the closest element index to specified time(s), assuming elements are sorted by epoch (guaranteed for any orbit built through the constructor, since elements are sorted at construction time; see _sort_elements_by_epoch). A time exactly halfway between two epochs selects the later element.

Parameters:

at_times (datetime | list[datetime] | npt.NDArray[np.datetime64] | Time | None) – specified times (a Skyfield Time may be a scalar or an array), or None to always select the first element (index 0)

Returns:

closest element index (for a scalar time) or indices

Return type:

int | list[int]

get_derived_orbit(delta_mean_anomaly: float, delta_raan: float) → GeneralPerturbationsOrbit[source]

Gets a derived orbit with perturbations to the mean anomaly and right ascension of ascending node.

Parameters:
  • delta_mean_anomaly (float) – Delta mean anomaly (degrees).

  • delta_raan (float) – Delta right ascension of ascending node (degrees).

Returns:

the derived orbit

Return type:

GeneralPerturbationsOrbit

get_eccentricity(index: int = 0) → float[source]

Gets the eccentricity of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the eccentricity

Return type:

float

get_element_epochs() → list[datetime][source]

Gets the epochs of all elements in this orbit. The epochs are cached until the elements change (e.g. after appending or removing an element), but not if an element’s epoch is changed in place.

Returns:

the epoch times

Return type:

list[datetime]

get_element_index(at_times: None) → int[source]
get_element_index(at_times: datetime) → int
get_element_index(at_times: list[datetime]) → list[int]
get_element_index(at_times: ndarray[tuple[int, ...], dtype[datetime64]]) → list[int]
get_element_index(at_times: Time) → int | list[int]

Gets the index of the element that propagates the orbit at specified time(s): the element whose epoch is closest (see get_closest_element_index), or, if element_switch_times are given, the element between the switches before and after each time. A time exactly at a switch selects the later element.

Parameters:

at_times (datetime | list[datetime] | npt.NDArray[np.datetime64] | Time | None) – specified times (a Skyfield Time may be a scalar or an array), or None to always select the first element (index 0)

Returns:

element index (for a scalar time) or indices

Return type:

int | list[int]

get_epoch(index: int = 0) → datetime[source]

Gets the epoch of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the epoch

Return type:

datetime

get_geographic_position(times: datetime | list[datetime]) → GeographicPosition[source]

Gets the geodetic (WGS84) position of this orbit at given time(s), in an Earth-fixed frame (see get_orbit_track_at_time).

Parameters:

times (datetime | list[datetime]) – time(s) at which to compute geodetic position.

Returns:

the geodetic position

Return type:

skyfield.toposlib.GeographicPosition

get_geographic_position_at_time(t: Time) → GeographicPosition[source]

Gets the geodetic (WGS84) position of this orbit at given Skyfield time(s), in an Earth-fixed frame (see get_orbit_track_at_time).

Parameters:

t (skyfield.timelib.Time) – time(s) at which to compute geodetic position.

Returns:

the geodetic position

Return type:

skyfield.toposlib.GeographicPosition

get_inclination(index: int = 0) → float[source]

Gets the inclination of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the inclination (degrees)

Return type:

float

get_mean_altitude(index: int = 0) → float[source]

Gets the mean altitude of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the mean altitude (meters)

Return type:

float

get_mean_anomaly(index: int = 0) → float[source]

Gets the mean anomaly of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the mean anomaly (degrees)

Return type:

float

get_mean_motion(index: int = 0) → float[source]

Gets the mean motion of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the mean motion (degrees/second)

Return type:

float

get_mean_motion_ddot(index: int = 0) → float[source]

Gets the second derivative of mean motion of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the second derivative of mean motion (degrees/second^3)

Return type:

float

get_mean_motion_dot(index: int = 0) → float[source]

Gets the first derivative of mean motion of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the first derivative of mean motion (degrees/second^2)

Return type:

float

get_observation_events(point: Point | Point, start: datetime, end: datetime, min_elevation_angle: float) → tuple[Time, ndarray[tuple[int, ...], dtype[_ScalarType_co]]][source]

Gets the observation events (rise/culminate/set) of this orbit with respect to a ground point, between start and end, using Skyfield’s find_events with refined rise and set times.

Times are propagated as by get_orbit_track_at_time: the parts of the period before the first element’s epoch and after the last element’s epoch, if the element has a repeat cycle (and repeat_cycle is not None), with its repeat track (the events of the repeat cycle just before or after the epoch are computed once and repeated, shifted by whole repeat cycles, to cover the period), and the rest by partitioning the period by whichever element’s epoch is closest at each time (see partition_by_element_index). Where a pass spans a switch between these sources, whose orbit tracks differ slightly, the satellite may rise or set at the switch (see _get_boundary_events).

Parameters:
  • point (Point | shapely.geometry.Point) – Target location to observe: a TAT-C point or a shapely point (longitude, latitude, and optional elevation in meters).

  • start (datetime) – Start time of the observation period.

  • end (datetime) – End time of the observation period.

  • min_elevation_angle (float) – Minimum elevation angle (deg) to constrain observation.

Returns:

event times and their rise (0) / culminate (1) / set (2) codes

Return type:

tuple[skyfield.timelib.Time, numpy.ndarray]

get_orbit_period(index: int = 0) → timedelta[source]

Gets the approximate orbit period of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the orbit period

Return type:

timedelta

get_orbit_track(times: datetime | list[datetime]) → Geocentric[source]

Gets the orbit track of this orbit at given time(s), in the inertial (GCRS) frame (see get_orbit_track_at_time).

Parameters:

times (datetime | list[datetime]) – time(s) at which to compute position/velocity.

Returns:

the orbit track position/velocity

Return type:

skyfield.positionlib.Geocentric

get_orbit_track_at_time(t: Time) → Geocentric[source]

Gets the orbit track of this orbit at given Skyfield time(s), in the inertial (GCRS) frame.

Each time is propagated with whichever element’s epoch is closest to it, or the element between the element_switch_times around it (see get_element_index), so a vectorized t may draw from different elements for different entries. Unless repeat_cycle is None, times before the first element’s epoch and after the last element’s epoch are instead propagated with that element’s repeat track, if it has a repeat cycle: the satellite’s Earth-fixed position and velocity are those of the element maintained on its repeat ground track at the time shifted by whole repeat cycles to within one repeat cycle of its epoch (see get_repeat_element), expressed in the inertial frame at the time itself. For an orbit with a single element, this applies to all times.

Prefer this method over get_orbit_track when a Skyfield Time is already in hand (e.g. while iterating a Skyfield search such as skyfield.searchlib.find_discrete): converting a Time to Python datetime objects and back discards the per-instant quantities Skyfield caches on it (such as nutation angles).

Parameters:

t (skyfield.timelib.Time) – time(s) at which to compute position/velocity.

Returns:

the orbit track position/velocity

Return type:

skyfield.positionlib.Geocentric

get_perigee_argument(index: int = 0) → float[source]

Gets the argument of perigee of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the argument of perigee (degrees)

Return type:

float

get_repeat_cycle(max_delta_position: float | None = None, max_delta_velocity: float | None = None, max_search_duration: timedelta | None = None, consistency_threshold: timedelta | None = None, max_delta_semimajor_axis: float | None = None) → timedelta | None[source]

Gets the orbit’s repeat cycle, if every element agrees on one, or None if the orbit is propagated directly (repeat_cycle is None).

If the orbit declares a repeat cycle (repeat_cycle, for an orbit maintained on a repeat ground track without drag), it is refined to the whole number of nodal (or mean solar) days of the first element maintained on its repeat ground track (see get_repeat_element).

Otherwise, each element’s own repeat cycle is computed independently (see GeneralPerturbationsElements.get_repeat_cycle), since an orbit with multiple elements may span a significant maneuver (altitude change, plane change, etc.), in which case there may be no single repeat cycle that describes the whole orbit. A repeat cycle is reported only if every element has one and they all agree within consistency_threshold of each other (the most recent element’s is reported). Propagation does not depend on this agreement: times before the first and after the last element’s epoch use those elements’ own repeat cycles.

Parameters:
  • max_delta_position (float | None) – the maximum difference in position (m) allowed for a repeat.

  • max_delta_velocity (float | None) – the maximum difference in velocity (m/s) allowed for a repeat.

  • max_search_duration (timedelta | None) – the maximum period of time to search for repeats.

  • consistency_threshold (timedelta | None) – the maximum allowed spread between elements’ repeat cycles.

  • max_delta_semimajor_axis (float | None) – the maximum difference (m) between the semimajor axis and that of an exact repeat for a candidate repeat.

Returns:

the repeat cycle duration (if every element agrees on one)

Return type:

timedelta

get_repeat_element(index: int = 0) → GeneralPerturbationsElements | None[source]

Gets the specified element maintained on its repeat ground track (see GeneralPerturbationsElements.get_repeat_element): without drag, with its mean motion adjusted so that a whole number of orbits spans the repeat cycle exactly, and, for a sun-synchronous orbit, with its inclination adjusted so that its nodal day is a mean solar day. The first and last elements’ are used to propagate times before the first and after the last element’s epoch, repeated with the repeat cycle.

Parameters:

index (int) – the index of the element

Returns:

the maintained element, if

the orbit declares a repeat cycle or the element has one (and the orbit is not propagated directly)

Return type:

GeneralPerturbationsElements | None

get_right_ascension_ascending_node(index: int = 0) → float[source]

Gets the right ascension of ascending node of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the right ascension of ascending node (degrees)

Return type:

float

get_semimajor_axis(index: int = 0) → float[source]

Gets the semimajor axis of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the semimajor axis (meters)

Return type:

float

get_true_anomaly(index: int = 0) → float[source]

Gets the true anomaly of the specified element.

Parameters:

index (int) – the index of the element

Returns:

the true anomaly (degrees)

Return type:

float

partition_by_element_index(start: datetime, end: datetime) → tuple[list[datetime], list[int]][source]

Partitions the time range [start, end] into consecutive segments, each assigned the index of the element that propagates the orbit throughout that segment (see get_element_index). The element switches at element_switch_times or, by default, at the midpoint between consecutive elements’ epochs, so only switches strictly inside (start, end) become segment boundaries.

Parameters:
  • start (datetime) – Start time.

  • end (datetime) – End time.

Returns:

segment boundary times

(length N+1, including start and end) and the element index for each of the N segments between consecutive boundaries (length N).

Return type:

tuple[list[datetime], list[int]]

to_gp_orbit() → GeneralPerturbationsOrbit[source]

Converts this orbit to a general perturbations orbit representation, which it already is.

Returns:

this orbit, unchanged

Return type:

GeneralPerturbationsOrbit

Circular Orbit

pydantic model tatc.schemas.CircularOrbit[source]

Orbit specification using Keplerian elements for elliptical motion – circular motion case.

Show JSON schema
{
   "title": "CircularOrbit",
   "description": "Orbit specification using Keplerian elements for elliptical motion -- circular motion case.",
   "type": "object",
   "properties": {
      "true_anomaly": {
         "default": 0,
         "description": "True anomaly (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "True Anomaly",
         "type": "number"
      },
      "epoch": {
         "default": "2020-01-01T00:00:00Z",
         "description": "Timestamp (epoch) of the initial orbital state.",
         "format": "date-time",
         "title": "Epoch",
         "type": "string"
      },
      "mean_altitude": {
         "description": "Mean altitude (meters).",
         "minimum": 0,
         "title": "Mean Altitude",
         "type": "number"
      },
      "type": {
         "const": "circular",
         "default": "circular",
         "description": "Orbit type discriminator.",
         "title": "Type",
         "type": "string"
      },
      "inclination": {
         "default": 0,
         "description": "Inclination (degrees).",
         "exclusiveMaximum": 180,
         "minimum": 0,
         "title": "Inclination",
         "type": "number"
      },
      "right_ascension_ascending_node": {
         "default": 0,
         "description": "Right ascension of ascending node (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "Right Ascension Ascending Node",
         "type": "number"
      }
   },
   "required": [
      "mean_altitude"
   ]
}

Config:
  • populate_by_name: bool = True

Fields:
  • epoch (pydantic.types.AwareDatetime)

  • inclination (float)

  • mean_altitude (float)

  • right_ascension_ascending_node (float)

  • true_anomaly (float)

  • type (Literal['circular'])

Validators:
  • _validate_perigee » all fields

field epoch: AwareDatetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)

Timestamp (epoch) of the initial orbital state.

Validated by:
  • _validate_perigee

field inclination: float = 0

Inclination (degrees).

Constraints:
  • ge = 0

  • lt = 180

Validated by:
  • _validate_perigee

field mean_altitude: float [Required]

Mean altitude (meters).

Constraints:
  • ge = 0

Validated by:
  • _validate_perigee

field right_ascension_ascending_node: float = 0

Right ascension of ascending node (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_perigee

field true_anomaly: float = 0

True anomaly (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_perigee

field type: Literal['circular'] = 'circular'

Orbit type discriminator.

Validated by:
  • _validate_perigee

get_derived_orbit(delta_mean_anomaly: float, delta_raan: float) → CircularOrbit[source]

Gets a derived orbit with perturbations to the mean anomaly and right ascension of ascending node.

Parameters:
  • delta_mean_anomaly (float) – Delta mean anomaly (degrees).

  • delta_raan (float) – Delta right ascension of ascending node (degrees).

Returns:

the derived orbit

Return type:

CircularOrbit

get_eccentricity() → float

Gets the eccentricity, always 0 for a circular orbit.

Returns:

the eccentricity

Return type:

float

get_epoch() → datetime

Gets the timestamp (epoch) of the initial orbital state.

Returns:

the epoch

Return type:

datetime

get_inclination() → float[source]

Gets the inclination.

Returns:

the inclination (degrees)

Return type:

float

get_mean_altitude() → float

Gets the mean altitude.

Returns:

the mean altitude (meters)

Return type:

float

get_mean_anomaly() → float

Gets the mean anomaly (decimal degrees).

Returns:

the mean anomaly

Return type:

float

get_mean_motion() → float

Gets the mean motion (revolutions per day). Derived from the semimajor axis by default.

Returns:

the mean motion

Return type:

float

get_orbit_period() → timedelta

Gets the approximate orbit period. Derived from the semimajor axis by default. Subclasses for which the orbit period is instead the defining (independent) quantity – with semimajor axis derived from it, rather than the other way around – must override this method (and cannot rely on this default, which would be circular).

Returns:

the orbit period

Return type:

timedelta

get_perigee_argument() → float

Gets the perigee argument, always 0 for a circular orbit (there is no perigee to reference).

Returns:

the perigee argument

Return type:

float

get_right_ascension_ascending_node() → float[source]

Gets the right ascension of ascending node.

Returns:

the right ascension of ascending node (degrees)

Return type:

float

get_semimajor_axis() → float

Gets the semimajor axis.

Returns:

the semimajor axis (meters)

Return type:

float

get_true_anomaly() → float

Gets the true anomaly (decimal degrees).

Returns:

the true anomaly

Return type:

float

to_gp_orbit() → GeneralPerturbationsOrbit

Converts this orbit to a general perturbations orbit representation. Reuses a previously-computed conversion (cached on this orbit), since _compute_gp_orbit() can be expensive (e.g. requires SGP4 fitting). Subclasses must implement _compute_gp_orbit() rather than overriding this method directly.

Returns:

the general perturbations orbit

Return type:

GeneralPerturbationsOrbit

Sun-synchronous Orbit

pydantic model tatc.schemas.SunSynchronousOrbit[source]

Orbit defined by sun synchronous parameters.

Show JSON schema
{
   "title": "SunSynchronousOrbit",
   "description": "Orbit defined by sun synchronous parameters.",
   "type": "object",
   "properties": {
      "true_anomaly": {
         "default": 0,
         "description": "True anomaly (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "True Anomaly",
         "type": "number"
      },
      "epoch": {
         "default": "2020-01-01T00:00:00Z",
         "description": "Timestamp (epoch) of the initial orbital state.",
         "format": "date-time",
         "title": "Epoch",
         "type": "string"
      },
      "mean_altitude": {
         "description": "Mean altitude (meters).",
         "exclusiveMaximum": 5980991.228584941,
         "minimum": 0,
         "title": "Mean Altitude",
         "type": "number"
      },
      "type": {
         "const": "sso",
         "default": "sso",
         "description": "Orbit type discriminator.",
         "title": "Type",
         "type": "string"
      },
      "equator_crossing_time": {
         "description": "Equator crossing time (local solar time).",
         "format": "time",
         "title": "Equator Crossing Time",
         "type": "string"
      },
      "equator_crossing_ascending": {
         "default": true,
         "description": "True, if the equator crossing time is ascending (south-to-north).",
         "title": "Equator Crossing Ascending",
         "type": "boolean"
      }
   },
   "required": [
      "mean_altitude",
      "equator_crossing_time"
   ]
}

Config:
  • populate_by_name: bool = True

Fields:
  • epoch (pydantic.types.AwareDatetime)

  • equator_crossing_ascending (bool)

  • equator_crossing_time (datetime.time)

  • mean_altitude (float)

  • true_anomaly (float)

  • type (Literal['sso'])

Validators:
  • _validate_perigee » all fields

field epoch: AwareDatetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)

Timestamp (epoch) of the initial orbital state.

Validated by:
  • _validate_perigee

field equator_crossing_ascending: bool = True

True, if the equator crossing time is ascending (south-to-north).

Validated by:
  • _validate_perigee

field equator_crossing_time: time [Required]

Equator crossing time (local solar time).

Validated by:
  • _validate_perigee

field mean_altitude: float [Required]

Mean altitude (meters).

Constraints:
  • ge = 0

  • lt = 5980991.228584941

Validated by:
  • _validate_perigee

field true_anomaly: float = 0

True anomaly (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_perigee

field type: Literal['sso'] = 'sso'

Orbit type discriminator.

Validated by:
  • _validate_perigee

get_derived_orbit(delta_mean_anomaly: float, delta_raan: float) → SunSynchronousOrbit[source]

Gets a derived orbit with perturbations to the mean anomaly and right ascension of ascending node.

Parameters:
  • delta_mean_anomaly (float) – Delta mean anomaly (degrees).

  • delta_raan (float) – Delta right ascension of ascending node (degrees).

Returns:

the derived orbit

Return type:

SunSynchronousOrbit

get_eccentricity() → float

Gets the eccentricity, always 0 for a circular orbit.

Returns:

the eccentricity

Return type:

float

get_epoch() → datetime

Gets the timestamp (epoch) of the initial orbital state.

Returns:

the epoch

Return type:

datetime

get_inclination() → float[source]

Gets the inclination (decimal degrees) for which the orbit plane, as propagated by SGP4, precesses at the rate of the mean Sun (360 degrees per tropical year), so that the local mean solar time of the equator crossings stays constant. Starting from the classical J2 estimate (cos i = -(a / 12,352 km)^(7/2)), the inclination is refined with SGP4’s secular precession rate of the ascending node (which includes the Earth’s J2 and J4 oblateness terms) for the orbit’s general perturbations elements. The result is cached.

Returns:

the inclination

Return type:

float

get_mean_altitude() → float

Gets the mean altitude.

Returns:

the mean altitude (meters)

Return type:

float

get_mean_anomaly() → float

Gets the mean anomaly (decimal degrees).

Returns:

the mean anomaly

Return type:

float

get_mean_motion() → float

Gets the mean motion (revolutions per day). Derived from the semimajor axis by default.

Returns:

the mean motion

Return type:

float

get_orbit_period() → timedelta

Gets the approximate orbit period. Derived from the semimajor axis by default. Subclasses for which the orbit period is instead the defining (independent) quantity – with semimajor axis derived from it, rather than the other way around – must override this method (and cannot rely on this default, which would be circular).

Returns:

the orbit period

Return type:

timedelta

get_perigee_argument() → float

Gets the perigee argument, always 0 for a circular orbit (there is no perigee to reference).

Returns:

the perigee argument

Return type:

float

get_right_ascension_ascending_node() → float[source]

Gets the right ascension of ascending node (decimal degrees): the right ascension at which the ascending node’s local mean solar time, at the epoch, equals the equator crossing time (or, for a descending equator crossing time, the time 12 hours later). Local mean solar time at a longitude is the universal time plus the longitude (15 degrees per hour), so the node’s longitude at the epoch is 15 degrees per hour of the difference between its local time and the universal time, and its right ascension adds the Greenwich mean sidereal time (consistent with the frame of the general perturbations elements).

Returns:

the right ascension of ascending node

Return type:

float

get_semimajor_axis() → float

Gets the semimajor axis.

Returns:

the semimajor axis (meters)

Return type:

float

get_true_anomaly() → float

Gets the true anomaly (decimal degrees).

Returns:

the true anomaly

Return type:

float

to_gp_orbit() → GeneralPerturbationsOrbit

Converts this orbit to a general perturbations orbit representation. Reuses a previously-computed conversion (cached on this orbit), since _compute_gp_orbit() can be expensive (e.g. requires SGP4 fitting). Subclasses must implement _compute_gp_orbit() rather than overriding this method directly.

Returns:

the general perturbations orbit

Return type:

GeneralPerturbationsOrbit

Geosynchronous Orbit

pydantic model tatc.schemas.GeosynchronousOrbit[source]

Orbit defined by geosynchronous parameters: a fixed longitude rather than a right ascension of ascending node.

Show JSON schema
{
   "title": "GeosynchronousOrbit",
   "description": "Orbit defined by geosynchronous parameters: a fixed longitude rather\nthan a right ascension of ascending node.",
   "type": "object",
   "properties": {
      "true_anomaly": {
         "default": 0,
         "description": "True anomaly (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "True Anomaly",
         "type": "number"
      },
      "epoch": {
         "default": "2020-01-01T00:00:00Z",
         "description": "Timestamp (epoch) of the initial orbital state.",
         "format": "date-time",
         "title": "Epoch",
         "type": "string"
      },
      "mean_altitude": {
         "default": 35793160.85267107,
         "description": "Mean altitude (meters).",
         "minimum": 0,
         "title": "Mean Altitude",
         "type": "number"
      },
      "type": {
         "const": "geosynchronous",
         "default": "geosynchronous",
         "description": "Orbit type discriminator.",
         "title": "Type",
         "type": "string"
      },
      "inclination": {
         "default": 0,
         "description": "Inclination (degrees).",
         "exclusiveMaximum": 180,
         "minimum": 0,
         "title": "Inclination",
         "type": "number"
      },
      "longitude": {
         "description": "Longitude (decimal degrees) of the sub-satellite point in the WGS 84 coordinate system.",
         "maximum": 180,
         "minimum": -180,
         "title": "Longitude",
         "type": "number"
      }
   },
   "required": [
      "longitude"
   ]
}

Config:
  • populate_by_name: bool = True

Fields:
  • epoch (pydantic.types.AwareDatetime)

  • inclination (float)

  • longitude (float)

  • mean_altitude (float)

  • true_anomaly (float)

  • type (Literal['geosynchronous'])

Validators:
  • _validate_perigee » all fields

field epoch: AwareDatetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)

Timestamp (epoch) of the initial orbital state.

Validated by:
  • _validate_perigee

field inclination: float = 0

Inclination (degrees).

Constraints:
  • ge = 0

  • lt = 180

Validated by:
  • _validate_perigee

field longitude: float [Required]

Longitude (decimal degrees) of the sub-satellite point in the WGS 84 coordinate system.

Constraints:
  • ge = -180

  • le = 180

Validated by:
  • _validate_perigee

field mean_altitude: float = 35793160.85267107

Mean altitude (meters).

Constraints:
  • ge = 0

Validated by:
  • _validate_perigee

field true_anomaly: float = 0

True anomaly (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_perigee

field type: Literal['geosynchronous'] = 'geosynchronous'

Orbit type discriminator.

Validated by:
  • _validate_perigee

get_derived_orbit(delta_mean_anomaly: float, delta_raan: float) → GeosynchronousOrbit[source]

Gets a derived orbit with perturbations to the mean anomaly and longitude (equivalent, for a geosynchronous orbit, to a right ascension of ascending node perturbation, since both epoch and Earth’s rotation angle stay fixed).

Parameters:
  • delta_mean_anomaly (float) – Delta mean anomaly (degrees).

  • delta_raan (float) – Delta right ascension of ascending node (degrees).

Returns:

the derived orbit

Return type:

GeosynchronousOrbit

get_eccentricity() → float

Gets the eccentricity, always 0 for a circular orbit.

Returns:

the eccentricity

Return type:

float

get_epoch() → datetime

Gets the timestamp (epoch) of the initial orbital state.

Returns:

the epoch

Return type:

datetime

get_inclination() → float[source]

Gets the inclination.

Returns:

the inclination (degrees)

Return type:

float

get_mean_altitude() → float

Gets the mean altitude.

Returns:

the mean altitude (meters)

Return type:

float

get_mean_anomaly() → float

Gets the mean anomaly (decimal degrees).

Returns:

the mean anomaly

Return type:

float

get_mean_motion() → float

Gets the mean motion (revolutions per day). Derived from the semimajor axis by default.

Returns:

the mean motion

Return type:

float

get_orbit_period() → timedelta

Gets the approximate orbit period. Derived from the semimajor axis by default. Subclasses for which the orbit period is instead the defining (independent) quantity – with semimajor axis derived from it, rather than the other way around – must override this method (and cannot rely on this default, which would be circular).

Returns:

the orbit period

Return type:

timedelta

get_perigee_argument() → float

Gets the perigee argument, always 0 for a circular orbit (there is no perigee to reference).

Returns:

the perigee argument

Return type:

float

get_right_ascension_ascending_node() → float[source]

Gets the right ascension of ascending node, derived from this orbit’s fixed longitude and Earth’s rotation angle (Greenwich Apparent Sidereal Time) at epoch, since a geosynchronous satellite remains above a fixed Earth-relative longitude rather than a fixed inertial-frame RAAN. As with SunSynchronousOrbit’s equator-crossing-time convention, this is computed independently of true_anomaly.

Returns:

the right ascension of ascending node (degrees)

Return type:

float

get_semimajor_axis() → float

Gets the semimajor axis.

Returns:

the semimajor axis (meters)

Return type:

float

get_true_anomaly() → float

Gets the true anomaly (decimal degrees).

Returns:

the true anomaly

Return type:

float

to_gp_orbit() → GeneralPerturbationsOrbit

Converts this orbit to a general perturbations orbit representation. Reuses a previously-computed conversion (cached on this orbit), since _compute_gp_orbit() can be expensive (e.g. requires SGP4 fitting). Subclasses must implement _compute_gp_orbit() rather than overriding this method directly.

Returns:

the general perturbations orbit

Return type:

GeneralPerturbationsOrbit

Keplerian Orbit

pydantic model tatc.schemas.KeplerianOrbit[source]

Orbit specification using Keplerian elements for elliptical motion.

Show JSON schema
{
   "title": "KeplerianOrbit",
   "description": "Orbit specification using Keplerian elements for elliptical motion.",
   "type": "object",
   "properties": {
      "true_anomaly": {
         "default": 0,
         "description": "True anomaly (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "True Anomaly",
         "type": "number"
      },
      "epoch": {
         "default": "2020-01-01T00:00:00Z",
         "description": "Timestamp (epoch) of the initial orbital state.",
         "format": "date-time",
         "title": "Epoch",
         "type": "string"
      },
      "type": {
         "const": "keplerian",
         "default": "keplerian",
         "description": "Orbit type discriminator.",
         "title": "Type",
         "type": "string"
      },
      "semimajor_axis": {
         "description": "Semimajor axis (meters).",
         "exclusiveMinimum": 0,
         "title": "Semimajor Axis",
         "type": "number"
      },
      "inclination": {
         "default": 0,
         "description": "Inclination (degrees).",
         "exclusiveMaximum": 180,
         "minimum": 0,
         "title": "Inclination",
         "type": "number"
      },
      "right_ascension_ascending_node": {
         "default": 0,
         "description": "Right ascension of ascending node (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "Right Ascension Ascending Node",
         "type": "number"
      },
      "eccentricity": {
         "default": 0,
         "description": "Eccentricity.",
         "exclusiveMaximum": 1,
         "minimum": 0,
         "title": "Eccentricity",
         "type": "number"
      },
      "perigee_argument": {
         "default": 0,
         "description": "Perigee argument (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "Perigee Argument",
         "type": "number"
      }
   },
   "required": [
      "semimajor_axis"
   ]
}

Fields:
  • eccentricity (float)

  • epoch (pydantic.types.AwareDatetime)

  • inclination (float)

  • perigee_argument (float)

  • right_ascension_ascending_node (float)

  • semimajor_axis (float)

  • true_anomaly (float)

  • type (Literal['keplerian'])

Validators:
  • _validate_perigee » all fields

field eccentricity: float = 0

Eccentricity.

Constraints:
  • ge = 0

  • lt = 1

Validated by:
  • _validate_perigee

field epoch: AwareDatetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)

Timestamp (epoch) of the initial orbital state.

Validated by:
  • _validate_perigee

field inclination: float = 0

Inclination (degrees).

Constraints:
  • ge = 0

  • lt = 180

Validated by:
  • _validate_perigee

field perigee_argument: float = 0

Perigee argument (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_perigee

field right_ascension_ascending_node: float = 0

Right ascension of ascending node (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_perigee

field semimajor_axis: float [Required]

Semimajor axis (meters).

Constraints:
  • gt = 0

Validated by:
  • _validate_perigee

field true_anomaly: float = 0

True anomaly (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_perigee

field type: Literal['keplerian'] = 'keplerian'

Orbit type discriminator.

Validated by:
  • _validate_perigee

get_derived_orbit(delta_mean_anomaly: float, delta_raan: float) → KeplerianOrbit[source]

Gets a derived orbit with perturbations to the mean anomaly and right ascension of ascending node.

Parameters:
  • delta_mean_anomaly (float) – Delta mean anomaly (degrees).

  • delta_raan (float) – Delta right ascension of ascending node (degrees).

Returns:

the derived orbit

Return type:

KeplerianOrbit

get_eccentricity() → float[source]

Gets the eccentricity.

Returns:

the eccentricity

Return type:

float

get_epoch() → datetime

Gets the timestamp (epoch) of the initial orbital state.

Returns:

the epoch

Return type:

datetime

get_inclination() → float[source]

Gets the inclination.

Returns:

the inclination (degrees)

Return type:

float

get_mean_altitude() → float

Gets the mean altitude (meters) above the WGS 84 mean radius. Derived from the semimajor axis by default; subclasses that store altitude directly (e.g. circular orbits) may override this for efficiency.

Returns:

the mean altitude

Return type:

float

get_mean_anomaly() → float[source]

Gets the mean anomaly (decimal degrees).

Returns:

the mean anomaly

Return type:

float

get_mean_motion() → float

Gets the mean motion (revolutions per day). Derived from the semimajor axis by default.

Returns:

the mean motion

Return type:

float

get_orbit_period() → timedelta

Gets the approximate orbit period. Derived from the semimajor axis by default. Subclasses for which the orbit period is instead the defining (independent) quantity – with semimajor axis derived from it, rather than the other way around – must override this method (and cannot rely on this default, which would be circular).

Returns:

the orbit period

Return type:

timedelta

get_perigee_argument() → float[source]

Gets the perigee argument.

Returns:

the perigee argument (degrees)

Return type:

float

get_right_ascension_ascending_node() → float[source]

Gets the right ascension of ascending node.

Returns:

the right ascension of ascending node (degrees)

Return type:

float

get_semimajor_axis() → float[source]

Gets the semimajor axis.

Returns:

the semimajor axis (meters)

Return type:

float

get_true_anomaly() → float

Gets the true anomaly (decimal degrees).

Returns:

the true anomaly

Return type:

float

to_gp_orbit() → GeneralPerturbationsOrbit

Converts this orbit to a general perturbations orbit representation. Reuses a previously-computed conversion (cached on this orbit), since _compute_gp_orbit() can be expensive (e.g. requires SGP4 fitting). Subclasses must implement _compute_gp_orbit() rather than overriding this method directly.

Returns:

the general perturbations orbit

Return type:

GeneralPerturbationsOrbit

Molniya Orbit

pydantic model tatc.schemas.MolniyaOrbit[source]

Orbit defined by Molniya parameters.

Show JSON schema
{
   "title": "MolniyaOrbit",
   "description": "Orbit defined by Molniya parameters.",
   "type": "object",
   "properties": {
      "true_anomaly": {
         "default": 0,
         "description": "True anomaly (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "True Anomaly",
         "type": "number"
      },
      "epoch": {
         "default": "2020-01-01T00:00:00Z",
         "description": "Timestamp (epoch) of the initial orbital state.",
         "format": "date-time",
         "title": "Epoch",
         "type": "string"
      },
      "northern_coverage": {
         "default": true,
         "description": "True, if the orbit generates northern hemisphere coverage.",
         "title": "Northern Coverage",
         "type": "boolean"
      },
      "perigee_altitude": {
         "description": "Perigee altitude (meters).",
         "minimum": 0,
         "title": "Perigee Altitude",
         "type": "number"
      },
      "inclination": {
         "description": "Inclination (degrees). Defaults to the critical inclination (about 63.4 degrees), for which the argument of perigee is frozen; at other inclinations, the argument of perigee (and so the latitude of apogee) precesses as propagated.",
         "exclusiveMaximum": 180,
         "minimum": 0,
         "title": "Inclination",
         "type": "number"
      },
      "right_ascension_ascending_node": {
         "default": 0,
         "description": "Right ascension of ascending node (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "Right Ascension Ascending Node",
         "type": "number"
      },
      "type": {
         "const": "molniya",
         "default": "molniya",
         "description": "Orbit type discriminator.",
         "title": "Type",
         "type": "string"
      }
   },
   "required": [
      "perigee_altitude"
   ]
}

Fields:
  • epoch (pydantic.types.AwareDatetime)

  • inclination (float)

  • northern_coverage (bool)

  • perigee_altitude (float)

  • right_ascension_ascending_node (float)

  • true_anomaly (float)

  • type (Literal['molniya'])

Validators:
  • _validate_eccentricity » all fields

  • _validate_perigee » all fields

field epoch: AwareDatetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)

Timestamp (epoch) of the initial orbital state.

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field inclination: float = np.float64(63.43494882292201)

Inclination (degrees). Defaults to the critical inclination (about 63.4 degrees), for which the argument of perigee is frozen; at other inclinations, the argument of perigee (and so the latitude of apogee) precesses as propagated.

Constraints:
  • ge = 0

  • lt = 180

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field northern_coverage: bool = True

True, if the orbit generates northern hemisphere coverage.

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field perigee_altitude: float [Required]

Perigee altitude (meters).

Constraints:
  • ge = 0

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field right_ascension_ascending_node: float = 0

Right ascension of ascending node (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field true_anomaly: float = 0

True anomaly (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field type: Literal['molniya'] = 'molniya'

Orbit type discriminator.

Validated by:
  • _validate_eccentricity

  • _validate_perigee

classmethod from_apogee_longitude(apogee_longitude: float, perigee_altitude: float, inclination: float = np.float64(63.43494882292201), northern_coverage: bool = True, true_anomaly: float = 0, epoch: datetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)) → Self

Creates an orbit whose apogee is over a longitude, rather than at a right ascension of ascending node. The ground track of a Tundra (or quasi-zenith) orbit is a figure-8 centered on its apogee longitude (and a Molniya orbit’s apogees alternate between this longitude and the one 180 degrees away). The right ascension of ascending node is solved so that the first apogee at or after the epoch, as propagated (see get_apogee_longitude), is over the longitude.

Parameters:
  • apogee_longitude (float) – Longitude (degrees) of the apogee’s sub-satellite point in the WGS 84 coordinate system.

  • perigee_altitude (float) – Perigee altitude (meters).

  • inclination (float) – Inclination (degrees). Defaults to the critical inclination.

  • northern_coverage (bool) – True, if the orbit generates northern hemisphere coverage.

  • true_anomaly (float) – True anomaly (degrees) at epoch.

  • epoch (datetime) – Timestamp (epoch) of the initial orbital state.

Returns:

the orbit (of the class on which this method is called)

Return type:

Self

get_apogee_longitude() → float

Gets the longitude (degrees) of the sub-satellite point in the WGS 84 coordinate system at the first apogee at or after the epoch, as propagated by SGP4. For a Tundra (or quasi-zenith) orbit, the ground track is a figure-8 centered on this longitude.

Returns:

the apogee longitude (degrees, -180 to 180)

Return type:

float

get_derived_orbit(delta_mean_anomaly: float, delta_raan: float) → MolniyaOrbit[source]

Gets a derived orbit with perturbations to the mean anomaly and right ascension of ascending node.

Parameters:
  • delta_mean_anomaly (float) – Delta mean anomaly (degrees).

  • delta_raan (float) – Delta right ascension of ascending node (degrees).

Returns:

the derived orbit

Return type:

Molniya Orbit

get_eccentricity() → float

Gets the eccentricity (float between 0 and 1).

Returns:

the eccentricity

Return type:

float

get_epoch() → datetime

Gets the timestamp (epoch) of the initial orbital state.

Returns:

the epoch

Return type:

datetime

get_inclination() → float

Gets the inclination (degrees).

Returns:

the inclination

Return type:

float

get_mean_altitude() → float

Gets the mean altitude (meters) above the WGS 84 mean radius. Derived from the semimajor axis by default; subclasses that store altitude directly (e.g. circular orbits) may override this for efficiency.

Returns:

the mean altitude

Return type:

float

get_mean_anomaly() → float

Gets the mean anomaly (decimal degrees).

Returns:

the mean anomaly

Return type:

float

get_mean_motion() → float

Gets the mean motion (revolutions per day). Derived from the semimajor axis by default.

Returns:

the mean motion

Return type:

float

get_orbit_period() → timedelta[source]

Gets the orbit period, for which the ground track repeats twice daily and corrected for the Earth’s oblateness (see _compute_repeat_orbit_period).

Returns:

the orbit period

Return type:

timedelta

get_perigee_argument() → float

Gets the perigee argument (degrees), at the southernmost (for northern coverage) or northernmost point of the orbit.

Returns:

the perigee argument

Return type:

float

get_right_ascension_ascending_node() → float

Gets the right ascension of ascending node.

Returns:

the right ascension of ascending node (degrees)

Return type:

float

get_semimajor_axis() → float

Gets the semimajor axis (meters).

Returns:

the semimajor axis

Return type:

float

get_true_anomaly() → float

Gets the true anomaly (decimal degrees).

Returns:

the true anomaly

Return type:

float

to_gp_orbit() → GeneralPerturbationsOrbit

Converts this orbit to a general perturbations orbit representation. Reuses a previously-computed conversion (cached on this orbit), since _compute_gp_orbit() can be expensive (e.g. requires SGP4 fitting). Subclasses must implement _compute_gp_orbit() rather than overriding this method directly.

Returns:

the general perturbations orbit

Return type:

GeneralPerturbationsOrbit

Tundra Orbit

pydantic model tatc.schemas.TundraOrbit[source]

Orbit defined by Tundra parameters.

Show JSON schema
{
   "title": "TundraOrbit",
   "description": "Orbit defined by Tundra parameters.",
   "type": "object",
   "properties": {
      "true_anomaly": {
         "default": 0,
         "description": "True anomaly (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "True Anomaly",
         "type": "number"
      },
      "epoch": {
         "default": "2020-01-01T00:00:00Z",
         "description": "Timestamp (epoch) of the initial orbital state.",
         "format": "date-time",
         "title": "Epoch",
         "type": "string"
      },
      "northern_coverage": {
         "default": true,
         "description": "True, if the orbit generates northern hemisphere coverage.",
         "title": "Northern Coverage",
         "type": "boolean"
      },
      "perigee_altitude": {
         "description": "Perigee altitude (meters).",
         "minimum": 0,
         "title": "Perigee Altitude",
         "type": "number"
      },
      "inclination": {
         "description": "Inclination (degrees). Defaults to the critical inclination (about 63.4 degrees), for which the argument of perigee is frozen; at other inclinations, the argument of perigee (and so the latitude of apogee) precesses as propagated.",
         "exclusiveMaximum": 180,
         "minimum": 0,
         "title": "Inclination",
         "type": "number"
      },
      "right_ascension_ascending_node": {
         "default": 0,
         "description": "Right ascension of ascending node (degrees).",
         "exclusiveMaximum": 360,
         "minimum": 0,
         "title": "Right Ascension Ascending Node",
         "type": "number"
      },
      "type": {
         "const": "tundra",
         "default": "tundra",
         "description": "Orbit type discriminator.",
         "title": "Type",
         "type": "string"
      }
   },
   "required": [
      "perigee_altitude"
   ]
}

Fields:
  • epoch (pydantic.types.AwareDatetime)

  • inclination (float)

  • northern_coverage (bool)

  • perigee_altitude (float)

  • right_ascension_ascending_node (float)

  • true_anomaly (float)

  • type (Literal['tundra'])

Validators:
  • _validate_eccentricity » all fields

  • _validate_perigee » all fields

field epoch: AwareDatetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)

Timestamp (epoch) of the initial orbital state.

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field inclination: float = np.float64(63.43494882292201)

Inclination (degrees). Defaults to the critical inclination (about 63.4 degrees), for which the argument of perigee is frozen; at other inclinations, the argument of perigee (and so the latitude of apogee) precesses as propagated.

Constraints:
  • ge = 0

  • lt = 180

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field northern_coverage: bool = True

True, if the orbit generates northern hemisphere coverage.

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field perigee_altitude: float [Required]

Perigee altitude (meters).

Constraints:
  • ge = 0

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field right_ascension_ascending_node: float = 0

Right ascension of ascending node (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field true_anomaly: float = 0

True anomaly (degrees).

Constraints:
  • ge = 0

  • lt = 360

Validated by:
  • _validate_eccentricity

  • _validate_perigee

field type: Literal['tundra'] = 'tundra'

Orbit type discriminator.

Validated by:
  • _validate_eccentricity

  • _validate_perigee

classmethod from_apogee_longitude(apogee_longitude: float, perigee_altitude: float, inclination: float = np.float64(63.43494882292201), northern_coverage: bool = True, true_anomaly: float = 0, epoch: datetime = datetime.datetime(2020, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)) → Self

Creates an orbit whose apogee is over a longitude, rather than at a right ascension of ascending node. The ground track of a Tundra (or quasi-zenith) orbit is a figure-8 centered on its apogee longitude (and a Molniya orbit’s apogees alternate between this longitude and the one 180 degrees away). The right ascension of ascending node is solved so that the first apogee at or after the epoch, as propagated (see get_apogee_longitude), is over the longitude.

Parameters:
  • apogee_longitude (float) – Longitude (degrees) of the apogee’s sub-satellite point in the WGS 84 coordinate system.

  • perigee_altitude (float) – Perigee altitude (meters).

  • inclination (float) – Inclination (degrees). Defaults to the critical inclination.

  • northern_coverage (bool) – True, if the orbit generates northern hemisphere coverage.

  • true_anomaly (float) – True anomaly (degrees) at epoch.

  • epoch (datetime) – Timestamp (epoch) of the initial orbital state.

Returns:

the orbit (of the class on which this method is called)

Return type:

Self

get_apogee_longitude() → float

Gets the longitude (degrees) of the sub-satellite point in the WGS 84 coordinate system at the first apogee at or after the epoch, as propagated by SGP4. For a Tundra (or quasi-zenith) orbit, the ground track is a figure-8 centered on this longitude.

Returns:

the apogee longitude (degrees, -180 to 180)

Return type:

float

get_derived_orbit(delta_mean_anomaly: float, delta_raan: float) → TundraOrbit[source]

Gets a derived orbit with perturbations to the mean anomaly and right ascension of ascending node.

Parameters:
  • delta_mean_anomaly (float) – Delta mean anomaly (degrees).

  • delta_raan (float) – Delta right ascension of ascending node (degrees).

Returns:

the derived orbit

Return type:

Tundra Orbit

get_eccentricity() → float

Gets the eccentricity (float between 0 and 1).

Returns:

the eccentricity

Return type:

float

get_epoch() → datetime

Gets the timestamp (epoch) of the initial orbital state.

Returns:

the epoch

Return type:

datetime

get_inclination() → float

Gets the inclination (degrees).

Returns:

the inclination

Return type:

float

get_mean_altitude() → float

Gets the mean altitude (meters) above the WGS 84 mean radius. Derived from the semimajor axis by default; subclasses that store altitude directly (e.g. circular orbits) may override this for efficiency.

Returns:

the mean altitude

Return type:

float

get_mean_anomaly() → float

Gets the mean anomaly (decimal degrees).

Returns:

the mean anomaly

Return type:

float

get_mean_motion() → float

Gets the mean motion (revolutions per day). Derived from the semimajor axis by default.

Returns:

the mean motion

Return type:

float

get_orbit_period() → timedelta[source]

Gets the orbit period, for which the ground track repeats once daily and corrected for Earth’s J2 oblateness perturbation to the true rate of mean anomaly advance.

Returns:

the orbit period

Return type:

timedelta

get_perigee_argument() → float

Gets the perigee argument (degrees), at the southernmost (for northern coverage) or northernmost point of the orbit.

Returns:

the perigee argument

Return type:

float

get_right_ascension_ascending_node() → float

Gets the right ascension of ascending node.

Returns:

the right ascension of ascending node (degrees)

Return type:

float

get_semimajor_axis() → float

Gets the semimajor axis (meters).

Returns:

the semimajor axis

Return type:

float

get_true_anomaly() → float

Gets the true anomaly (decimal degrees).

Returns:

the true anomaly

Return type:

float

to_gp_orbit() → GeneralPerturbationsOrbit

Converts this orbit to a general perturbations orbit representation. Reuses a previously-computed conversion (cached on this orbit), since _compute_gp_orbit() can be expensive (e.g. requires SGP4 fitting). Subclasses must implement _compute_gp_orbit() rather than overriding this method directly.

Returns:

the general perturbations orbit

Return type:

GeneralPerturbationsOrbit