wireless_models.py

import simpy
import numpy as np
from dataclasses import dataclass


@dataclass
class Packet:
    user_id: int
    traffic_type: str
    size_bits: int
    arrival_time: float


@dataclass
class UserStats:
    generated_packets: int = 0
    served_packets: int = 0
    dropped_packets: int = 0
    served_bits: int = 0
    total_delay: float = 0.0


def jains_fairness_index(throughputs):
    x = np.array(throughputs, dtype=float)
    if np.sum(x) == 0:
        return 0.0
    return (np.sum(x) ** 2) / (len(x) * np.sum(x ** 2) + 1e-12)


def normalized_throughput(total_bits_served, link_capacity_bps, interval_s):
    if interval_s <= 0:
        return 0.0
    return min(total_bits_served / (link_capacity_bps * interval_s), 1.0)


class PoissonTraffic:
    def __init__(self, env, ap, user_id, rate_pps, packet_size_bits):
        self.env = env
        self.ap = ap
        self.user_id = user_id
        self.rate_pps = rate_pps
        self.packet_size_bits = packet_size_bits

    def run(self):
        while True:
            inter_arrival = np.random.exponential(1.0 / self.rate_pps)
            yield self.env.timeout(inter_arrival)
            pkt = Packet(
                user_id=self.user_id,
                traffic_type="Poisson",
                size_bits=self.packet_size_bits,
                arrival_time=self.env.now
            )
            self.ap.enqueue_packet(pkt)


class OnOffTraffic:
    def __init__(self, env, ap, user_id, on_rate_pps, packet_size_bits, mean_on=2.0, mean_off=1.0):
        self.env = env
        self.ap = ap
        self.user_id = user_id
        self.on_rate_pps = on_rate_pps
        self.packet_size_bits = packet_size_bits
        self.mean_on = mean_on
        self.mean_off = mean_off

    def run(self):
        while True:
            on_duration = np.random.exponential(self.mean_on)
            off_duration = np.random.exponential(self.mean_off)

            end_on = self.env.now + on_duration
            while self.env.now < end_on:
                inter_arrival = np.random.exponential(1.0 / self.on_rate_pps)
                yield self.env.timeout(inter_arrival)
                pkt = Packet(
                    user_id=self.user_id,
                    traffic_type="ON/OFF",
                    size_bits=self.packet_size_bits,
                    arrival_time=self.env.now
                )
                self.ap.enqueue_packet(pkt)

            yield self.env.timeout(off_duration)


class PeriodicTraffic:
    def __init__(self, env, ap, user_id, period_s, packet_size_bits):
        self.env = env
        self.ap = ap
        self.user_id = user_id
        self.period_s = period_s
        self.packet_size_bits = packet_size_bits

    def run(self):
        while True:
            yield self.env.timeout(self.period_s)
            pkt = Packet(
                user_id=self.user_id,
                traffic_type="Periodic",
                size_bits=self.packet_size_bits,
                arrival_time=self.env.now
            )
            self.ap.enqueue_packet(pkt)