Library

module SatelliteToolboxOrbitDataMessages

Create, fetch, parse, and write CCSDS Orbit Data Messages (ODM).

The package currently supports Orbit Mean-Elements Messages (OMM) in the XML and KVN formats, including Navigation Data Messages (NDM) that wrap multiple messages in XML, and fetching OMMs from the Celestrak and Space-Track services.

abstract type AbstractOmmFetcher

Supertype of all Orbit Mean-Elements Message (OMM) fetchers.

Every supported service defines a concrete subtype (e.g. CelestrakOmmFetcher) together with methods for create_omm_fetcher and fetch_omms.

struct CelestrakOmmFetcher <: AbstractOmmFetcher

Fetcher that retrieves Orbit Mean-Elements Messages (OMM) from the Celestrak service.

Create an instance with create_omm_fetcher(CelestrakOmmFetcher) and query the service with fetch_omms. Celestrak provides publicly available data and does not require authentication.

Fields

• url::String: Address of the Celestrak endpoint used to perform the queries.

struct OdmFetchError <: Exception

Exception thrown when a request to an Orbit Data Message service fails.

Fields

• msg::String: Description of the request failure.
• url::Union{String, Nothing}: URL of the failed request, if available.
• status::Union{Int, Nothing}: HTTP status code of the failed request, if available.

OdmFetchError(msg::String; kwargs...) -> OdmFetchError

Create an OdmFetchError with the description msg.

Keywords

• url::Union{String, Nothing}: URL of the failed request, if available. (Default: nothing)
• status::Union{Int, Nothing}: HTTP status code of the failed request, if available. (Default: nothing)

struct OdmLoginError <: Exception

Exception thrown when the authentication with an Orbit Data Message service fails.

Fields

• msg::String: Description of the login failure.

struct OmmCovarianceMatrix

Covariance matrix of an Orbit Mean-Elements Message (OMM) as defined by the CCSDS 502.0-B-3 standard.

The matrix is symmetric, so only the lower-triangular 21 elements are stored. The elements follow the CCSDS naming convention where CX_X is the (1,1) entry, CY_X is the (2,1) entry, etc.

Fields

• comments::Vector{String}: Comments for the covariance matrix section. (Default: String[])
• cov_ref_frame::Union{String, Nothing}: Reference frame of the covariance matrix. (Default: nothing)
• cx_x::Float64: (1,1) element [km²].
• cy_x::Float64: (2,1) element [km²].
• cy_y::Float64: (2,2) element [km²].
• cz_x::Float64: (3,1) element [km²].
• cz_y::Float64: (3,2) element [km²].
• cz_z::Float64: (3,3) element [km²].
• cx_dot_x::Float64: (4,1) element [km²/s].
• cx_dot_y::Float64: (4,2) element [km²/s].
• cx_dot_z::Float64: (4,3) element [km²/s].
• cx_dot_x_dot::Float64: (4,4) element [km²/s²].
• cy_dot_x::Float64: (5,1) element [km²/s].
• cy_dot_y::Float64: (5,2) element [km²/s].
• cy_dot_z::Float64: (5,3) element [km²/s].
• cy_dot_x_dot::Float64: (5,4) element [km²/s²].
• cy_dot_y_dot::Float64: (5,5) element [km²/s²].
• cz_dot_x::Float64: (6,1) element [km²/s].
• cz_dot_y::Float64: (6,2) element [km²/s].
• cz_dot_z::Float64: (6,3) element [km²/s].
• cz_dot_x_dot::Float64: (6,4) element [km²/s²].
• cz_dot_y_dot::Float64: (6,5) element [km²/s²].
• cz_dot_z_dot::Float64: (6,6) element [km²/s²].

struct OmmData

Data section of an Orbit Mean-Elements Message (OMM) as defined by the CCSDS 502.0-B-3 standard, containing the mean Keplerian elements and the optional spacecraft parameters, TLE-related parameters, covariance matrix, and user-defined parameters.

Fields

• comments::Vector{String}: Comments for the data section. (Default: String[])
• mean_elements_comments::Vector{String}: Comments for the mean elements section. (Default: String[])
• epoch::NanoDate: Epoch of the mean Keplerian elements.
• semi_major_axis::Union{Float64, Nothing}: Semi-major axis [km]. (Default: nothing)
• mean_motion::Union{Float64, Nothing}: Mean motion [rev/day]. (Default: nothing)
• eccentricity::Float64: Eccentricity.
• inclination::Float64: Inclination [deg].
• raan::Float64: Right ascension of the ascending node [deg].
• arg_of_pericenter::Float64: Argument of pericenter [deg].
• mean_anomaly::Float64: Mean anomaly [deg].
• GM::Union{Float64, Nothing}: Gravitational coefficient [km³/s²]. (Default: nothing)
• spacecraft_parameters_comments::Vector{String}: Comments for the spacecraft parameters section. (Default: String[])
• mass::Union{Float64, Nothing}: Spacecraft mass [kg]. (Default: nothing)
• solar_rad_area::Union{Float64, Nothing}: Effective area for solar radiation pressure [m²]. (Default: nothing)
• solar_rad_coeff::Union{Float64, Nothing}: Solar radiation pressure coefficient. (Default: nothing)
• drag_area::Union{Float64, Nothing}: Effective area for atmospheric drag [m²]. (Default: nothing)
• drag_coeff::Union{Float64, Nothing}: Atmospheric drag coefficient. (Default: nothing)
• tle_parameters_comments::Vector{String}: Comments for the TLE-related parameters section. (Default: String[])
• ephemeris_type::Union{Int, Nothing}: Default ephemeris type associated with the TLE. (Default: nothing)
• classification_type::Union{Char, Nothing}: Classification type, e.g. 'U' for unclassified. (Default: nothing)
• norad_cat_id::Union{Int, Nothing}: NORAD catalog number. (Default: nothing)
• element_set_number::Union{Int, Nothing}: Element set number. (Default: nothing)
• rev_at_epoch::Union{Int, Nothing}: Revolution number at epoch. (Default: nothing)
• bstar::Union{Float64, Nothing}: SGP4 drag term (B*) [1/ER]. (Default: nothing)
• bterm::Union{Float64, Nothing}: Ballistic coefficient [m²/kg]. (Default: nothing)
• mean_motion_dot::Union{Float64, Nothing}: First time derivative of the mean motion [rev/day²]. (Default: nothing)
• mean_motion_ddot::Union{Float64, Nothing}: Second time derivative of the mean motion [rev/day³]. (Default: nothing)
• agom::Union{Float64, Nothing}: Solar radiation pressure coefficient AGOM [m²/kg]. (Default: nothing)
• covariance_matrix::Union{OmmCovarianceMatrix, Nothing}: Covariance matrix of the message. (Default: nothing)
• user_defined_parameters::Union{Nothing, Vector{Pair{String, String}}}: User-defined parameters as a vector of key => value pairs. (Default: nothing)

struct OmmHeader

Header section of an Orbit Mean-Elements Message (OMM) as defined by the CCSDS 502.0-B-3 standard.

Fields

• comments::Vector{String}: Comments for the header section. (Default: String[])
• classification::Union{String, Nothing}: Message classification. (Default: nothing)
• creation_date::Union{NanoDate, Nothing}: Message creation date. It can only be nothing for messages parsed leniently, which cannot be written until a creation date is set. (Default: nothing)
• originator::String: Message originator.
• message_id::Union{String, Nothing}: Unique message identifier. (Default: nothing)

