Выводы:

В ходе выполнения лабораторной работы были получены навыки моделирования стандартных сценариев работы телекоммуникационных систем с топологией типа «звезда», изучены свойства алгоритмов планирования ресурсов нисходящего кадра Maximum Throughput, Proportion Fair и Equal Blind в подобных системах.

Алгоритм Maximum Throughput показал наибольшую суммарную скорость передачи данных. Это объясняется тем, что все ресурсы выделялись абоненту с максимальной скоростью. С увеличением количества абонентов суммарная скорость возрастала, так как возрастала вероятность наличия пользователя с высокой скоростью. Средняя скорость снижалась по мере роста числа абонентов, но оставалась выше, чем у других алгоритмов. Минимальная скорость была равна нулю во всех случаях, кроме случая с одним абонентом, поскольку алгоритм предоставляет все ресурсы одному пользователю.

Алгоритм Proportion Fair обеспечил стабильные результаты по суммарной скорости — 30–35 Мбит/с для каждого числа абонентов. Средняя скорость передачи данных уменьшалась с ростом числа пользователей, так как ресурсы делились между всеми участниками сети. Минимальная скорость также снижалась, но оставалась выше, чем у алгоритма Maximum Throughput, благодаря более справедливому распределению ресурсов. Алгоритм показал баланс между общей производительностью и равномерностью распределения пропускной способности.

Алгоритм Equal Blind обеспечил равное распределение ресурсов между всеми абонентами без учёта качества связи. В результате суммарная скорость снизилась с 30 Мбит/с для одного абонента до 21 Мбит/с для 64 абонентов. Средняя скорость уменьшалась с ростом количества пользователей, минимальная скорость равна средней, так как ресурсы делились поровну. Алгоритм показал наименьшую суммарную производительность, но обеспечил одинаковые условия для всех абонентов независимо от их пропускной способности.

Приложение

Листинг 3 - Программная реализация моделирования

import numpy as np

import matplotlib.pyplot as plt

np.random.seed(123) # Зерно рандома для воспроизводимости результатов

# Параметры

R = 2500 # Радиус окружности (м)

num_experiments = 100 # Количество экспериментов

num_users_range = [1, 2, 4, 8, 16, 32, 64] # Количество абонентов

# Параметры для модели Окамура-Хата

Ptx = 10 # Мощность излучаемого сигнала (Вт)

F0 = 900 # Частота БС (МГц)

DF = 10 * 10**6 # Полоса пропускания канала связи (Гц)

KN = 2 # Коэффициент шума приемника

K = 1.38 * 10**(-23) # Постоянная Больцмана

T = 300 # Абсолютная температура (К)

Hbs = 40 # Высота БС (м)

Hrx = 1.7 # Высота абонента (м)

S = 0

Pn = K * T * DF * KN # Мощность шума

# Функция для расчета потерь по модели Окамура-Хата

def okumura_hata(d, f0, hbs, hrx, s):

# Преобразуем расстояние в километры

d_km = d / 1000

# Расчет коэффициента a(hrx)

a_hrx = (1.1 * np.log10(f0) - 0.7) * hrx - (1.56 * np.log10(f0) - 0.8)

# Расчет потерь по модели Окамура-Хата

L_db = 46.3 + 33.9 * np.log10(f0) - 13.82 * np.log10(hbs) - a_hrx + (44.9 - 6.55 * np.log10(hrx)) * np.log10(d_km) + s

return L_db

# Функция для расчета мощности принятого сигнала

def calculate_received_power(d, Ptx, f0, hbs, hrx, s):

L_db = okumura_hata(d, f0, hbs, hrx, s)

Prx = Ptx / (10 ** (L_db / 10)) # Принятая мощность в ваттах

return Prx

# Функция для расчета SNR

def calculate_snr(d, Ptx, f0, hbs, hrx, s):

Prx = calculate_received_power(d, Ptx, f0, hbs, hrx, s)

snr = Prx / Pn

return snr

# Функция для расчета пропускной способности (скорости)

def calculate_data_rate(snr, DF):

return DF * np.log2(1 + snr)

# Функция для размещения абонентов внутри окружности

def place_users(N, R):

angles = np.random.uniform(0, 2 * np.pi, N)

radii = np.sqrt(np.random.uniform(0, R**2, N))

return angles, radii

# Функция для расчета максимально достижимых скоростей

def calculate_speeds(radii):

distances = radii

speeds = []

for d in distances:

snr = calculate_snr(d, Ptx, F0, Hbs, Hrx, S)

speed = calculate_data_rate(snr, DF)

speeds.append(speed)

return np.array(speeds)

### Алгоритмы распределения ресурсов

def equal_blind(C):

alpha = (1 / C) / np.sum(1 / C)

return alpha

def maximum_throughput(C):

alpha = np.zeros_like(C)

alpha[np.argmax(C)] = 1 # Все ресурсы отдаются абоненту с максимальной скоростью

