Приложение а «Генерация абонентов, расчёт расстояния, потерь, скоростей»

import numpy as np

from matplotlib import pyplot as plt

# константы

R = 300 # радиус действия БС

Ptx = 0.1 #

f0 = 4000 # частота

df = 180 * 10**3 # частота пропускания канала

kn = 3 # коэффициент теплового шума

T = 300 # температура (К)

K = 1.380649 * 10 -23 # постоянная Больцмана

Pn = df * T * K * kn # мощность теплового шума

SLOTS = 10**3 # количество слотов

K_ITU = 29 # коэффициент типа помещения ?

subs_list = [2,4,8,16] # Список кол-ва АБ

algoritm_list = ['Maximum Throughput', 'Equal Blind', 'Proportional fair'] # названия алгоритмов рр

T_rb = 0.5 * (10 -3) # длительность слота

y = 1 # последняя секунда

y_slot = round(y / T_rb) # кол-во слотов, на которых рассчитывается ср скорость

Nrb = 100 # кол-во ресурсных блоков

V = 2**13 # объем данных в пакете (1Кб)

lambd_list = np.arange(1, 10, 1) # значения интенсивности входного потока

buffer_scores_by_alg = {}

def generate_ab(n, lam):

# Генерация случайных расстояний пользователей до базовой станции

dist = np.sqrt(np.random.uniform(0, R**2, n))

L_list = 10 ((20 * np.log10(f0) + K_ITU * np.log10(dist) - 28) / 10)

subs = []

packs = []

for L in L_list:

# случайная помеха

fading_dB = np.random.normal(loc=0, scale=1, size=SLOTS)

# Суммарное затухание в дБ

total_loss_dB = 10 * np.log10(L) + fading_dB # L уже в линейной шкале

# Перевод в линейную шкалу: L_total = 10^(total_dB / 10)

L_total = 10 (total_loss_dB / 10)

# Мощность на приёме (в линейной шкале)

Prx = Ptx / L_total

SNR = Prx / Pn

CC = df * np.log2(1 + SNR)

subs.append(list(CC * T_rb))

# Генерация количества пакетов

user_packs = [(np.random.poisson(lam=lam)) * V for _ in range(SLOTS)]

packs.append(user_packs)

return subs, packs

Приложение б «Моделирование работы передачи данных, вычисление среднего объёма данных в буферах»

def get_avg_score(subs, packs , algorithm):

subs_cnt = len(subs)

for _ in range(subs_cnt)] # случайное число пакетов

buffer = [[packs[i][0] for i in range(subs_cnt)]] # начальное число пакетов в буфере

slot_resource_blocks = [[]] # ресурсные блоки

sub_R_mean_list = [[get_avg_R(slot_resource_blocks, subs, i, 0) for i in range(subs_cnt)]] # ср зн скорости передачи для первого слота

cur_sub_idx = 0

# перебор слотов

for slot_idx in range(SLOTS):

# распределение нагрузки

if algorithm in ['Equal Blind', 'Proportional fair']:

sub_R_mean_list.append([

get_avg_R_smooth(slot_resource_blocks, subs, i, slot_idx, sub_R_mean_list[-1])

for i in range(subs_cnt)])

# Список абонентов, у которых буфер в текущем слоте не пустой

sub_with_full_buffer = [i % subs_cnt for i in range(cur_sub_idx, cur_sub_idx + subs_cnt)

if buffer[-1][i % subs_cnt] != 0]

# установление приоритета

cur_sub_idx = (cur_sub_idx + 1) % subs_cnt

# оставшиеся данные копируем в следующий слот

buffer.append(buffer[-1].copy())

# получение очереди аб, по приоритету

if sub_with_full_buffer:

subs_priority_idx = get_sub_index([subs[i][slot_idx] for i in range(subs_cnt)], algorithm,sub_with_full_buffer, sub_R_mean_list[-1])

new_slot_res_block = []

# перебор аб

for sub_idx in subs_priority_idx:

# выделение ресурсных блоков

sub_res_block_cnt = int(np.ceil(buffer[-1][sub_idx] / subs[sub_idx][slot_idx]))

new_slot_res_block.extend([sub_idx] * sub_res_block_cnt)

if len(new_slot_res_block) >= Nrb: # ресурсные блоки кончились (всего 100)

break

slot_resource_blocks.append(new_slot_res_block[:Nrb])

# передача данных приоритетам

for sub_idx in [i for i in slot_resource_blocks[-1] if i != -1]:

buffer[-1][sub_idx] = max(0, buffer[-1][sub_idx] - subs[sub_idx][slot_idx])

else:

slot_resource_blocks.append([]) # нечего передавать

buffer[-1] = [buf + packs[i][slot_idx] for i, buf in enumerate(buffer[-1])]

return np.mean([sum(slot) for slot in buffer]) # средний суммарный объем