lab2

import numpy as np
import matplotlib.pyplot as plt

# константы
SLOTS = 10 ** 4  # количество слотов
T_rb = 0.5 * (10 ** -3)  # длительность слота (сек)
T = 300  # температура
V = 2 ** 13  # объем данных в 1 пакете (1 Кб)
R = 2500  # радиус БС
Ptx = 10  # мощность излучения станции
f0 = 900  # частота
kn = 2  # коэффициент шума приемника
DF = 0.18  # полоса пропускания канала связи
k = 1.38 * 10 ** -23  # постоянная Больцмана
Pn = DF * T * k * kn  # мощность шума
#print('Pn = {0} * {1} * {2} * {3} = {4}'.format(DF,T,k,kn,Pn))
abonents = [2, 8, 16, 64]  # количество абонентов
H = 30  # высота БС
S = 0  # параметр формулы - маленький город
h_s = 2  # высота точки приёма

lambd_list = np.arange(0, 141, 5)  # значения интенсивности входного потока
p_list = 1 / (lambd_list * T_rb + 1)  # вероятность передачи пакетов


def modeling():
    # цикл по количеству пользователей в системе
    for user_n in abonents:
        # генерация расстояний до абонентов
        dist = np.sqrt(np.random.uniform(0, R ** 2, user_n))

        # расчет параметров затухания по Окумура-Хата
        alpha = (1.1 * np.log10(f0) - 0.7) * h_s - (1.56 * np.log10(f0) - 0.8)
        #print(alpha)
        L_db_list = 10 ** ((46.3 + 33.9 * np.log10(f0) - 13.82 * np.log10(H) - alpha +
                            (44.9 - 6.55 * np.log10(h_s)) * np.log10(dist) + S) / 10)
        #print(dist[0])
        #print(L_db_list[0])

        buffer_volume = []  #  для хранения среднего объема данных в буфере

        # цикл по значениям интенсивности входного потока
        for p, lambd in zip(p_list, lambd_list):
            buffer = np.zeros(user_n)  # инициализация буфера для каждого абонента
            total_data = 0  # суммарный объем данных в буфере

            # цикл по количеству моделируемых слотов
            for slot in range(SLOTS):
                # Расчёт L_i[k] - затухание сигнала
                L_db = L_db_list + np.random.normal(0, 1, user_n)
                Prx = Ptx / L_db
                SNR = Prx / Pn
                #print('Ptx = {0} L = {1} Prx = {2}'.format(Ptx,L_db[0], Prx[0]))
                #print('Prx = {0}, Pn = {1}, SNR = {2}'.format(Prx[0], Pn, SNR))
                # расчёт C_i[k] - пропускная способность абонентов
                C = DF * np.log2(1 + SNR)

                # расчёт V_i[k] - объем передаваемых данных
                V_i = C * T_rb

                # генерация пакетов данных
                pacs = (np.random.geometric(p, user_n) - 1) * V

                # расчёт D_i[k] - обновление буфера
                buffer = np.maximum(0, buffer - V_i) + pacs
                total_data += sum(buffer)

            # расчёт среднего суммарного объема данных в буфере БС
            buffer_volume.append(total_data / SLOTS)
            print(f'Абонентов = {user_n}, lam = {lambd}, Объём данных = {buffer_volume[-1]}')

        # построение графика
        plt.plot(lambd_list, buffer_volume, label=f'Абонентов = {user_n}')

    plt.xlabel('Интенсивность входного потока (пакет/сек)')
    plt.ylabel('Средний суммарный объём данных в буфере (бит)')
    plt.grid()
    plt.legend()
    plt.grid()
    plt.show()

# Запуск моделирования
modeling()