struct OmmMetadata

Metadata section of an Orbit Mean-Elements Message (OMM) as defined by the CCSDS 502.0-B-3 standard.

Fields

• comments::Vector{String}: Comments for the metadata section. (Default: String[])
• object_name::String: Spacecraft name.
• object_id::String: International designator, usually in the format YYYY-NNNP.
• center_name::String: Origin of the reference frame.
• ref_frame::String: Reference frame of the mean elements.
• ref_frame_epoch::Union{NanoDate, Nothing}: Epoch of the reference frame, if it is not intrinsic to its definition. (Default: nothing)
• time_system::String: Time system used for the message.
• mean_element_theory::String: Theory describing the mean elements, e.g. "SGP4".

abstract type OrbitDataMessage

Supertype of all Orbit Data Messages (ODM) defined by the CCSDS 502.0-B-3 standard.

Every concrete message type supported by this package (for example, OrbitMeanElementsMessage) is a subtype of OrbitDataMessage. Functions that handle generic messages, such as parse_odm and write_odm, operate on this abstract type.

struct OrbitMeanElementsMessage <: OrbitDataMessage

Orbit Mean-Elements Message (OMM) as defined by the CCSDS 502.0-B-3 standard.

The structure contains the three sections defined by the standard: a header, a metadata, and a data section. The individual fields can be accessed directly through these sections, for example omm.metadata.object_name or omm.data.epoch.

To create a message, use the keyword constructor OrbitMeanElementsMessage(; kwargs...), which assembles all the internal sections automatically.

Fields

• version::VersionNumber: OMM format version (2.0 or 3.0).
• header::OmmHeader: Message header (creation date, originator, etc.).
• metadata::OmmMetadata: Message metadata (object identification, reference frame, etc.).
• data::OmmData: Mean elements data (mean Keplerian elements, TLE parameters, etc.).

OrbitMeanElementsMessage(
    omm::OrbitMeanElementsMessage;
    kwargs...
) -> OrbitMeanElementsMessage

Create a copy of omm, overriding the fields specified in kwargs.... Any keyword accepted by the keyword constructor can be used; the remaining fields, including the message version, are copied from omm.

OrbitMeanElementsMessage(; kwargs...) -> OrbitMeanElementsMessage

Create an Orbit Mean-Elements Message (OMM) from the keyword arguments kwargs....

This constructor assembles the internal header, metadata, and data sections defined by the CCSDS 502.0-B-3 standard, returning a message with version 3.0 unless version is provided. The required keywords are the message creation date, the originator, the object identification, the reference frame and time system, and the mean Keplerian elements. All angular quantities (inclination, raan, arg_of_pericenter, and mean_anomaly) are expressed in degrees. An ArgumentError is thrown if the keyword combination violates the message rules (see the extended help).

The date keywords (creation_date, epoch, and ref_frame_epoch) must be provided as NanoDate objects so that the sub-second precision is preserved.

Keywords

• version::VersionNumber: OMM format version (v"2.0" or v"3.0"). The version-specific field rules are enforced by the parsers, and the writers always emit version 3.0. (Default: v"3.0")
• header_comments::Vector{String}: Comments for the header section. (Default: String[])
• classification::Union{String, Nothing}: Message classification. (Default: nothing)
• creation_date::Union{NanoDate, Nothing}: Message creation date (required). It can only be nothing for messages parsed leniently (see strict in parse_omm), which cannot be written until a creation date is set.
• originator::String: Message originator (required).
• message_id::Union{String, Nothing}: Unique message identifier. (Default: nothing)
• metadata_comments::Vector{String}: Comments for the metadata section. (Default: String[])
• object_name::String: Spacecraft name (required).
• object_id::String: International designator, usually in the format YYYY-NNNP (required).
• center_name::String: Origin of the reference frame (required).
• ref_frame::String: Reference frame of the mean elements (required).
• ref_frame_epoch::Union{NanoDate, Nothing}: Epoch of the reference frame, if it is not intrinsic to its definition. (Default: nothing)
• time_system::String: Time system used for the message (required).
• mean_element_theory::String: Theory describing the mean elements, e.g. "SGP4" (required).
• data_comments::Vector{String}: Comments for the data section. (Default: String[])
• mean_elements_comments::Vector{String}: Comments for the mean elements section. (Default: String[])
• epoch::NanoDate: Epoch of the mean Keplerian elements (required).
• semi_major_axis::Union{Float64, Nothing}: Semi-major axis [km]. Either this keyword or mean_motion must be provided. (Default: nothing)
• mean_motion::Union{Float64, Nothing}: Mean motion [rev/day]. Either this keyword or semi_major_axis must be provided. (Default: nothing)
• eccentricity::Float64: Eccentricity (required).
• inclination::Float64: Inclination [deg] (required).
• raan::Float64: Right ascension of the ascending node [deg] (required).
• arg_of_pericenter::Float64: Argument of pericenter [deg] (required).
• mean_anomaly::Float64: Mean anomaly [deg] (required).
• GM::Union{Float64, Nothing}: Gravitational coefficient [km³/s²]. (Default: nothing)
• spacecraft_parameters_comments::Vector{String}: Comments for the spacecraft parameters section. (Default: String[])
• mass::Union{Float64, Nothing}: Spacecraft mass [kg]. (Default: nothing)
• solar_rad_area::Union{Float64, Nothing}: Effective area for solar radiation pressure [m²]. (Default: nothing)
• solar_rad_coeff::Union{Float64, Nothing}: Solar radiation pressure coefficient. (Default: nothing)
• drag_area::Union{Float64, Nothing}: Effective area for atmospheric drag [m²]. (Default: nothing)
• drag_coeff::Union{Float64, Nothing}: Atmospheric drag coefficient. (Default: nothing)
• tle_parameters_comments::Vector{String}: Comments for the TLE-related parameters section. (Default: String[])
• ephemeris_type::Union{Int, Nothing}: Default ephemeris type associated with the TLE. (Default: nothing)
• classification_type::Union{Char, Nothing}: Classification type, e.g. 'U' for unclassified. (Default: nothing)
• norad_cat_id::Union{Int, Nothing}: NORAD catalog number. (Default: nothing)
• element_set_number::Union{Int, Nothing}: Element set number. (Default: nothing)
• rev_at_epoch::Union{Int, Nothing}: Revolution number at epoch. (Default: nothing)
• bstar::Union{Float64, Nothing}: SGP4 drag term (B*) [1/ER]. (Default: nothing)
• bterm::Union{Float64, Nothing}: Ballistic coefficient [m²/kg]. (Default: nothing)
• mean_motion_dot::Union{Float64, Nothing}: First time derivative of the mean motion [rev/day²]. (Default: nothing)
• mean_motion_ddot::Union{Float64, Nothing}: Second time derivative of the mean motion [rev/day³]. (Default: nothing)
• agom::Union{Float64, Nothing}: Solar radiation pressure coefficient AGOM [m²/kg]. (Default: nothing)
• covariance_matrix::Union{OmmCovarianceMatrix, Nothing}: Covariance matrix of the message. (Default: nothing)
• user_defined_parameters::Union{Nothing, Vector{Pair{String, String}}}: User-defined parameters as a vector of key => value pairs. (Default: nothing)

