Link Budgets – ephemerista.analysis.link_budget

The link_budget.py module.

This module provides the LinkBudget class and the associated LinkBudgetResults class.

pydantic model ephemerista.analysis.link_budget.EnvironmentalLosses

The EnvironmentalLosses class.

This class models all environmental losses supported by Ephemerista.

Fields:

• atmospheric_attenuation (float)

• cloud_attenuation (float)

• depolarization_loss (float)

• gaseous_attenuation (float)

• rain_attenuation (float)

• scintillation_attenuation (float)

field atmospheric_attenuation: float [Required] (alias 'atmosphericAttenuation')

Attenuation of atmospheric gases, in dB

Constraints:

• ge = 0.0

field cloud_attenuation: float [Required] (alias 'cloudAttenuation')

Attenuation due to clouds, in dB

Constraints:

• ge = 0.0

field depolarization_loss: float [Required] (alias 'depolarizationLoss')

Depolarization losses, in dB

Constraints:

• ge = 0.0

field gaseous_attenuation: float [Required] (alias 'gaseousAttenuation')

Gaseous attenuation, in dB

Constraints:

• ge = 0.0

field rain_attenuation: float [Required] (alias 'rainAttenuation')

Rain attenuation, in dB)

Constraints:

• ge = 0.0

field scintillation_attenuation: float [Required] (alias 'scintillationAttenuation')

Solar scintillation attenuation, in dB

Constraints:

• ge = 0.0

classmethod calculate(percentage_exceed, time, observer, target_comms, observer_comms, gs_pass)

Calculate environmental losses for a given link.

Return type:

Self

classmethod no_losses()

Initialise losses to zero.

Return type:

Self

sum()

Sum all environmental losses.

Return type:

float

pydantic model ephemerista.analysis.link_budget.InterferenceStats

The InterferenceStats class.

This class models the influence of interfering radio transmissions on the link.

Fields:

• c_n0i0 (float)

• eb_n0i0 (float)

• interference_power_w (float)

• margin_with_interference (float)

field c_n0i0: float [Required] (alias 'cN0I0')

Carrier to noise plus interference density, in dB

field eb_n0i0: float [Required] (alias 'ebN0I0')

Bit energy to noise plus interference density, in dB

field interference_power_w: float [Required] (alias 'interferencePowerW')

Total received interference power from all sources, in W

Constraints:

• ge = 0.0

field margin_with_interference: float [Required] (alias 'marginWithInterference')

Link margin considering interference, in dB

property interference_power: float

pydantic model ephemerista.analysis.link_budget.Link

The Link class.

This class models a radio link between two communication systems covering a specific visbility window.

Fields:

• link_type (Literal['uplink', 'downlink'])

• stats (list[ephemerista.analysis.link_budget.LinkStats])

• times (list[ephemerista.time.Time])

• window (ephemerista.analysis.visibility.Window)

field link_type: Literal['uplink', 'downlink'] [Required] (alias 'linkType')

Link type, uplink or downlink

field stats: list[LinkStats] [Required]

List of link metrics, one for each time step

field times: list[Time] [Required]

Time vector

field window: Window [Required]

Time window of the visibility pass where the link budget is computed

plot(*, plot_interference=False)

Plot all link properties.

plot_attenuations(percentage_exceed)

Plot all attenuations.

to_dataframe()

Convert to a DataFrame.

Return type:

DataFrame

property mean_c_n0: float

property mean_eb_n0: float

property mean_eirp: float

property mean_fspl: float

property mean_gt: float

property mean_losses: float

property mean_margin: float

property mean_rx_angle: float

property mean_slant_range: float

property mean_tx_angle: float

pydantic model ephemerista.analysis.link_budget.LinkBudget

The LinkBudget analysis.

Fields:

• end_time (ephemerista.time.Time | None)

• percentage_exceed (float)

• scenario (ephemerista.scenarios.Scenario)

• start_time (ephemerista.time.Time | None)

field end_time: Time | None = None (alias 'endTime')

End time (optional, if None the scenario’s end time is used)

field percentage_exceed: float = 1.0 (alias 'percentageExceed')

Percentage of the time the environmental attenuation values are exceeded, per ITU-R

Constraints:

• gt = 0.001

• le = 5.0

field scenario: Scenario [Required]

The scenario used to analyze the link budget

field start_time: Time | None = None (alias 'startTime')

Start time (optional, if None the scenario’s start time is used)

analyze(ensemble=None, visibility=None, environment_losses='enabled')

Run the analysis.

Return type:

LinkBudgetResults

pydantic model ephemerista.analysis.link_budget.LinkBudgetResults

The results of the LinkBudget analysis.

Fields:

• links (dict[uuid.UUID, dict[uuid.UUID, list[ephemerista.analysis.link_budget.Link]]])

• results_type (Literal['link_budget'])

• scenario (ephemerista.scenarios.Scenario)

field links: dict[Annotated[UUID], dict[Annotated[UUID], list[Link]]] [Required]

Dictionary of all links between all targets and all observers

field results_type: Literal['link_budget'] = 'link_budget' (alias 'type')

field scenario: Scenario [Required]

get(observer, target)

Get all links for a given observer and target pairing.

Return type:

list[Link]

to_dataframe(observer, target, *, with_interference=False)

Convert the analysis results to a Pandas data frame.

Return type:

DataFrame

events

pydantic model ephemerista.analysis.link_budget.LinkStats

The LinkStats class.

This class models all relevant properties of a radio link for link budget calculations at specific point in time.

Fields:

• bandwidth (float)

• c_n0 (float)

• carrier_rx_power (float)

• data_rate (float)

• eb_n0 (float)

• eirp (float)

• frequency (float)

• fspl (float)

• gt (float)

• interference_stats (ephemerista.analysis.link_budget.InterferenceStats | None)

• losses (ephemerista.analysis.link_budget.EnvironmentalLosses)

• margin (float)

• noise_power (float)

• rx_angle (ephemerista.angles.Angle)

• slant_range (float)

• tx_angle (ephemerista.angles.Angle)

field bandwidth: float [Required]

Bandwidth, in Hz

field c_n0: float [Required] (alias 'cN0')

Carrier to noise density, in dB

field carrier_rx_power: float [Required] (alias 'carrierRxPower')

Power level at receiver input, in dBW

field data_rate: float [Required] (alias 'dataRate')

Data rate, in bit/s

field eb_n0: float [Required] (alias 'ebN0')

Bit energy to noise density, in dB

field eirp: float [Required]

Effective isotropic radiated power, in dBW

field frequency: float [Required]

Frequency, in Hz

field fspl: float [Required]

Free space path loss, in dB

field gt: float [Required]

Gain to noise temperature ratio, in dB/K

field interference_stats: InterferenceStats | None = None (alias 'interferenceStats')

Interference data (optional, only available after analyzing interference)

field losses: EnvironmentalLosses [Required]

Environmental losses

field margin: float [Required]

Link margin, in dB

field noise_power: float [Required] (alias 'noisePower')

Noise power, in dBW

field rx_angle: Angle [Required] (alias 'rxAngle')

Angle between the RX antenna boresight vector and the receiver to transmitter vector, in degrees

field slant_range: float [Required] (alias 'slantRange')

Range between transmit and receive antennas, in meters

field tx_angle: Angle [Required] (alias 'txAngle')

Angle between the TX antenna boresight vector and the transmitter to receiver vector, in degrees

classmethod calculate(time, channel, link_type, target, observer, target_comms, observer_comms, losses, ensemble)

Calculate link stats.

Return type:

Self

add_interference(interference_power_w)

Add interference to previously computed link stats.

Return type:

Self