def test_tracking_target(self, model):
e = model.enum
m = model
pattern = range(7)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert not m.tx_antenna_tracking_target
e = model.enum
m = model
pattern = range(7)
antenna = pylink.Antenna(is_rx=False, tracking=True, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert True == m.tx_antenna_tracking_target
e = model.enum
m = model
pattern = range(7)
antenna = pylink.Antenna(is_rx=False,
tracking='turkey saussage',
pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert m.tx_antenna_tracking_target
assert True == m.tx_antenna_tracking_target
def model():
return pylink.DAGModel([pylink.Geometry(),
pylink.Antenna(is_rx=True),
pylink.Interconnect(is_rx=True),
pylink.Receiver(),
pylink.Transmitter(),
pylink.Interconnect(is_rx=False),
pylink.Antenna(is_rx=False),
pylink.Channel(),
pylink.Modulation(name='QPSK', perf=perf),
pylink.LinkBudget()])
def test_boresight_gain_dbi(self, model):
assert model.tx_antenna_boresight_gain_dbi == 0
pattern = range(1, 10, 1)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
model.accept_tribute(antenna.tribute)
model.clear_cache()
assert model.tx_antenna_boresight_gain_dbi == 1
def test_obj(self, model):
e = model.enum
m = model
pattern = range(7)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert m.tx_antenna_obj == antenna
def test_peak_gain_dbi(self, model):
e = model.enum
m = model
pattern = range(10)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert max(antenna.interpolated) == m.tx_antenna_peak_gain_dbi
def test_average_nadir_gain_dbi(self, model):
e = model.enum
m = model
pattern = [1] * 90 + [0] * 180 + [1] * 90
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert (1 == m.tx_antenna_average_nadir_gain_dbi)
def test_raw_gain_pattern_angles(self, model):
e = model.enum
m = model
pattern = range(36)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
for i in range(len(m.tx_antenna_raw_gain_pattern_angles)):
assert m.tx_antenna_raw_gain_pattern_angles[i] == 10 * i
pattern = range(7)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
angles = m.tx_antenna_raw_gain_pattern_angles
for i in range(len(angles)):
assert angles[i] == i * (360.0 / len(pattern))
def test_raw_gain_pattern(self, model):
e = model.enum
m = model
pattern = range(10)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
for i in range(len(pattern)):
assert m.tx_antenna_raw_gain_pattern[i] == pattern[i]
def test_pointing_loss_db(self, model):
e = model.enum
m = model
pattern = range(7)
antenna = pylink.Antenna(pointing_loss_db=2.718281828,
is_rx=False,
tracking=False,
pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert m.tx_antenna_pointing_loss_db == 2.718281828
def test_gain_pattern_angles(self, model):
e = model.enum
m = model
pattern = range(7)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
angles = m.tx_antenna_gain_pattern_angles
assert 360 == len(angles)
for i in range(len(angles)):
assert i == angles[i]
def test_rf_chain(self, model):
e = model.enum
m = model
chain = range(3)
pattern = range(7)
antenna = pylink.Antenna(rf_chain=chain,
is_rx=False,
tracking=False,
pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert m.tx_antenna_rf_chain == chain
def test_gain_pattern(self, model):
e = model.enum
m = model
pattern = [1] * 3 + [0] * 5 + [1] * 2
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
interp = m.tx_antenna_gain_pattern
assert 360 == len(interp)
for i in range(-30, 30, 1):
angle = (360 + i) % 360
assert abs(interp[angle] - 1.0) < 3e-2
def test_gain_dbi(self, model):
e = model.enum
m = model
pattern = range(10)
antenna = pylink.Antenna(is_rx=False, tracking=False, pattern=pattern)
m.accept_tribute(antenna.tribute)
model.clear_cache()
assert 360 == len(m.tx_antenna_gain_pattern_angles)
for i in range(-180, 180, 1):
m.override(e.tx_antenna_angle_deg, i)
gain = m.tx_antenna_gain_dbi
deg = (360 + i) % 360
val = antenna.interpolated[deg]
assert gain == val
for i in range(360):
m.override(e.tx_antenna_angle_deg, i)
gain = m.tx_antenna_gain_dbi
val = antenna.interpolated[i]
assert gain == val
def update_gs_rx_antenna_gain(self, gain):
# create new antenna
self.gs_rx_antenna = pylink.Antenna(
gain=gain,
pattern=self.sampler(self.groundstation_configuration,
['rx', 'antenna', 'pattern']),
polarization=self.groundstation_configuration['nominal']['rx']
['antenna']['polarization'],
is_rx=True,
tracking=self.groundstation_configuration['nominal']['rx']
['antenna']['tracking'],
pointing_loss_db=self.sampler(self.groundstation_configuration,
['rx', 'antenna', 'pointing_loss']),
rx_noise_temp_k=self.sampler(self.groundstation_configuration,
['rx', 'antenna', 'noise_temp']))
# form the downlink signal chain
self.downlink = pylink.DAGModel([
self.geometry, self.gs_rx_antenna, self.sat_transmitter,
self.sat_tx_antenna, self.gs_receiver, self.downlink_channel,
self.rx_interconnect, self.tx_interconnect, self.modulation,
pylink.LinkBudget(name='Downlink', is_downlink=True)
])
]
gs_rf_chain = [
pylink.Element(name='Cables', gain_db=-0.75, noise_figure_db=0.75),
pylink.Element(name='LNA', gain_db=35, noise_figure_db=2.75),
pylink.Element(name='Filter', gain_db=-3.5, noise_figure_db=3.5),
pylink.Element(name='Demodulator', gain_db=0, noise_figure_db=15),
]
geometry = pylink.Geometry(apoapsis_altitude_km=550,
periapsis_altitude_km=500,
min_elevation_deg=20)
sat_rx_antenna = pylink.Antenna(gain=3,
polarization='RHCP',
pattern=sat_pattern,
rx_noise_temp_k=1000,
is_rx=True,
tracking=False)
sat_tx_antenna = pylink.Antenna(gain=3,
polarization='RHCP',
pattern=sat_pattern,
is_rx=False,
tracking=False)
gs_rx_antenna = pylink.Antenna(pattern=pylink.pattern_generator(48),
rx_noise_temp_k=300,
polarization='RHCP',
is_rx=True,
tracking=True)
def satellite_init(self):
# build the receive RF chain
self.sat_rf_chain = [
pylink.Element(name='Cables',
gain_db=self.sampler(self.satellite_configuration,
['rx', 'cable', 'gain']),
noise_figure_db=self.sampler(
self.satellite_configuration,
['rx', 'cable', 'noise_figure'])),
pylink.Element(name='LNA',
gain_db=self.sampler(self.satellite_configuration,
['rx', 'lna', 'gain']),
noise_figure_db=self.sampler(
self.satellite_configuration,
['rx', 'lna', 'noise_figure'])),
pylink.Element(name='Filter',
gain_db=self.sampler(self.satellite_configuration,
['rx', 'filter', 'gain']),
noise_figure_db=self.sampler(
self.satellite_configuration,
['rx', 'filter', 'noise_figure'])),
pylink.Element(name='Demodulator',
gain_db=self.sampler(self.satellite_configuration,
['rx', 'demodulator', 'gain']),
noise_figure_db=self.sampler(
self.satellite_configuration,
['rx', 'demodulator', 'noise_figure'])),
]
# if no gain given, calculate from the antenna aperture
if 'gain' in self.satellite_configuration['nominal']['rx']['antenna']:
sat_rx_antenna_gain = self.sampler(self.satellite_configuration,
['rx', 'antenna', 'gain'])
if 'aperture' in self.satellite_configuration['nominal']['rx'][
'antenna'] and self.warn:
print(
"Satellite Rx Antenna: Both gain and aperature provided, will use gain"
)
else:
sat_rx_antenna_gain = 10 * np.log10(
self.sampler(self.satellite_configuration,
['rx', 'antenna', 'aperture_efficiency']) *
self.sampler(self.satellite_configuration,
['rx', 'antenna', 'aperture']) * 4 * np.pi *
(1e6 * self.sampler(self.channel_configuration,
['uplink', 'center_freq']))**2 /
scipy.constants.c**2)
# specify the receive antenna
self.sat_rx_antenna = pylink.Antenna(
gain=sat_rx_antenna_gain,
polarization=self.satellite_configuration['nominal']['rx']
['antenna']['polarization'],
pattern=self.sampler(self.satellite_configuration,
['rx', 'antenna', 'pattern']),
is_rx=True,
tracking=self.satellite_configuration['nominal']['rx']['antenna']
['tracking'],
pointing_loss_db=self.sampler(self.satellite_configuration,
['rx', 'antenna', 'pointing_loss']),
rx_noise_temp_k=self.sampler(self.satellite_configuration,
['rx', 'antenna', 'noise_temp']))
# if no gain given, calculate from the antenna aperture
if 'gain' in self.satellite_configuration['nominal']['tx']['antenna']:
sat_tx_antenna_gain = self.sampler(self.satellite_configuration,
['tx', 'antenna', 'gain'])
if 'aperture' in self.satellite_configuration['nominal']['tx'][
'antenna'] and self.warn:
print(
"Satellite Tx Antenna: Both gain and aperature provided, will use gain"
)
else:
sat_tx_antenna_gain = 10 * np.log10(
self.sampler(self.satellite_configuration,
['tx', 'antenna', 'aperture_efficiency']) *
self.sampler(self.satellite_configuration,
['tx', 'antenna', 'aperture']) * 4 * np.pi *
(1e6 * self.sampler(self.channel_configuration,
['downlink', 'center_freq']))**2 /
scipy.constants.c**2)
self.sat_tx_antenna = pylink.Antenna(
gain=sat_tx_antenna_gain,
polarization=self.satellite_configuration['nominal']['tx']
['antenna']['polarization'],
pattern=self.sampler(self.satellite_configuration,
['tx', 'antenna', 'pattern']),
is_rx=False,
tracking=self.satellite_configuration['nominal']['tx']['antenna']
['tracking'],
pointing_loss_db=self.sampler(self.satellite_configuration,
['rx', 'antenna', 'pointing_loss']))
self.sat_receiver = pylink.Receiver(
rf_chain=self.sat_rf_chain,
implementation_loss_db=self.sampler(
self.satellite_configuration,
['rx', 'receiver', 'implementation_loss']),
name='Satellite ' +
self.channel_configuration['nominal']['uplink']['name'] +
' Receiver')
self.sat_transmitter = pylink.Transmitter(
tx_power_at_pa_dbw=self.sampler(self.satellite_configuration,
['tx', 'pa', 'power']),
name='Satellite ' +
self.channel_configuration['nominal']['downlink']['name'] +
' Transmitter')
#!/usr/bin/env python
import os
import pylink
d = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'export')
if not os.path.exists(d):
os.makedirs(d)
for peak in [3, 5, 15]:
eff = .65
null = -20
f = os.path.join(d, 'pattern-%ddBi.png' % peak)
pattern = pylink.pattern_generator(peak, eff=eff, null=null)
ant = pylink.Antenna(pattern=pattern)
ant.plot_pattern(f,
include_raw=False,
title='%ddBi Generated Pattern' % peak,
ylim=[null-3, peak+3])
print('Pattern Created: %s' % f)
f = os.path.join(d, 'pattern-manual.png')
pattern = [10, 5, -5, -9, -10, -10, -10, -10, -10, -10, -9, -5, 5]
ant = pylink.Antenna(pattern=pattern)
ant.plot_pattern(f,
include_raw=True,
title='Manual Pattern')
#!/usr/bin/python
import pylink
"""Illustrations of the precedence order for node definitions.
Nodes are added to the DAG in the order in which they are received.
So you can, if you wish, override a standard definition.
"""
# Vanilla link budget
m = pylink.DAGModel([
pylink.Geometry(),
pylink.Transmitter(tx_power_at_pa_dbw=2),
pylink.Interconnect(is_rx=False),
pylink.Antenna(is_rx=False),
pylink.Receiver(),
pylink.Antenna(is_rx=True),
pylink.Interconnect(is_rx=True),
pylink.Channel(),
pylink.Modulation('DVB-S2X'),
pylink.LinkBudget()
])
e = m.enum
print 'Link margin in vanilla example: %s' % m.link_margin_db
# let's override the link_margin_db node in the kwargs
def _evil_margin_db(model):
return -3.0
noise_figure_db=2.75),
pylink.Element(name='Filter',
gain_db=-3.5,
noise_figure_db=3.5),
pylink.Element(name='Demodulator',
gain_db=0,
noise_figure_db=15),
]
geometry = pylink.Geometry(apoapsis_altitude_km=426452,
periapsis_altitude_km=356873,
min_elevation_deg=20)
sat_rx_antenna = pylink.Antenna(gain=54.7,
polarization='RHCP',
pattern=sat_pattern,
rx_noise_temp_k=288.84,
is_rx=True,
tracking=False)
sat_tx_antenna = pylink.Antenna(gain=53.11,
polarization='RHCP',
pattern=sat_pattern,
is_rx=False,
tracking=False)
gs_rx_antenna = pylink.Antenna(pattern=pylink.pattern_generator(48),
rx_noise_temp_k=25.6,
polarization='LCP',
is_rx=True,
tracking=True)