Extended help

Throws

• ArgumentError: If version is not v"2.0" or v"3.0".
• ArgumentError: If not exactly one of semi_major_axis and mean_motion is provided.
• ArgumentError: If the TLE-related parameters section is present (any of its keywords or comments is set) and not exactly one of bstar and bterm is provided, or mean_motion_dot is missing, or not exactly one of mean_motion_ddot and agom is provided.

struct SpacetrackOmmFetcher <: AbstractOmmFetcher

Fetcher that retrieves Orbit Mean-Elements Messages (OMM) from the Space-Track service.

Create an instance with create_omm_fetcher(SpacetrackOmmFetcher) and query the service with fetch_omms. Space-Track requires a (free) registered account; the login cookie is cached locally and reused until it expires.

Fields

• username::String: Space-Track username used to authenticate the requests.
• cookiejar::HTTP.CookieJar: Cookie jar holding the authentication cookie for the session.

_field_name_width(fields::AbstractVector{NTuple{3, String}}) -> Int

Compute the maximum width of the field names in fields.

_format_value(value) -> String

Convert value to its display String. This function is the single formatting seam for field values, allowing consistent formatting across every message.

The default method uses string, which for AbstractFloat yields the shortest representation that round-trips exactly (e.g., 7134.084, 4.47e-6), avoiding any loss of precision in the orbital elements.

_kvn__parse_keyword(
    line::AbstractString
) -> Union{Nothing, Tuple{AbstractString, AbstractString}}

Parse a KVN line and return the keyword and value as a Tuple of SubStrings, or nothing if the line is neither a keyword nor a comment line.

A comment line yields the synthesized keyword "COMMENT" with the comment text as the value. The value of a keyword line is returned verbatim, including any trailing [unit] annotation, which can be removed with _kvn__strip_unit.

_kvn__strip_unit(value::AbstractString) -> AbstractString

Return value without its trailing [unit] annotation, or value unchanged if it has none.

_kvn_omm__check_user_defined_keys(omm::OrbitMeanElementsMessage) -> Nothing

Check if every user-defined parameter name in omm matches the KVN keyword grammar (uppercase letters, digits, and underscores), throwing an ArgumentError otherwise. Any other name would produce a KVN output that cannot be parsed back.

_kvn_omm__parse(str::AbstractString) -> NamedTuple

Parse the first Orbit Mean-Elements Message (OMM) in the KVN input str, returning the container (; version, header_fields, metadata_fields, data_fields) with the raw field values. The version and the mandatory fields are checked afterwards by _omm_assemble.

_kvn_omm__write(io::IO, omm::OrbitMeanElementsMessage) -> Nothing
_kvn_omm__write(io::IO, vomm::AbstractVector{OrbitMeanElementsMessage}) -> Nothing

Write the given omm (or the set of messages in vomm) to the provided io stream in KVN format. A set of messages is written sequentially, delimited by their CCSDS_OMM_VERS keywords as expected by parse_omms.

The written version is always 3.0, regardless of the version stored in the messages, matching the behavior of the XML writer.

_kvn_omm__write_element(
    io::IO,
    keyword::AbstractString,
    value::Any,
    keyword_width::Int,
    unit::Union{Nothing, String} = nothing
) -> Nothing

Write the line keyword = value to the provided io stream in KVN format. The keyword is padded to keyword_width characters to align the values, and the value is rendered with _ndm_render_value. If a unit is provided, it is appended in square brackets, padding the value to _KVN_OMM__VALUE_WIDTH characters to align the units.

_kvn_omm__write_section(
    io::IO,
    section::Union{OmmHeader, OmmMetadata, OmmData, OmmCovarianceMatrix},
    mapping::Vector{Pair{String, Symbol}},
    comments::Vector{String},
    keyword_width::Int,
    section_name::String
) -> Bool

Write the fields of the OMM section to the provided io stream in KVN format. The written keywords and their fields are given by mapping, whose order is preserved in the output, and the section comments are written before the fields. The keywords are padded to keyword_width characters to align the values, and section_name names the section in warnings.

Fields whose value is nothing are omitted from the output. If every field is nothing, the section comments are dropped with a warning: the flat KVN format has no section delimiters, so the parser would attribute such comments to the next section.

Returns

• Bool: true if any line was written, false otherwise.

_kvn_omms__parse(str::AbstractString, strict::Bool) -> Vector{OrbitMeanElementsMessage}

Parse a set of Orbit Mean-Elements Messages (OMM) in the KVN input str and return the parsed messages. The strict flag selects whether the mandatory fields are validated strictly (see _omm_check_mandatory_fields).

_ndm_render_value(value::String) -> String
_ndm_render_value(value::NanoDate) -> String
_ndm_render_value(value::Any) -> String

Render the given value as a string suitable for NDM outputs (e.g. XML or KVN).

NanoDate values are rendered with nanosecond precision (yyyy-mm-ddTHH:MM:SS.sssssssss), whereas the other types use their default string representation. Notice that, for AbstractFloat, this representation is the shortest one that round-trips exactly, avoiding any loss of precision.

_odm_check_writable(odm::OrbitDataMessage) -> Nothing

Check if odm contains all fields required for writing, throwing an ArgumentError otherwise. The check is dispatched to the corresponding message type; unsupported message types are accepted here and skipped with a warning by the format-specific writer.

This function is format-agnostic so that every supported file type is validated by the same rules.

_omm_assemble(
    version::Union{Nothing, Float64},
    header_fields::Dict{Symbol, Any},
    metadata_fields::Dict{Symbol, Any},
    data_fields::Dict{Symbol, Any},
    strict::Bool
) -> OrbitMeanElementsMessage

Assemble an Orbit Mean-Elements Message (OMM) from the information returned by a format-specific parser: the format version (nothing if it is absent in the input) and the dictionaries header_fields, metadata_fields, and data_fields with the raw field values of the corresponding sections. The dictionaries only contain the fields that are present in the input. The strict flag selects whether the mandatory fields are validated strictly (see _omm_check_mandatory_fields).

The version and the mandatory fields are validated before the message is created. Then, each dictionary is converted to keyword arguments of the corresponding OMM section constructor. The covariance matrix, if present, must be stored in data_fields[:covariance_matrix] as a Dict{Symbol, Any} with its raw element values.

_omm_assemble(parsed_omm::NamedTuple, strict::Bool) -> OrbitMeanElementsMessage

Assemble an OMM from the container (; version, header_fields, metadata_fields, data_fields) holding the same information.

_omm_check_mandatory_fields(
    version::VersionNumber,
    header_fields::Dict{Symbol, Any},
    metadata_fields::Dict{Symbol, Any},
    data_fields::Dict{Symbol, Any},
    strict::Bool
) -> Nothing

Check if all mandatory fields of an Orbit Mean-Elements Message (OMM) with version (2.0 or 3.0) are present in the dictionaries header_fields, metadata_fields, and data_fields returned by a format-specific parser, throwing an ArgumentError otherwise. A field whose value is nothing or an empty string is treated as absent. If strict is false, the CREATION_DATE presence requirement is relaxed, allowing real-world files with an omitted creation date to be processed.