return alpha

def proportion_fair(C):

alpha = np.ones_like(C) / len(C)

return alpha

# Функция для расчета метрик

def calculate_metrics(C, alpha):

fact_speeds = alpha * C

total_speed = np.sum(fact_speeds) / 10**6 # Суммарная скорость в Мбит/с

avg_speed = np.mean(fact_speeds) / 10**6 # Средняя скорость в Мбит/с

min_speed = np.min(fact_speeds) / 10**6 # Минимальная скорость в Мбит/с

return total_speed, avg_speed, min_speed

# Основной цикл для экспериментов

results = {'Equal Blind': {'total': [], 'avg': [], 'min': []},

'Maximum Throughput': {'total': [], 'avg': [], 'min': []},

'Proportion Fair': {'total': [], 'avg': [], 'min': []}}

for N in num_users_range:

total_EB, avg_EB, min_EB = [], [], []

total_MT, avg_MT, min_MT = [], [], []

total_PF, avg_PF, min_PF = [], [], []

for _ in range(num_experiments):

angles, radii = place_users(N, R)

speeds = calculate_speeds(radii)

# Equal Blind

alpha_EB = equal_blind(speeds)

total, avg, min_ = calculate_metrics(speeds, alpha_EB)

total_EB.append(total)

avg_EB.append(avg)

min_EB.append(min_)

# Maximum Throughput

alpha_MT = maximum_throughput(speeds)

total, avg, min_ = calculate_metrics(speeds, alpha_MT)

total_MT.append(total)

avg_MT.append(avg)

min_MT.append(min_)

# Proportion Fair

alpha_PF = proportion_fair(speeds)

total, avg, min_ = calculate_metrics(speeds, alpha_PF)

total_PF.append(total)

avg_PF.append(avg)

min_PF.append(min_)

results['Equal Blind']['total'].append(np.mean(total_EB))

results['Equal Blind']['avg'].append(np.mean(avg_EB))

results['Equal Blind']['min'].append(np.mean(min_EB))

results['Maximum Throughput']['total'].append(np.mean(total_MT))

results['Maximum Throughput']['avg'].append(np.mean(avg_MT))

results['Maximum Throughput']['min'].append(np.mean(min_MT))

results['Proportion Fair']['total'].append(np.mean(total_PF))

results['Proportion Fair']['avg'].append(np.mean(avg_PF))

results['Proportion Fair']['min'].append(np.mean(min_PF))

# Вывод результатов

def print_results(results):

    print("{:<15} {:<10} {:<15} {:<15} {:<15}".format(

        "Алгоритм", "N", "Суммарная (Мбит/с)", "Средняя (Мбит/с)", "Минимальная (Мбит/с)"

    ))

    print("-" * 70)

   

    for algorithm in results:

        for i, N in enumerate(num_users_range):

            total = results[algorithm]['total'][i]

            avg = results[algorithm]['avg'][i]

            min_speed = results[algorithm]['min'][i]

            print("{:<15} {:<10} {:<15.2f} {:<15.2f} {:<15.2f}".format(

                algorithm, N, total, avg, min_speed

            ))

        print("-" * 70)

print_results(results)

# Визуализация результатов

def plot_results(results, metric, title, ylabel):

    plt.figure(figsize=(10, 6))

    for strategy in results:

        if strategy == 'Equal Blind':

            label = f'{strategy} (ПРС)'

        elif strategy == 'Maximum Throughput':

            label = f'{strategy} (ПСС)'

        elif strategy == 'Proportion Fair':

            label = f'{strategy} (ПРД)'

        plt.plot(num_users_range, results[strategy][metric], label=label, alpha=0.7)

    plt.xlabel('Количество абонентов')

    plt.ylabel(ylabel)

    plt.title(title)

    plt.legend()

    plt.grid(True)

    plt.xticks(num_users_range)

    plt.show()

# Графики для каждой метрики

plot_results(results, 'total', 'Суммарная скорость передачи данных (Мбит/с)', 'Суммарная скорость (Мбит/с)')

plot_results(results, 'avg', 'Средняя скорость передачи данных (Мбит/с)', 'Средняя скорость (Мбит/с)')

plot_results(results, 'min', 'Минимальная скорость передачи данных (Мбит/с)', 'Минимальная скорость (Мбит/с)')

# Визуализация распределения абонентов в полярной системе координат

angles, radii = place_users(64, R)  # Пример для 64 абонентов

plt.figure(figsize=(8, 8))

ax = plt.subplot(111, projection='polar')

ax.scatter(angles, radii, s=30, label='Абоненты')

ax.plot(0, 0, color='red', marker='o', markersize=10, label='Базовая станция')

ax.set_theta_zero_location('E')

ax.set_theta_direction(1)

ax.grid(True)

ax.set_title('Распределение 64 абонентов вокруг базовой станции', pad=20)

ax.legend(loc='upper right')

plt.show()