def test_multiple_locations():
# Obtain the coordinates of the different cities
cities = {'Boston': (42.36, -71.06),
'New York': (40.71, -74.01),
'Los Angeles': (34.05, -118.24),
'Denver': (39.74, -104.99),
'Las Vegas': (36.20, -115.14),
'Seattle': (47.61, -122.33),
'Washington DC': (38.91, -77.04)}
lat = [coords[0] for coords in cities.values()]
lon = [coords[1] for coords in cities.values()]
# Satellite coordinates (GEO, 4 E)
lat_sat = 0
lon_sat = -77
h_sat = 35786 * itur.u.km
# Compute the elevation angle between satellite and ground stations
el = itur.utils.elevation_angle(h_sat, lat_sat, lon_sat, lat, lon)
# Set the link parameters
f = 22.5 * itur.u.GHz # Link frequency
D = 1.2 * itur.u.m # Antenna diameters
p = 0.1 # Unavailability (Vals exceeded 0.1% of time)
# Compute the atmospheric attenuation
Ag, Ac, Ar, As, Att = itur.atmospheric_attenuation_slant_path(
lat, lon, f, el, p, D, return_contributions=True)
# Plot the results
city_idx = np.arange(len(cities))
width = 0.15
fig, ax = plt.subplots(1, 1)
ax.bar(city_idx, Att.value, 0.6, label='Total atmospheric Attenuation')
ax.bar(city_idx - 1.5 * width, Ar.value, width,
label='Rain attenuation')
ax.bar(city_idx - 0.5 * width, Ag.value, width,
label='Gaseous attenuation')
ax.bar(city_idx + 0.5 * width, Ac.value, width,
label='Clouds attenuation')
ax.bar(city_idx + 1.5 * width, As.value, width,
label='Scintillation attenuation')
# Set the labels
ticks = ax.set_xticklabels([''] + list(cities.keys()))
for t in ticks:
t.set_rotation(45)
ax.set_ylabel('Atmospheric attenuation exceeded for 0.1% [dB]')
# Format image
ax.yaxis.grid(which='both', linestyle=':')
ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.3), ncol=2)
plt.tight_layout(rect=(0, 0, 1, 0.85))
def test_single_location():
# Location of the receiver ground stations
lat = 41.39
lon = -71.05
# Link parameters
el = 60 # Elevation angle equal to 60 degrees
f = 22.5 * itur.u.GHz # Frequency equal to 22.5 GHz
D = 1 * itur.u.m # Receiver antenna diameter of 1 m
p = 0.1 # We compute values exceeded during 0.1 % of
# the average year
# Compute atmospheric parameters
hs = itur.topographic_altitude(lat, lon)
T = itur.surface_mean_temperature(lat, lon)
P = itur.models.itu835.pressure(lat, hs)
rho_p = itur.surface_water_vapour_density(lat, lon, p, hs)
itur.models.itu835.water_vapour_density(lat, hs)
itur.models.itu835.temperature(lat, hs)
itur.models.itu836.total_water_vapour_content(lat, lon, p, hs)
# Compute rain and cloud-related parameters
itur.models.itu618.rain_attenuation_probability(
lat, lon, el, hs)
itur.models.itu837.rainfall_probability(lat, lon)
itur.models.itu837.rainfall_rate(lat, lon, p)
itur.models.itu839.isoterm_0(lat, lon)
itur.models.itu839.rain_height(lat, lon)
itur.models.itu840.columnar_content_reduced_liquid(
lat, lon, p)
itur.models.itu676.zenit_water_vapour_attenuation(
lat, lon, p, f, h=hs)
# Compute attenuation values
itur.gaseous_attenuation_slant_path(f, el, rho_p, P, T)
itur.rain_attenuation(lat, lon, f, el, hs=hs, p=p)
itur.cloud_attenuation(lat, lon, el, f, p)
itur.scintillation_attenuation(lat, lon, f, el, p, D)
itur.atmospheric_attenuation_slant_path(lat, lon, f, el, p, D)
def get_link_attenuation(self, p=0.001, method='approx'):
if self.grstation is None:
sys.exit(
'Need to associate a ground station to a satellite first. Try satellite.set_reception(reception)!!!'
)
if self.reception is None:
sys.exit(
'Need to associate a reception to a satellite first. Try satellite.set_reception(reception)!!!'
)
if self.p is None:
self.p = 0.001
p = 0.001
if self.a_tot is not None and p == self.p:
return self.a_fs, self.reception.get_depoint_loss(
), self.a_g, self.a_c, self.a_r, self.a_s, self.a_t, self.a_tot
else:
freq = self.freq * u.GHz
e = self.get_elevation()
diam = self.reception.ant_size * u.m
a_fs = FsAtt(self.get_distance(), self.freq)
a_g, a_c, a_r, a_s, a_t = itur.atmospheric_attenuation_slant_path(
self.grstation.site_lat,
self.grstation.site_long,
freq,
e,
p,
diam,
return_contributions=True,
mode=method)
a_tot = a_fs + self.reception.get_depoint_loss() + a_t.value
self.a_g = a_g
self.a_c = a_c
self.a_r = a_r
self.a_s = a_s
self.a_t = a_t
self.a_fs = a_fs
self.a_tot = a_tot
self.p = p
# erasing the dependent variables that will use link atten. for different p value
self.power_flux_density = None
self.antenna_noise_rain = None
self.total_noise_temp = None
self.figure_of_merit = None
self.c_over_n0 = None
self.snr = None
self.cross_pol_discrimination = None
return a_fs, self.reception.get_depoint_loss(
), a_g, a_c, a_r, a_s, a_t, a_tot
def test_map_africa(self):
# Generate a regular grid of latitude and longitudes with 0.1
# degree resolution for the region of interest.
lat, lon = itur.utils.regular_lat_lon_grid(lat_max=60,
lat_min=-60,
lon_max=65,
lon_min=-35,
resolution_lon=1,
resolution_lat=1)
# Satellite coordinates (GEO, 4 E)
lat_sat = 0
lon_sat = 4
h_sat = 35786 * itur.u.km
# Compute the elevation angle between satellite and ground stations
el = itur.utils.elevation_angle(h_sat, lat_sat, lon_sat, lat, lon)
# Set the link parameters
f = 22.5 * itur.u.GHz # Link frequency
D = 1.2 * itur.u.m # Antenna diameters
p = 0.1 # Unavailability (Vals exceeded 0.1% of time)
# Compute the atmospheric attenuation
Att = itur.atmospheric_attenuation_slant_path(lat, lon, f, el, p, D)
# Now we show the surface mean temperature distribution
T = itur.surface_mean_temperature(lat, lon)\
.to(itur.u.Celsius, equivalencies=itur.u.temperature())
# Plot the results
try:
m = itur.utils.plot_in_map(
Att,
lat,
lon,
cbar_text='Atmospheric attenuation [dB]',
cmap='magma')
# Plot the satellite location
m.scatter(lon_sat, lat_sat, c='white', s=20)
m = itur.utils.plot_in_map(
T,
lat,
lon,
cbar_text='Surface mean temperature [C]',
cmap='RdBu_r')
except RuntimeError as e:
print(e)
def atmospheric_attenuation(lat, lng, elevation, pol_skew, freq, availability,
dish_size, dish_eff):
"""Total attenuation due to multiple sources of atmospheric attenuation
A wrapper to obtain the total atmospheric attenuation through ITU-Rpy.
Args:
lat (float): Earth station's latitude in degrees.
lng (float): Earth station's longitude in degrees.
elevation (float): Elevation angle in degrees.
freq (float): Carrier frequency in Hz.
availability (float): Target link availability within [95 to 99.999%].
dish_size (float): Earth station's dish diameter in m.
dish_eff (float): Dish aperture efficiency within [0, 1].
Returns:
float: Total atmospheric attenuation in dB.
"""
f_ghz = freq / 1e9
unavailability = 100 - availability
a_g, a_c, a_r, a_s, a_t = itur.atmospheric_attenuation_slant_path(
lat,
lng,
f_ghz,
elevation,
unavailability,
dish_size,
eta=dish_eff,
tau=pol_skew,
return_contributions=True)
util.log_result("Rain attenuation @ {:g}%".format(unavailability),
"{:.2f}".format(a_r))
util.log_result("Cloud attenuation @ {:g}%".format(unavailability),
"{:.2f}".format(a_c))
util.log_result("Gaseous attenuation @ {:g}%".format(unavailability),
"{:.2f}".format(a_g))
util.log_result("Tropo. scintillation @ {:g}%".format(unavailability),
"{:.2f}".format(a_s))
return a_t.value
def test_single_location_vs_p():
# Ground station coordinates (Boston)
lat_GS = 42.3601
lon_GS = -71.0942
# Satellite coordinates (GEO, 77 W)
lat_sat = 0
lon_sat = -77
h_sat = 35786 * itur.u.km
# Compute the elevation angle between satellite and ground station
el = itur.utils.elevation_angle(h_sat, lat_sat, lon_sat,
lat_GS, lon_GS)
f = 22.5 * itur.u.GHz # Link frequency
D = 1.2 * itur.u.m # Antenna diameters
# Define unavailabilities vector in logarithmic scale
p = np.logspace(-1.5, 1.5, 100)
A_g, A_c, A_r, A_s, A_t = \
itur.atmospheric_attenuation_slant_path(
lat_GS, lon_GS, f, el, p, D, return_contributions=True)
# Plot the results using matplotlib
f, ax = plt.subplots(1, 1)
ax.semilogx(p, A_g.value, label='Gaseous attenuation')
ax.semilogx(p, A_c.value, label='Cloud attenuation')
ax.semilogx(p, A_r.value, label='Rain attenuation')
ax.semilogx(p, A_s.value, label='Scintillation attenuation')
ax.semilogx(p, A_t.value, label='Total atmospheric attenuation')
ax.set_xlabel('Percentage of time attenuation value is exceeded [%]')
ax.set_ylabel('Attenuation [dB]')
ax.grid(which='both', linestyle=':')
plt.legend()
# Satellite coordinates (GEO, 77 W)
lat_sat = 0
lon_sat = -77
h_sat = 35786 * itur.u.km
# Compute the elevation angle between satellite and ground station
el = itur.utils.elevation_angle(h_sat, lat_sat, lon_sat, lat_GS, lon_GS)
f = 22.5 * itur.u.GHz # Link frequency
D = 1.2 * itur.u.m # Antenna diameters
p = 1
f = np.logspace(-0.2, 2, 100) * itur.u.GHz
Ag, Ac, Ar, As, A =\
itur.atmospheric_attenuation_slant_path(lat_GS, lon_GS, f, el, p, D,
return_contributions=True)
# Plot the results
fig, ax = plt.subplots(1, 1)
ax.loglog(f, Ag, label='Gaseous attenuation')
ax.loglog(f, Ac, label='Cloud attenuation')
ax.loglog(f, Ar, label='Rain attenuation')
ax.loglog(f, As, label='Scintillation attenuation')
ax.loglog(f, A, label='Total atmospheric attenuation')
ax.xaxis.set_major_formatter(ScalarFormatter())
ax.yaxis.set_major_formatter(ScalarFormatter())
ax.set_xlabel('Frequency [GHz]')
ax.set_ylabel('Atmospheric attenuation [dB]')
ax.grid(which='both', linestyle=':')
plt.legend()
def ITU_loss(self,
frequency,
link,
location=[41.39, -71.05],
percentage=0.1):
# calculate the matching dish diameter - assume efficiency of 65%
if link == 'downlink':
effective_diameter = (scipy.constants.c /
(np.pi * frequency)) * np.sqrt(
10**(self.gs_rx_antenna_gain / 10) /
0.65) * itur.u.m
else:
effective_diameter = (scipy.constants.c /
(np.pi * frequency)) * np.sqrt(
10**(self.gs_tx_antenna_gain / 10) /
0.65) * itur.u.m
elevation = self.elevation
# convert frequency to GHz
frequency_ghz = (frequency / 1e9) * itur.u.GHz
# Compute atmospheric parameters
hs = itur.topographic_altitude(41.39, -71.05)
T = itur.surface_mean_temperature(41.39, -71.05)
P = itur.models.itu835.pressure(41.39, hs)
rho_p = itur.surface_water_vapour_density(location[0], location[1],
percentage, hs)
rho_sa = itur.models.itu835.water_vapour_density(location[0], hs)
T_sa = itur.models.itu835.temperature(location[0], hs)
V = itur.models.itu836.total_water_vapour_content(
location[0], location[1], percentage, hs)
# Compute rain and cloud-related parameters
R_prob = itur.models.itu618.rain_attenuation_probability(
location[0], location[1], elevation, hs)
R_pct_prob = itur.models.itu837.rainfall_probability(
location[0], location[1])
R001 = itur.models.itu837.rainfall_rate(location[0], location[1],
percentage)
h_0 = itur.models.itu839.isoterm_0(location[0], location[1])
h_rain = itur.models.itu839.rain_height(location[0], location[1])
L_red = itur.models.itu840.columnar_content_reduced_liquid(
location[0], location[1], percentage)
A_w = itur.models.itu676.zenit_water_vapour_attenuation(location[0],
location[1],
percentage,
frequency_ghz,
h=hs)
# Compute attenuation values
A_g = itur.gaseous_attenuation_slant_path(frequency_ghz, elevation,
rho_p, P, T)
A_r = itur.rain_attenuation(location[0],
location[1],
frequency_ghz,
elevation,
hs=hs,
p=percentage)
A_c = itur.cloud_attenuation(location[0], location[1], elevation,
frequency_ghz, percentage)
A_s = itur.scintillation_attenuation(location[0], location[1],
frequency_ghz, elevation,
percentage, effective_diameter)
A_t = itur.atmospheric_attenuation_slant_path(location[0], location[1],
frequency_ghz, elevation,
percentage,
effective_diameter)
# rain attenuation plus all other attenuations
rain = A_r
atmosphere = A_g + A_c + A_s
return float(rain.value), float(atmosphere.value)
gs_name = args.gs_name
gs_lat = args.gs_lat
gs_lon = args.gs_lon
# Ground station coordinates (Blacksburg, Hume)
lat_GS = 37.206831
lon_GS = -80.419138
f = args.freq / 1e9 * u.GHz #Link frequency
D = 0.1 * u.m # Antenna diameters
p = args.exceedance
el = np.linspace(1, 90, 100)
#el[0] = 1e-10
Ag, Ac, Ar, As, A =\
itur.atmospheric_attenuation_slant_path(gs_lat, gs_lon, f, el, p, D,
return_contributions=True)
# Plot the results
xinch = 7
yinch = 4
fig1 = plt.figure(1, figsize=(xinch, yinch / .8))
ax = fig1.add_subplot(1, 1, 1)
#ax.plot(el, Ag, label='Gaseous attenuation')
ax.plot(el, Ac, label='Cloud attenuation')
#ax.plot(el, Ar, label='Rain attenuation')
#ax.plot(el, As, label='Scintillation attenuation')
#ax.plot(el, A, label='Total atmospheric attenuation')
title_str = 'Worst Case ({:1.1f}%) Cloud Attenuation vs Elevation'.format(
p)
ax.xaxis.set_major_formatter(ScalarFormatter())
ax.yaxis.set_major_formatter(ScalarFormatter())
def test_single_location_vs_f():
# Ground station coordinates (Boston)
lat_GS = 42.3601
lon_GS = -71.0942
################################################
# First case: Attenuation vs. frequency #
################################################
# Satellite coordinates (GEO, 77 W)
lat_sat = 0
lon_sat = -77
h_sat = 35786 * itur.u.km
# Compute the elevation angle between satellite and ground station
el = itur.utils.elevation_angle(h_sat, lat_sat, lon_sat,
lat_GS, lon_GS)
f = 22.5 * itur.u.GHz # Link frequency
D = 1.2 * itur.u.m # Antenna diameters
p = 1
f = np.logspace(-0.2, 2, 100) * itur.u.GHz
Ag, Ac, Ar, As, A =\
itur.atmospheric_attenuation_slant_path(lat_GS, lon_GS, f,
el, p, D,
return_contributions=True)
# Plot the results
fig, ax = plt.subplots(1, 1)
ax.loglog(f, Ag, label='Gaseous attenuation')
ax.loglog(f, Ac, label='Cloud attenuation')
ax.loglog(f, Ar, label='Rain attenuation')
ax.loglog(f, As, label='Scintillation attenuation')
ax.loglog(f, A, label='Total atmospheric attenuation')
ax.set_xlabel('Frequency [GHz]')
ax.set_ylabel('Atmospheric attenuation [dB]')
ax.grid(which='both', linestyle=':')
plt.legend()
################################################
# Second case: Attenuation vs. elevation angle #
################################################
f = 22.5 * itur.u.GHz
el = np.linspace(5, 90, 100)
Ag, Ac, Ar, As, A =\
itur.atmospheric_attenuation_slant_path(lat_GS, lon_GS,
f, el, p, D,
return_contributions=True)
# Plot the results
fig, ax = plt.subplots(1, 1)
ax.plot(el, Ag, label='Gaseous attenuation')
ax.plot(el, Ac, label='Cloud attenuation')
ax.plot(el, Ar, label='Rain attenuation')
ax.plot(el, As, label='Scintillation attenuation')
ax.plot(el, A, label='Total atmospheric attenuation')
ax.set_xlabel('Elevation angle [deg]')
ax.set_ylabel('Atmospheric attenuation [dB]')
ax.grid(which='both', linestyle=':')
plt.legend()
# Satellite coordinates (GEO, 4 E)
lat_sat = 0
lon_sat = -77
h_sat = 35786 * itur.u.km
# Compute the elevation angle between satellite and ground stations
el = itur.utils.elevation_angle(h_sat, lat_sat, lon_sat, lat, lon)
# Set the link parameters
f = 22.5 * itur.u.GHz # Link frequency
D = 1.2 * itur.u.m # Antenna diameters
p = 0.1 # Unavailability (Values exceeded 0.1% of time)
# Compute the atmospheric attenuation
Ag, Ac, Ar, As, Att = itur.atmospheric_attenuation_slant_path(
lat, lon, f, el, p, D, return_contributions=True)
# Plot the results
city_idx = np.arange(len(cities))
width = 0.15
fig, ax = plt.subplots(1, 1)
ax.bar(city_idx, Att.value, 0.6, label='Total atmospheric Attenuation')
ax.bar(city_idx - 1.5 * width, Ar.value, width, label='Rain attenuation')
ax.bar(city_idx - 0.5 * width, Ag.value, width, label='Gaseous attenuation')
ax.bar(city_idx + 0.5 * width, Ac.value, width, label='Clouds attenuation')
ax.bar(city_idx + 1.5 * width,
As.value,
width,
label='Scintillation attenuation')
print(
' - Rain height [ITU-R P.839] {0:.1f}'.
format(h_rain))
print(
' - Columnar content of reduced liquid (p={0}%) [ITU-R P.840] {1:.1f}'.
format(p, L_red))
print(
' - Zenit water vapour attenuation (p={0}%) [ITU-R P.676] {1:.1f}'.
format(p, A_w))
# Compute attenuation values
A_g = itur.gaseous_attenuation_slant_path(f, el, rho_p, P, T)
A_r = itur.rain_attenuation(lat, lon, f, el, hs=hs, p=p)
A_c = itur.cloud_attenuation(lat, lon, el, f, p)
A_s = itur.scintillation_attenuation(lat, lon, f, el, p, D)
A_t = itur.atmospheric_attenuation_slant_path(lat, lon, f, el, p, D)
print(('\n\nAttenuation values exceeded for p={0}% of the average year '
'for a link with el={1} deg, f={2}, \nD={3} and '
'receiver ground station located at coordinates ({4}, {5})').format(
p, el, f, D, lat, lon))
print(
' - Rain attenuation [ITU-R P.618] {0:.1f}'.
format(A_r))
print(
' - Gaseous attenuation [ITU-R P.676] {0:.1f}'.
format(A_g))
print(
' - Clouds attenuation [ITU-R P.840] {0:.1f}'.
format(A_c))