This function is format-agnostic so that every supported file type is validated by the same rules.

_omm_check_writable(omm::OrbitMeanElementsMessage, file_type::Symbol) -> Nothing

Check if omm contains all fields required to write an OMM 3.0 output as file_type, throwing an ArgumentError otherwise.

The format-independent rules are shared by every file type, whereas file_type selects the additional format-specific rules (currently, the KVN keyword grammar for the user-defined parameter names).

_omm_field_type(field::Symbol) -> DataType

Return the type of the OMM field as defined in _OMM_FIELD_TYPE, defaulting to Float64.

_omm_field_unit(field::Symbol) -> Union{Nothing, String}

Return the physical unit of the OMM field as defined in _OMM_FIELD_UNIT, or nothing if the field is dimensionless.

_omm_is_absent(value::Any) -> Bool

Check if the raw field value returned by a format-specific parser must be treated as absent, i.e. it is nothing or an empty string.

_omm_parse_field(
    ::Type{T},
    value::AbstractString,
    keyword::AbstractString
) -> Union{Nothing, T}

Parse the raw value of the OMM field identified by the CCSDS keyword as type T, throwing an ArgumentError that names the keyword if the value is invalid. The NanoDate method returns nothing when value is empty or contains only whitespace.

_omm_parse_field_value(
    field::Symbol,
    value::AbstractString,
    keyword::AbstractString
) -> Any

Parse the raw value of the OMM field identified by the CCSDS keyword using the field type defined in _OMM_FIELD_TYPE.

The explicit branch on the field type lets inference split the call to _omm_parse_field, avoiding a dynamic dispatch for every parsed field.

_parse_ndm_date(str::AbstractString) -> Union{Nothing, NanoDate}

Parse an NDM date/time string into a NanoDate, returning nothing if str is empty or contains only whitespace. An ArgumentError is thrown if the date is malformed or the ordinal day is outside the year.

The CCSDS 502.0-B-3 standard allows two formats for absolute time tags and epochs:

• YYYY-MM-DDThh:mm:ss[.d→d][Z] (calendar date)
• YYYY-DDDThh:mm:ss[.d→d][Z] (ordinal day-of-year)

NanoDate natively handles the calendar form (including the optional trailing Z), so this function only needs to convert the ordinal form before delegating to NanoDate.

_parse_omm_object_id(object_id::AbstractString) -> Union{Nothing, NamedTuple}

Parse an OMM OBJECT_ID in the international designator format YYYY-NNN or YYYY-NNNP, returning the container (; year, launch_number, piece) with the matched components, or nothing if object_id does not follow the format. Surrounding whitespace is ignored, and the piece may be empty.

_print_fields(
    io::IO,
    fields::AbstractVector{NTuple{3, String}},
    rail::String
) -> Nothing

Print to io the fields, each preceded by rail (the tree rails drawn before the field name). The field names are left-aligned to the widest name in fields.

_print_node(
    io::IO,
    name::String,
    rail::String,
    connector::String,
    face::Symbol
) -> Nothing

Print to io a tree node opening with the given name styled with face, preceded by rail (the ancestor tree rails) and connector (e.g., "├─ ", "└─ ", or "" for a top-level heading).

_push_output!(
    vector::AbstractVector{NTuple{3, String}},
    name::String,
    value::Any,
    unit::String
) -> Nothing

Push to vector the field row (name, value, unit) if value is not nothing. The value is converted to a string using _format_value.

Passing the row components as positional arguments lets the compiler specialize on the value type, avoiding the tuple conversion and boxing of a Tuple{String, Any, String} argument.

_register_faces() -> Nothing

Register the named StyledStrings faces used to render the orbit data messages. This function is idempotent: faces already registered are not overwritten.

The registered faces are:

• :satellitetoolbox_odm_title: Structure name (e.g., OrbitMeanElementsMessage:).
• :satellitetoolbox_odm_section: Top-level sections (Header, Metadata, and Data).
• :satellitetoolbox_odm_node: Tree nodes (the data subsection titles).
• :satellitetoolbox_odm_tree: Tree rails and connectors.
• :satellitetoolbox_odm_field: Field names.
• :satellitetoolbox_odm_unit: Field units.

_render_field(
    field_name::String,
    field_value::String,
    unit::String,
    name_width::Int
) -> AbstractString

Render a single field row <name> : <value> <unit>, left-aligning field_name to name_width. The unit is appended inline separated by a space, except for the degree unit "°", which hugs the value. The returned string has no trailing whitespace.

_spacetrack__cookie_expire_date(cookiejar::HTTP.CookieJar) -> Union{DateTime, Nothing}

Get the expiration date of the Space-Track cookie in the cookiejar. If the cookie is not found, it returns nothing.

_spacetrack__is_cookie_valid(cookiejar::Union{HTTP.CookieJar, Nothing}) -> Bool

Check if the Space-Track cookie in the cookiejar is valid. To load the cookiejar, use the function _spacetrack__load_cookiejar.

_spacetrack__load_cookiejar(username::String) -> Union{HTTP.CookieJar, Nothing}

Load the cookie jar for the given username from the scratch space. If the cookie file does not exist or could not be loaded, it returns nothing.

_spacetrack__login(username::String, password::Base.SecretBuffer) -> HTTP.CookieJar

Login to the Space-Track service using the provided username and password. The password is a Base.SecretBuffer; its plaintext is materialized only inside this function and shredded immediately after the request body is built. If the login is successful, it saves the cookies to the scratch space and returns the cookie jar. Otherwise, it throws an OdmLoginError.

_spacetrack__purge_cookiejar(username::String) -> Nothing

Purge the cookiejar file for the given username from the scratch space.

_spacetrack__save_cookiejar(cookiejar::HTTP.CookieJar, username::String) -> Nothing

Save the cookiejar to the scratch space for the given username.

_xml_add_tag!(parent::XML.Node, tag::String, value::Any) -> Nothing

Add a child XML tag to parent with the given tag name and value, rendered with _ndm_render_value. If value is nothing, no tag is added.

_xml_odm__parse(str::AbstractString, strict::Bool) -> Vector{OrbitDataMessage}

Parse the Orbit Data Messages (ODM) in the XML input in str, returning a vector with the parsed messages.

The document can be a stand-alone message or a Navigation Data Message (NDM) wrapping multiple messages. Unsupported message types (OPM, OEM, OCM) are skipped with a warning. If the root tag is not recognized, an ArgumentError is thrown.

_xml_odm__parse_message(
    ::Val{tag},
    xml::Cursor,
    strict::Bool
) -> Union{Nothing, OrbitDataMessage}

Parse the ODM message with the root tag at the current position of the Cursor xml, dispatching on Val(tag), and return the parsed message. Message types that are not supported yet emit a warning and return nothing.

To add support for a new message type, define a method for the corresponding tag, e.g. _xml_odm__parse_message(::Val{:opm}, xml::XML.Cursor, strict::Bool), returning the assembled message.

_xml_odm__parse_ndm(xml::Cursor, strict::Bool) -> Vector{OrbitDataMessage}

Parse a Navigation Data Message (NDM) at the Cursor xml, returning a vector with the parsed wrapped messages.

_xml_odm__write(io::IO, vodm::AbstractVector{T}) where T <: OrbitDataMessage -> Nothing

Write the set of Orbit Data Messages in the vector vodm to the provided io stream as a Navigation Data Message (NDM) XML document.

_xml_odm__write_element(odm::OrbitDataMessage) -> Union{Nothing, XML.Node}

Convert odm to an XML element suitable for embedding in an NDM document. Message types that cannot be written yet emit a warning and return nothing.

To add support for a new message type, define a method for the corresponding concrete type.

_xml_omm__add_section_tags!(
    node::XML.Node,
    section::Union{OmmHeader, OmmMetadata, OmmData, OmmCovarianceMatrix},
    mapping::Vector{Pair{String, Symbol}},
    comments::Vector{String}
) -> Nothing

Add the tags of the OMM section to the XML node. The added tags and their fields are given by mapping, whose order is preserved in the output, and the section comments are added before the fields.

Fields whose value is nothing are omitted from the output.

_xml_omm__add_tags!(parent::XML.Node, omm::OrbitMeanElementsMessage) -> Nothing

Add the OMM tags from the given omm message to the parent XML node.

The tags of each section are obtained automatically from the corresponding keyword mapping (see _xml_omm__add_section_tags!), so the output follows the keyword order defined by the CCSDS 502.0-B-3 standard.

_xml_omm__parse(str::AbstractString, strict::Bool) -> Union{Nothing, NamedTuple}
_xml_omm__parse(xml::XML.Cursor, strict::Bool) -> Union{Nothing, NamedTuple}

Parse the first Orbit Mean-Elements Message (OMM) from the XML input in str (or at the Cursor xml), returning the container (; version, header_fields, metadata_fields, data_fields) with the raw field values. If the document does not contain an OMM message, nothing is returned.

_xml_omm__parse_body(
    xml::Cursor,
    strict::Bool
) -> Tuple{Dict{Symbol, Any}, Dict{Symbol, Any}}

Parse the body of an Orbit Mean-Elements Message (OMM) from a Cursor xml representation, returning dictionaries with the raw field values of the metadata and data sections of its single segment.

_xml_omm__parse_data(xml::Cursor, strict::Bool) -> Dict{Symbol, Any}

Parse the data of the segment body of an Orbit Mean-Elements Message (OMM) from a Cursor xml representation, returning a dictionary with the raw field values of all data subsections. Fields that are absent are omitted from the dictionary; the mandatory fields are checked afterwards by _omm_check_mandatory_fields.

_xml_omm__parse_element(xml::Cursor, strict::Bool) -> NamedTuple

Parse an OMM element at the Cursor xml, returning the container (; version, header_fields, metadata_fields, data_fields) with the raw field values. The version and the mandatory fields are checked afterwards by _omm_assemble.

_xml_omm__parse_header(xml::Cursor, strict::Bool) -> Dict{Symbol, Any}

Parse the header of an Orbit Mean-Elements Message (OMM) from a Cursor xml representation, returning a dictionary with the raw field values. Fields that are absent are omitted from the dictionary; the mandatory fields are checked afterwards by _omm_check_mandatory_fields.

_xml_omm__parse_metadata(xml::Cursor, strict::Bool) -> Dict{Symbol, Any}

Parse the metadata of the segment body of an Orbit Mean-Elements Message (OMM) from a Cursor xml representation, returning a dictionary with the raw field values. Fields that are absent are omitted from the dictionary; the mandatory fields are checked afterwards by _omm_check_mandatory_fields.

_xml_omm__parse_section!(
    fields::Dict{Symbol, Any},
    xml::Cursor,
    strict::Bool,
    mapping::Vector{Pair{String, Symbol}},
    comments_key::Symbol,
    description::String
) -> Nothing

Parse an OMM section composed only of scalar elements at the Cursor xml, storing the raw field values in fields. The recognized keywords and their fields are given by mapping, the comments are stored in fields[comments_key] when present, and description names the section fields in error messages (e.g. "metadata field").

Empty values are rejected when strict is true and skipped otherwise, allowing real-world files with omitted values to be processed leniently.

_xml_omm__parse_segment(
    xml::Cursor,
    strict::Bool
) -> Tuple{Dict{Symbol, Any}, Dict{Symbol, Any}}

Parse a segment of the body of an Orbit Mean-Elements Message (OMM) from a Cursor xml representation, returning dictionaries with the raw field values of its metadata and data sections.

_xml_omm__parse_user_defined_parameters(
    xml::Cursor,
    strict::Bool
) -> Vector{Pair{String, String}}

Parse an OMM userDefinedParameters section at the cursor's current position, matching the tags case-insensitively when strict is false. An ArgumentError is thrown if the section contains an unknown element or a USER_DEFINED element without the parameter attribute.

_xml_omm__scalar_value(xml::Cursor) -> SubString{String}

Read the text or CDATA value of the current OMM scalar element while advancing the cursor past that element. Non-value child nodes are ignored.

All text and CDATA chunks are concatenated and the surrounding whitespace is stripped, matching the whitespace-collapse behavior of the XML schema types used by the CCSDS 502.0-B-3 standard.

_xml_omm__tag(node::Cursor, strict::Bool) -> Union{Nothing, SubString{String}}

Return the canonical OMM tag for node, matching case-insensitively unless strict is true.

_xml_omm__write(io::IO, omm::OrbitMeanElementsMessage) -> Nothing

Write the given omm to the provided io stream as a stand-alone XML document. Hence, the XML declaration is included.

The written version is always 3.0, regardless of the version stored in the omm. This matches the schema declared in the xsi:noNamespaceSchemaLocation attribute.

_xml_omm__write(io::IO, vomm::AbstractVector{OrbitMeanElementsMessage}) -> Nothing

Write the set of Orbit Mean-Elements Messages in the vector vomm to the provided io stream as a Navigation Data Message (NDM) XML document.

_xml_omm__write_element(omm::OrbitMeanElementsMessage) -> XML.Node

Convert the given omm to an XML element suitable for embedding within another XML document (e.g. an NDM). Hence, the XML declaration is omitted.

The written version is always 3.0, regardless of the version stored in the omm. This matches the schema declared by the enclosing document.

_xml_omms__parse(str::AbstractString, strict::Bool) -> Vector{OrbitMeanElementsMessage}

Parse the Orbit Mean-Elements Messages (OMM) in the XML input in str, returning a vector with the parsed messages.

The document can be a stand-alone message or a Navigation Data Message (NDM) wrapping multiple messages. Messages that are not OMMs are skipped, and unsupported message types (OPM, OEM, OCM) additionally emit a warning. If the root tag is not recognized, an ArgumentError is thrown.

create_omm_fetcher(::Type{CelestrakOmmFetcher}; kwargs...) -> CelestrakOmmFetcher

Create an Orbit Mean-Elements Message (OMM) fetcher from the Celestrak service.

Keywords

• url::String: URL of the Celestrak query endpoint. (Default: "https://celestrak.org/NORAD/elements/gp.php")

create_omm_fetcher(::Type{SpacetrackOmmFetcher}; kwargs...) -> SpacetrackOmmFetcher

Create an Orbit Mean-Elements Message (OMM) fetcher from the Space-Track service.

Keywords

• username::String: Space-Track username. If empty, the user will be prompted to input it. (Default: "")
• password::String: Space-Track password. If empty, the user will be prompted to input it if a valid cookie is not found. (Default: "")
• force_login::Bool: If true, the user will be prompted to input the password even if a valid cookie is found. (Default: false)

Returns

• SpacetrackOmmFetcher: The created fetcher.

Extended help

Throws

• OdmLoginError: If the login fails, e.g. due to invalid credentials or a network error.

create_omm_fetcher(::Type{T}, args...; kwargs...) where T <: AbstractOmmFetcher -> T

Create an Orbit Mean-Elements Message (OMM) fetcher of type T.

The positional and keyword arguments are specific to each fetcher type; see the documentation of the corresponding method. An ArgumentError is thrown if T has no registered fetcher method.

fetch_omms(fetcher::CelestrakOmmFetcher; kwargs...) -> Vector{OrbitMeanElementsMessage}

Fetch Orbit Mean-Elements Messages (OMM) from the Celestrak service using the query parameters in kwargs....

This function returns a Vector{OrbitMeanElementsMessage} with the fetched OMMs. If no matching OMM is found, an empty vector is returned. If an error prevents the request from succeeding, an OdmFetchError is thrown.

Exactly one of international_designator, satellite_number, and satellite_name must be provided.

Keywords

• international_designator::Union{Nothing, AbstractString}: International designator of the satellite in the format YYYY-NNN or YYYY-NNNP. (Default: nothing)
• satellite_number::Union{Nothing, Integer}: NORAD catalog number of the satellite. (Default: nothing)
• satellite_name::Union{Nothing, AbstractString}: Name of the satellite. (Default: nothing)
• strict::Bool: Select the validation strictness when parsing the fetched OMMs; see parse_omms for the exact rules. Celestrak currently emits OMM 2.0 messages with empty header values, hence the relaxed default. (Default: false)

fetch_omms(fetcher::T; kwargs...) -> Vector{OrbitMeanElementsMessage}

Fetch Orbit Mean-Elements Messages (OMM) using fetcher.

The keywords kwargs... customize the search and are specific to each fetcher type; see the documentation of the corresponding method. An ArgumentError is thrown if the fetcher type T is not registered.

fetch_omms(fetcher::SpacetrackOmmFetcher; kwargs...) -> Vector{OrbitMeanElementsMessage}

Fetch Orbit Mean-Elements Messages (OMM) from the Space-Track service using the query parameters in kwargs....

This function returns a Vector{OrbitMeanElementsMessage} with the fetched OMMs. If the login cookie expired, an OdmLoginError is thrown. If the request to the service fails, an OdmFetchError is thrown.

Keywords

• interval::Union{Nothing, Tuple{Union{Date, DateTime}, Union{Date, DateTime}}}: A tuple with the start and end date of the interval to fetch the OMMs. This interval is appended to the predicates using the EPOCH field. If nothing, no interval is used. Notice that if the space data is :gp and an interval is specified, the space data is automatically changed to :gp_history; if the space data is already :gp_history, no change occurs. (Default: nothing)
• order_by::Union{Nothing, Vector{Pair{String, Symbol}}}: A vector of Pair{String, Symbol} with the fields to order the results by. The first element of each Pair is the field name whereas the second is the order direction, which can be either :ascending or :descending. This field is appended to the predicates using the orderby field. If nothing, no ordering is used. (Default: nothing)
• predicates::Union{Nothing, Vector{Pair{String, Any}}}: A vector of Pair{String, Any} with the query predicates to filter the OMMs. The first element of each Pair is the field name whereas the second is the field value. See the extended help for more details. If the field value is of type HTML{String}, it is used as is. Otherwise, it is converted to a string and URL-encoded. (Default: nothing)
• query_limits::Union{Nothing, Int, UnitRange{Int}}: The maximum number of OMMs to fetch. If an Int is provided, it is used as the limit. If a UnitRange{Int} is provided, it is used as the start and end indices of the fetched data. If nothing, no limit is used. This field is appended to the predicates using the limit field. (Default: nothing)
• satellite_name::Union{Nothing, AbstractString}: The name of the satellite to fetch the OMMs. This field is appended to the predicates using the OBJECT_NAME field. If nothing, no satellite name is used. If both satellite_name and satellite_number are provided, satellite_number takes precedence. (Default: nothing)
• satellite_number::Union{Nothing, Integer}: The NORAD catalog number of the satellite to fetch the OMMs. This field is appended to the predicates using the NORAD_CAT_ID field. If nothing, no satellite number is used. If both satellite_name and satellite_number are provided, satellite_number takes precedence. (Default: nothing)
• space_data::Symbol: The space data to fetch the OMMs from. It can be either :gp or :gp_history. If :gp, the latest OMM for each satellite is fetched. If :gp_history, all the OMMs that match the predicates are fetched. If an interval is specified and the space data is :gp, it is automatically changed to :gp_history. For more information, see the Space-Track API documentation. (Default: :gp)
• strict::Bool: Select the validation strictness when parsing the fetched OMMs; see parse_omms for the exact rules. (Default: true)

Extended help

Query Predicates

This section describes the query predicates that can be used to filter the OMMs. Those expressions can be passed using the predicates keyword argument. This description is a simplified version of the documentation that can be found at https://www.space-track.org/documentation#/api.

The following fields are available for querying the Space-Track database:

We can use the following REST operators to build the query predicates:

• >: Greater Than (alternate is %3E).
• <: Less Than (alternate is %3C).
• <>: Not Equal (alternate is %3C%3E).
• ,: Comma Delimited 'OR' (ex. 1,2,3).
• --: Inclusive Range (ex. 1--100 returns 1 and 100 and everything in between). Date ranges are expressed as YYYY-MM-DD%20HH:MM:SS--YYYY-MM-DD%20HH:MM:SS or YYYY-MM-DD--YYYY-MM-DD.
• null-val: Value for 'NULL', can only be used with Not Equal (<>) or by itself.
• ~~: "Like" or Wildcard search. You may put the ~~ before or after the text; wildcard is evaluated regardless of location of ~~ in the URL. For example, ~~OB will return 'OBJECT 1', 'GLOBALSTAR', 'PROBA 1', etc.
• ^: Wildcard after value with a minimum of two characters (alternate is %5E). The wildcard is evaluated after the text regardless of location of ^ in the URL. For example, ^OB will return 'OBJECT 1', 'OBJECT 2', etc. but not 'GLOBALSTAR'.
• now: Variable that contains the current system date and time. Add or subtract days (or fractions thereof) after 'now' to modify the date/time, e.g. now-7, now+14, now-6.5, now+2.3. Use <, >, and -- to get a range of dates; e.g. >now-7, now-14--now.

Hence, we can build complex queries like:

1. Return all OMMs where the satellite number is between 40,000 and 40,100 and the mean motion is lower than 14.9:

predicates = [
    "NORAD_CAT_ID" => "40000--40100",
    "MEAN_MOTION"  => "<14.9",
]

1. Return all OMMs with epoch in the last 7 days where the right ascension of the ascending node (RAAN) is between 140 and 141 degrees:

predicates = [
    "EPOCH"          => "now-7--now",
    "RA_OF_ASC_NODE" => "140--141",
]

1. Return the OMMs for the Starlink satellites that have decayed in the last 10 days:

predicates = [
    "OBJECT_NAME" => "^STARLINK",
    "EPOCH"       => "now-10--now",
    "DECAY_DATE"  => "<>null-val",
]

Examples

Create the OMM fetcher by logging in to Space-Track.

julia> f = create_omm_fetcher(SpacetrackOmmFetcher)
Space-Track username: username@email.com
Space-Track password:
[ Info: Successfully logged in to Space-Track.
SpacetrackOmmFetcher: username@email.com (Login expires in 5 hours)

Fetch all the OMMs for the SCD 1 satellite between June 19 and June 20, 2024.

julia> omm = fetch_omms(f, satellite_name="SCD 1", interval = (Date(2024, 6, 19), Date(2024, 6, 20)))
3-element Vector{OrbitMeanElementsMessage}:
 OMM: SCD 1 [1993-009B] (Epoch = 2024-06-19T07:28:48.714816)
 OMM: SCD 1 [1993-009B] (Epoch = 2024-06-19T20:30:29.736576)
 OMM: SCD 1 [1993-009B] (Epoch = 2024-06-19T22:16:28.479360)

Fetch the latest OMM for the Amazonia 1 satellite.

julia> omm = fetch_omms(f, satellite_name="Amazonia 1")
1-element Vector{OrbitMeanElementsMessage}:
 OMM: AMAZONIA 1 [2021-015A] (Epoch = 2025-09-09T04:34:22.789920)

parse_odm(str::AbstractString; kwargs...) -> Vector{OrbitDataMessage}

Parse an Orbit Data Message (ODM) from the string str, which must contain a complete XML document, and return the parsed message(s).

The return value is always a Vector{OrbitDataMessage}: a single-element vector for a stand-alone message, or a multi-element vector for a Navigation Data Message (NDM) wrapping multiple messages. Unsupported message types (OPM, OEM, OCM) are skipped with a warning; if no supported message remains, an empty vector is returned. If the root tag is not recognized, an ArgumentError is thrown.

Keywords

• strict::Bool: Select the validation strictness. If true, the schema-defined XML tag casing is required, empty XML element values are rejected, and the CREATION_DATE field must be present. If false, tags and the OMM id attribute value are matched case-insensitively, empty XML element values are skipped, and the CREATION_DATE may be absent. (Default: true)

parse_omm(str::AbstractString; kwargs...) -> Union{Nothing, OrbitMeanElementsMessage}

Parse an Orbit Mean-Elements Message (OMM) in the string str and return the parsed message.

If the XML is a Navigation Data Message (NDM), only the first OMM message is returned. If the file does not contain an OMM message, nothing is returned.

Keywords

• file_type::Symbol: The input file type. If :auto, the file type is inferred from the content. It can be :auto, :kvn, or :xml. (Default: :auto)
• strict::Bool: Select the validation strictness. If true, the schema-defined XML tag casing is required, empty XML element values are rejected, and the CREATION_DATE field must be present in any format. If false, tags and the OMM id attribute value are matched case-insensitively, empty XML element values are skipped, and the CREATION_DATE may be absent. (Default: true)

parse_omms(str::AbstractString; kwargs...) -> Vector{OrbitMeanElementsMessage}

Parse a set of Orbit Mean-Elements Messages (OMM) in the string str and return the parsed messages.

For XML input, the document can be a stand-alone message or a Navigation Data Message (NDM): only the OMM messages are returned, and other message types (OPM, OEM, OCM) are skipped with a warning. If the root tag is not recognized, an ArgumentError is thrown. For KVN input, each message must begin with its CCSDS_OMM_VERS keyword. If the input does not contain an OMM message, an empty vector is returned.

Keywords

• file_type::Symbol: The input file type. If :auto, the file type is inferred from the content. It can be :auto, :kvn, or :xml. (Default: :auto)
• strict::Bool: Select the validation strictness. If true, the schema-defined XML tag casing is required, empty XML element values are rejected, and the CREATION_DATE field must be present in any format. If false, tags and the OMM id attribute value are matched case-insensitively, empty XML element values are skipped, and the CREATION_DATE may be absent. (Default: true)

read_odm(file::AbstractString; kwargs...) -> Vector{OrbitDataMessage}
read_odm(io::IO; kwargs...) -> Vector{OrbitDataMessage}

Read the Orbit Data Messages (ODM) from the provided file or io stream.

For more information, see parse_odm.

Keywords

• strict::Bool: Select the validation strictness. For more information, see parse_odm. (Default: true)

read_omm(file::AbstractString; kwargs...) -> Union{Nothing, OrbitMeanElementsMessage}
read_omm(io::IO; kwargs...) -> Union{Nothing, OrbitMeanElementsMessage}

Read an Orbit Mean-Elements Message (OMM) from the provided file or io stream.

If the input contains multiple messages, only the first OMM is returned. If it does not contain an OMM, nothing is returned. For more information, see parse_omm.

Keywords

• file_type::Symbol: The input file type. If :auto, the file type is inferred from the content. It can be :auto, :kvn, or :xml. (Default: :auto)
• strict::Bool: Select the validation strictness. For more information, see parse_omm. (Default: true)

read_omms(file::AbstractString; kwargs...) -> Vector{OrbitMeanElementsMessage}
read_omms(io::IO; kwargs...) -> Vector{OrbitMeanElementsMessage}

Read a set of Orbit Mean-Elements Messages (OMM) from the provided file or io stream.

If the input contains messages of other types, only the OMMs are returned. If it does not contain an OMM, an empty vector is returned. For more information, see parse_omms.

Keywords

• file_type::Symbol: The input file type. If :auto, the file type is inferred from the content. It can be :auto, :kvn, or :xml. (Default: :auto)
• strict::Bool: Select the validation strictness. For more information, see parse_omms. (Default: true)

write_odm(io::IO, odm::OrbitDataMessage) -> Nothing

Write the given odm to the provided io stream in XML format.

write_odm(io::IO, vodm::AbstractVector{T}) where T<:OrbitDataMessage -> Nothing

Write the set of Orbit Data Messages in the vector vodm to the provided io stream in XML format.

write_odm(file::AbstractString, odm::OrbitDataMessage) -> Nothing

Write the given odm to the file at file in XML format, overwriting its contents.

write_odm(
    file::AbstractString,
    vodm::AbstractVector{T}
) where T<:OrbitDataMessage -> Nothing

Write the set of Orbit Data Messages in the vector vodm to the file at file in XML format, overwriting its contents.

write_omm(io::IO, omm::OrbitMeanElementsMessage; kwargs...) -> Nothing

Write the given omm to the provided io stream.

write_omm(io::IO, vomm::AbstractVector{OrbitMeanElementsMessage}; kwargs...) -> Nothing

Write the set of Orbit Mean-Elements Messages in the vector vomm to the provided io stream. In XML format, the messages are wrapped in a Navigation Data Message (NDM) document, whereas in KVN format they are written sequentially, delimited by their CCSDS_OMM_VERS keyword.

write_omm(file::AbstractString, omm::OrbitMeanElementsMessage; kwargs...) -> Nothing
write_omm(
    file::AbstractString,
    vomm::AbstractVector{OrbitMeanElementsMessage};
    kwargs...
) -> Nothing

Write the given omm (or the set of messages in vomm) to the file at file, overwriting its contents.

The written version is always 3.0, regardless of the version stored in the messages.

Keywords

• file_type::Symbol: The output file type, which can be :xml or :kvn. The methods that write to a file also accept :auto, which infers the file type from the file extension (case-insensitive): .kvn selects the KVN format, whereas any other extension selects the XML format. (Default: :xml when writing to an io stream, :auto when writing to a file)

module ODM

Namespace with accessor functions for the fields of Orbit Data Messages (ODM).

The accessors flatten the nested CCSDS hierarchy so that the most common fields can be obtained without navigating the message structure, e.g. ODM.epoch(omm) instead of omm.data.epoch. The functions live in this module to avoid polluting the namespace with the field names; access them qualified, or opt in with using SatelliteToolboxOrbitDataMessages.ODM.

ODM.GM(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the gravitational coefficient [km³/s²] of the Orbit Mean-Elements Message omm.

ODM.agom(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the solar radiation pressure coefficient AGOM [m²/kg] of the Orbit Mean-Elements Message omm.

ODM.arg_of_pericenter(omm::OrbitMeanElementsMessage) -> Float64

Return the argument of pericenter [deg] of the Orbit Mean-Elements Message omm.

ODM.bstar(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the SGP4 drag term B* [1/ER] of the Orbit Mean-Elements Message omm.

ODM.bterm(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the ballistic coefficient [m²/kg] of the Orbit Mean-Elements Message omm.

ODM.center_name(omm::OrbitMeanElementsMessage) -> String

Return the origin of the reference frame of the Orbit Mean-Elements Message omm.

ODM.classification(omm::OrbitMeanElementsMessage) -> Union{String, Nothing}

Return the classification of the Orbit Mean-Elements Message omm.

ODM.classification_type(omm::OrbitMeanElementsMessage) -> Union{Char, Nothing}

Return the classification type of the Orbit Mean-Elements Message omm.

ODM.covariance_matrix(omm::OrbitMeanElementsMessage) -> Union{OmmCovarianceMatrix, Nothing}

Return the covariance matrix of the Orbit Mean-Elements Message omm.

ODM.creation_date(omm::OrbitMeanElementsMessage) -> Union{NanoDate, Nothing}

Return the creation date of the Orbit Mean-Elements Message omm.

ODM.data_comments(omm::OrbitMeanElementsMessage) -> Vector{String}

Return the comments of the data section of the Orbit Mean-Elements Message omm.

ODM.drag_area(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the effective area for atmospheric drag [m²] of the Orbit Mean-Elements Message omm.

ODM.drag_coeff(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the atmospheric drag coefficient of the Orbit Mean-Elements Message omm.

ODM.eccentricity(omm::OrbitMeanElementsMessage) -> Float64

Return the eccentricity of the Orbit Mean-Elements Message omm.

ODM.element_set_number(omm::OrbitMeanElementsMessage) -> Union{Int, Nothing}

Return the element set number of the Orbit Mean-Elements Message omm.

ODM.ephemeris_type(omm::OrbitMeanElementsMessage) -> Union{Int, Nothing}

Return the default ephemeris type associated with the TLE of the Orbit Mean-Elements Message omm.

ODM.epoch(omm::OrbitMeanElementsMessage) -> NanoDate

Return the epoch of the mean Keplerian elements of the Orbit Mean-Elements Message omm.

ODM.header_comments(omm::OrbitMeanElementsMessage) -> Vector{String}

Return the comments of the header section of the Orbit Mean-Elements Message omm.

ODM.inclination(omm::OrbitMeanElementsMessage) -> Float64

Return the inclination [deg] of the Orbit Mean-Elements Message omm.

ODM.mass(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the spacecraft mass [kg] of the Orbit Mean-Elements Message omm.

ODM.mean_anomaly(omm::OrbitMeanElementsMessage) -> Float64

Return the mean anomaly [deg] of the Orbit Mean-Elements Message omm.

ODM.mean_element_theory(omm::OrbitMeanElementsMessage) -> String

Return the theory describing the mean elements of the Orbit Mean-Elements Message omm.

ODM.mean_elements_comments(omm::OrbitMeanElementsMessage) -> Vector{String}

Return the comments of the mean elements section of the Orbit Mean-Elements Message omm.

ODM.mean_motion(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the mean motion [rev/day] of the Orbit Mean-Elements Message omm.

ODM.mean_motion_ddot(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the second time derivative of the mean motion [rev/day³] of the Orbit Mean-Elements Message omm.

ODM.mean_motion_dot(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the first time derivative of the mean motion [rev/day²] of the Orbit Mean-Elements Message omm.

ODM.message_id(omm::OrbitMeanElementsMessage) -> Union{String, Nothing}

Return the message identifier of the Orbit Mean-Elements Message omm.

ODM.metadata_comments(omm::OrbitMeanElementsMessage) -> Vector{String}

Return the comments of the metadata section of the Orbit Mean-Elements Message omm.

ODM.norad_cat_id(omm::OrbitMeanElementsMessage) -> Union{Int, Nothing}

Return the NORAD catalog number of the Orbit Mean-Elements Message omm.

ODM.object_id(omm::OrbitMeanElementsMessage) -> String

Return the international designator of the Orbit Mean-Elements Message omm.

ODM.object_name(omm::OrbitMeanElementsMessage) -> String

Return the spacecraft name of the Orbit Mean-Elements Message omm.

ODM.originator(omm::OrbitMeanElementsMessage) -> String

Return the originator of the Orbit Mean-Elements Message omm.

ODM.raan(omm::OrbitMeanElementsMessage) -> Float64

Return the right ascension of the ascending node [deg] of the Orbit Mean-Elements Message omm.

ODM.ref_frame(omm::OrbitMeanElementsMessage) -> String

Return the reference frame of the mean elements of the Orbit Mean-Elements Message omm.

ODM.ref_frame_epoch(omm::OrbitMeanElementsMessage) -> Union{NanoDate, Nothing}

Return the epoch of the reference frame of the Orbit Mean-Elements Message omm.

ODM.rev_at_epoch(omm::OrbitMeanElementsMessage) -> Union{Int, Nothing}

Return the revolution number at epoch of the Orbit Mean-Elements Message omm.

ODM.semi_major_axis(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the semi-major axis [km] of the Orbit Mean-Elements Message omm.

ODM.solar_rad_area(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the effective area for solar radiation pressure [m²] of the Orbit Mean-Elements Message omm.

ODM.solar_rad_coeff(omm::OrbitMeanElementsMessage) -> Union{Float64, Nothing}

Return the solar radiation pressure coefficient of the Orbit Mean-Elements Message omm.

ODM.spacecraft_parameters_comments(omm::OrbitMeanElementsMessage) -> Vector{String}

Return the comments of the spacecraft parameters section of the Orbit Mean-Elements Message omm.

ODM.time_system(omm::OrbitMeanElementsMessage) -> String

Return the time system of the Orbit Mean-Elements Message omm.

ODM.tle_parameters_comments(omm::OrbitMeanElementsMessage) -> Vector{String}

Return the comments of the TLE-related parameters section of the Orbit Mean-Elements Message omm.

ODM.user_defined_parameters(omm::OrbitMeanElementsMessage) -> Union{Nothing, Vector{Pair{String, String}}}

Return the user-defined parameters of the Orbit Mean-Elements Message omm.