most-queue 1.60__tar.gz → 1.62__tar.gz

{most_queue-1.60 → most_queue-1.62}/.gitignore

@@ -162,4 +162,4 @@ cython_debug/
 
 .vscode
 
-/works/results/
+works/negative_queues/results/*

{most_queue-1.60 → most_queue-1.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.60
+Version: 1.62
 Summary: Software package for calculation and simulation of queuing systems
 Project-URL: Homepage, https://github.com/xabarov/most-queue
 Author-email: Xabarov Roman <xabarov1985@gmail.com>
@@ -41,7 +41,7 @@ Description-Content-Type: text/markdown
 
 # Queueing Systems: Simulation & Numerical Methods 🔄
 
-![Queue](assets/queue_long.png)
+![Queue](assets/3.gif)
 
 A Python package for simulating and analyzing queueing systems (QS) and networks. 
 
@@ -129,8 +129,8 @@ Most_queue consists of two main parts:
 
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
-| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
-| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
+| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
 
 
 ### Others
@@ -139,7 +139,10 @@ Most_queue consists of two main parts:
 | 1.  | M<sup>x</sup>/M/1          |  Solving for the of M<sup>x</sup>/M/1 QS with batch arrival    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_batch.py) | |
 | 2.  | M/M/1/D         |  Solving for M/M/1 with exponential impatience     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_impatience.py) | |
 | 3. | M/M/1/N          |  Solving for the Engset model for M/M/1 with a finite number of sources.     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_engset.py) | |
-| 4.  | General Network |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_im_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 4.  | Queuing Network |  Numerical calculation of queuing network     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_no_prty.py) |  |
+| 5.  | Queuing Network with Priorities  |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_sim_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 6.  | Queuing Network Optimization  | Optimization of queuing network transition matrix     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_opt.py) |  |
+
 
 ---
 

{most_queue-1.60 → most_queue-1.62}/README.md

@@ -1,6 +1,6 @@
 # Queueing Systems: Simulation & Numerical Methods 🔄
 
-![Queue](assets/queue_long.png)
+![Queue](assets/3.gif)
 
 A Python package for simulating and analyzing queueing systems (QS) and networks. 
 
@@ -88,8 +88,8 @@ Most_queue consists of two main parts:
 
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
-| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
-| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
+| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
 
 
 ### Others
@@ -98,7 +98,10 @@ Most_queue consists of two main parts:
 | 1.  | M<sup>x</sup>/M/1          |  Solving for the of M<sup>x</sup>/M/1 QS with batch arrival    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_batch.py) | |
 | 2.  | M/M/1/D         |  Solving for M/M/1 with exponential impatience     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_impatience.py) | |
 | 3. | M/M/1/N          |  Solving for the Engset model for M/M/1 with a finite number of sources.     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_engset.py) | |
-| 4.  | General Network |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_im_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 4.  | Queuing Network |  Numerical calculation of queuing network     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_no_prty.py) |  |
+| 5.  | Queuing Network with Priorities  |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_sim_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 6.  | Queuing Network Optimization  | Optimization of queuing network transition matrix     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_opt.py) |  |
+
 
 ---
 

{most_queue-1.60 → most_queue-1.62}/most_queue/general/distribution_params.py

@@ -35,6 +35,15 @@ class GammaParams:
     g: list[float] | None = None
 
 
+@dataclass
+class WeibullParams:
+    """
+     Weibull distribution parameters.
+    """
+    k: float  # Shape parameter
+    W: float  # Scale parameter
+
+
 @dataclass
 class GaussianParams:
     """

{most_queue-1.60 → most_queue-1.62}/most_queue/general/tables.py

@@ -320,3 +320,5 @@ def print_mrx(mrx, is_short=False):
                 print(f"{color}{mrx[i, j]:^5.3f} | ", end="")
         print("\n" + "-------" *
               col if is_short or mrx[i, j].imag == 0.0 else "\n" + "---------------" * col)
+
+    print(f'{Style.RESET_ALL}')

{most_queue-1.60 → most_queue-1.62}/most_queue/misc/flow_sum.py

@@ -1,9 +1,9 @@
 import matplotlib
 import matplotlib.pyplot as plt
 
-from most_queue.theory.utils.flow_sum import SummatorNumeric
 from most_queue.rand_distribution import GammaDistribution
 from most_queue.sim.flow_sum import FlowSumSim
+from most_queue.theory.utils.flow_sum import SummatorNumeric
 
 matplotlib.use('TkAgg')
 
@@ -19,7 +19,7 @@ def test():
     mean = 1  # среднее каждого потока
     num_of_jobs = 400000  # количество заявок для ИМ
     is_semi = False  # True, если необходимо использовать метод семиинвариантов вместо H2
-    distr_im = "Gamma"  # распределение, используемое для ИМ
+    distr_sim = "Gamma"  # распределение, используемое для ИМ
 
     # число суммируемых потоков
     ns = [x + 2 for x in range(n_nums - 1)]
@@ -38,7 +38,7 @@ def test():
     # i - кол-во суммируемых потоков, j - номер начального момента
 
     # ИМ
-    s_sim = FlowSumSim(a, distr=distr_im, num_of_jobs=num_of_jobs)
+    s_sim = FlowSumSim(a, distr=distr_sim, num_of_jobs=num_of_jobs)
     # в  s_sim._flows[i][j] содержатся начальные моменты суммируемых потокоы,
     s_sim.sum_flows()
     # i - кол-во суммируемых потоков, j - номер начального момента

{most_queue-1.60 → most_queue-1.62}/most_queue/rand_distribution.py

@@ -16,10 +16,135 @@ from most_queue.general.distribution_params import (
     H2Params,
     ParetoParams,
     UniformParams,
+    WeibullParams
 )
 from most_queue.general.interfaces import Distribution
 
 
+class Weibull(Distribution):
+    """
+    Class for working with the Weibull distribution
+    """
+
+    def __init__(self, params: WeibullParams, generator=None):
+        """
+        :param params: WeibullParams object containing shape parameter (k) and scale parameter (T)
+        :param generator: random number generator. If None, np.random is used.
+        """
+
+        self.k = params.k
+        self.W = params.W
+        self.params = params
+        self.type = 'Weibull'
+        self.generator = generator
+
+    @staticmethod
+    def generate_static(params: WeibullParams, generator=None):
+        """
+        Generates a random number according to the Weibull distribution.
+        """
+        if generator:
+            p = generator.random()
+        else:
+            p = np.random.rand()
+        return math.pow(-math.log(p)*params.W, -1 / params.k)
+
+    def generate(self) -> float:
+        """
+        Generates a random number according to the Weibull distribution.
+        """
+
+        return self.generate_static(self.params, self.generator)
+
+    @staticmethod
+    def calc_theory_moments(params: WeibullParams, num: int) -> list[float]:
+        """
+        Calculates theoretical moments of the distribution up to the specified order.
+        :param params: WeibullParams parameters for the distribution.
+        :param num: number of moments to calculate.
+        :return: list[float]
+        """
+        f = [0.0]*num
+        for i in range(num):
+            f[i] = math.gamma(1 + i/params.k) * math.pow(params.W, i/params.k)
+        return f
+
+    @staticmethod
+    def get_params(moments: list[float]) -> WeibullParams:
+        """
+        Parameter selection for the distribution based 
+        on initial moments of the distribution 
+
+        params:
+            moments: initial moments of the random variable
+
+       return:
+            WeibullParams 
+
+        """
+        a = moments[1] / (moments[0] * moments[0])
+        u0 = math.log(2 * a) / (2.0 * math.log(2))
+        ee = 1e-6
+        u1 = (1.0 / (2 * math.log(2))) * math.log(
+            a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5))
+        delta = u1 - u0
+        while math.fabs(delta) > ee:
+            u1 = (1.0 / (2 * math.log(2))) * math.log(
+                a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5))
+            delta = u1 - u0
+            u0 = u1
+        k = 1 / u1
+        big_w = math.pow(moments[0] / math.gamma(u1 + 1), k)
+
+        return WeibullParams(k=k, W=big_w)
+
+    @staticmethod
+    def get_params_by_mean_and_coev(f1: float, coev: float) -> WeibullParams:
+        """
+        Subselect parameters of Weibull distribution by the given mean and coefficient of variation.
+         Args:
+             f1 (float): The first parameter of the Weibull distribution.
+             coev (float): The coefficient of variation.
+         Returns:
+             WeibullParams
+        """
+
+        f = [0, 0, 0]
+        alpha = 1 / (coev ** 2)
+        f[0] = f1
+        f[1] = pow(f[0], 2) * (pow(coev, 2) + 1)
+        f[2] = f[1] * f[0] * (1.0 + 2 / alpha)
+
+        return Weibull.get_params(f)
+
+    @staticmethod
+    def get_tail(params: WeibullParams, t: float) -> float:
+        """
+        Calculate the tail probability of a Weibull distribution at a given value.
+         Args:
+            params (WeibullParams): The parameters of Weibull distribution
+            t: The value at which to calculate the tail probability.
+        """
+        k = params.k
+        big_w = params.W
+
+        return math.exp(-math.pow(t, k) / big_w)
+
+    @staticmethod
+    def get_cdf(params: WeibullParams, t: float) -> float:
+        """
+        Calculate the cumulative distribution function (CDF) of a Weibull distribution for a given set of values.
+         Args:
+            params (WeibullParams): The parameters of Weibull distribution
+            t: The value at which to calculate the cdf probability.
+
+        """
+        k = params.k
+        big_w = params.W
+
+        return 1.0 - math.exp(-math.pow(t, k) / big_w)
+
+
 class NormalDistribution(Distribution):
     """
     Gaussian distribution. Generates random numbers from a normal (Gaussian) distribution.
@@ -806,7 +931,8 @@ class ErlangDistribution(Distribution):
     @staticmethod
     def get_params_by_mean_and_coev(f1: float, coev: float) -> ErlangParams:
         """
-        Method selects the parameters of the Erlang distribution by mean and coefficient of variation.
+        Method selects the parameters of the Erlang distribution 
+        by mean and coefficient of variation.
         """
         f = [0, 0]
         f[0] = f1

{most_queue-1.60 → most_queue-1.62}/most_queue/sim/base.py

@@ -105,7 +105,8 @@ class QsSim:
 
         self.is_set_source_params = True
 
-        self.source = create_distribution(params, kendall_notation, self.generator)
+        self.source = create_distribution(
+            params, kendall_notation, self.generator)
 
         self.arrival_time = self.source.generate()
 
@@ -137,14 +138,17 @@ class QsSim:
                             self.server_kendall_notation,
                             self.server_params, self.n)
 
-    def send_task_to_channel(self, is_warm_start=False):
+    def send_task_to_channel(self, is_warm_start=False, tsk=None):
         """
         Sends a job to the service channel
         """
+
+        if tsk is None:
+            tsk = Task(self.ttek)
+            tsk.wait_time = 0
+
         for s in self.servers:
             if s.is_free:
-                tsk = Task(self.ttek)
-                tsk.wait_time = 0
                 self.taked += 1
                 self.refresh_w_stat(tsk.wait_time)
                 self.zero_wait_arrivals_num += 1
@@ -159,42 +163,53 @@ class QsSim:
 
                 break
 
-    def send_task_to_queue(self):
+    def send_task_to_queue(self, new_tsk=None):
         """
         Send Task to Queue
         """
-        if self.buffer is None:  # queue length is not specified, i.e. infinite queue
+
+        if new_tsk is None:
             new_tsk = Task(self.ttek)
             new_tsk.start_waiting_time = self.ttek
+
+        if self.buffer is None:  # queue length is not specified, i.e. infinite queue
+
             self.queue.append(new_tsk)
         else:
             if self.queue.size() < self.buffer:
-                new_tsk = Task(self.ttek)
-                new_tsk.start_waiting_time = self.ttek
                 self.queue.append(new_tsk)
             else:
                 self.dropped += 1
                 self.in_sys -= 1
 
-    def arrival(self):
+    def arrival(self, moment=None, ts=None):
         """
         Actions upon arrival of the job by the QS.
         """
-
+        
         self.arrived += 1
         self.p[self.in_sys] += self.arrival_time - self.ttek
 
-        self.in_sys += 1
-        self.ttek = self.arrival_time
-        self.arrival_time = self.ttek + self.source.generate()
+        if moment:
+            self.ttek = moment
+            ts.arr_time = moment
+            ts.wait_time = 0
+            ts.start_waiting_time = -1
+            ts.time_to_end_service = 0
+            
+        else:
+            self.ttek = self.arrival_time
+            self.arrival_time = self.ttek + self.source.generate()
 
+        self.in_sys += 1
+        
         if self.free_channels == 0:
-            self.send_task_to_queue()
+            self.send_task_to_queue(new_tsk=ts)
 
         else:  # there are free channels:
-            self.send_task_to_channel()
+            self.send_task_to_channel(tsk=ts)
 
-    def serving(self, c):
+    def serving(self, c, is_network=False):
         """
         Actions upon receipt of a service job with - channel number
         """
@@ -219,9 +234,12 @@ class QsSim:
                 self.refresh_busy_stat(self.ttek - self.start_busy)
 
         if self.queue.size() != 0:
-            self.send_head_of_queue_to_channel(c)
+            self.send_head_of_queue_to_channel(c, is_network=is_network)
+            
+        if is_network:
+            return end_ts
 
-    def send_head_of_queue_to_channel(self, channel_num):
+    def send_head_of_queue_to_channel(self, channel_num, is_network=False):
         """
         Send first Task (head of queue) to Channel
         """
@@ -232,6 +250,8 @@ class QsSim:
 
         self.taked += 1
         que_ts.wait_time += self.ttek - que_ts.start_waiting_time
+        if is_network:
+            que_ts.wait_network += self.ttek - que_ts.start_waiting_time
         self.refresh_w_stat(que_ts.wait_time)
 
         self.servers[channel_num].start_service(que_ts, self.ttek)

most_queue-1.62/most_queue/sim/networks/network.py

@@ -0,0 +1,181 @@
+"""
+Simulation of a priority network with priorities and multiple channels.
+"""
+import math
+
+import numpy as np
+from colorama import Fore, Style, init
+from tqdm import tqdm
+
+from most_queue.rand_distribution import ExpDistribution
+from most_queue.sim.base import QsSim
+from most_queue.sim.utils.tasks import Task
+
+init()
+
+
+class NetworkSimulator:
+    """
+    Simulation of network with multiple channels in each node.
+    """
+
+    def __init__(self, arrival_rate: float, R: np.matrix, n: list[int],
+                 serv_params):
+        """
+        arrival_rate: arrival rate of tasks.
+
+        R: routing matrix
+        n: list of number of channels in each node.
+
+        serv_params: list of dictionaries with service parameters for each node 
+            [m][dict(type, params)]
+            where m - node number, 
+            type - distribution type, params - distribution parameters.
+        """
+        self.arrival_time = arrival_rate
+        self.R = R  
+        self.n_num = len(n)  # number of nodes
+        self.nodes = n  # n[i] - number of channels in node i
+
+        self.serv_params = serv_params
+
+        self.qs = []
+
+        for m in range(self.n_num):
+            self.qs.append(QsSim(n[m]))
+            self.qs[m].set_servers(serv_params[m]['params'], kendall_notation=serv_params[m]['type'])
+
+        self.source = ExpDistribution(self.arrival_time)
+        self.arrival_time = self.source.generate()
+        self.v_network = [0.0] * 3
+        self.w_network = [0.0] * 3
+
+        self.ttek = 0
+        self.total = 0
+        self.served = 0
+        self.in_sys = 0
+        self.arrived = 0
+
+    def choose_next_node(self, current_node):
+        """
+        Choose the next node for a task based on the current node
+        :param current_node: The current node of the task.
+        :return: The index of the next node.
+        """
+        sum_p = 0
+        p = np.random.rand()
+        for i in range(self.R.shape[0]):
+            sum_p += self.R[current_node + 1, i]
+            if sum_p > p:
+                return i
+        return 0
+
+    def refresh_v_stat(self, new_a):
+        """
+        Refresh sojourn time statistics
+        :param new_a: The new arrival time.
+        """
+        factor = (1.0 - (1.0 / self.served))
+        a_pow = [math.pow(new_a, i + 1) for i in range(3)]
+        for i in range(3):
+            self.v_network[i] = self.v_network[i] * \
+                factor + a_pow[i] / self.served
+
+    def refresh_w_stat(self, new_a):
+        """
+        Refresh waiting time statistics 
+        :param new_a: The new arrival time.
+
+        """
+        factor = (1.0 - (1.0 / self.served))
+        a_pow = [math.pow(new_a, i + 1) for i in range(3)]
+        for i in range(3):
+            self.w_network[i] = self.w_network[i] * \
+                factor + a_pow[i] / self.served
+
+    def run_one_step(self):
+        """
+        Run one step of the simulation.
+        """
+        num_of_serv_ch_earlier = -1  # номер канала узла, мин время до окончания обслуживания
+        num_of_node_earlier = -1  # номер узла, в котором раньше всех закончится обслуживание
+        arrival_earlier = 1e10  # момент прибытия ближайшего
+        serving_earlier = 1e10  # момент ближайшего обслуживания
+
+        if self.arrival_time < arrival_earlier:
+            arrival_earlier = self.arrival_time
+
+        for node in range(self.n_num):
+            for c in range(self.nodes[node]):
+                if self.qs[node].servers[c].time_to_end_service < serving_earlier:
+                    serving_earlier = self.qs[node].servers[c].time_to_end_service
+                    num_of_serv_ch_earlier = c
+                    num_of_node_earlier = node
+
+        if arrival_earlier < serving_earlier:
+            self.on_arrival(arrival_earlier)
+        else:
+            self.on_serving(serving_earlier,
+                            num_of_serv_ch_earlier, num_of_node_earlier)
+
+    def on_arrival(self, arrival_earlier):
+        """
+        Handle arrival event
+        """
+        self.ttek = arrival_earlier
+        self.arrived += 1
+        self.in_sys += 1
+
+        self.arrival_time = self.ttek + self.source.generate()
+
+        next_node = self.choose_next_node(-1)
+
+        ts = Task(self.ttek, is_network=True)
+
+        self.qs[next_node].arrival(self.ttek, ts)
+
+    def on_serving(self, serving_earlier, num_of_serv_ch_earlier, num_of_node_earlier):
+        """
+        Handle serving event
+        """
+        self.ttek = serving_earlier
+        ts = self.qs[num_of_node_earlier].serving(
+            num_of_serv_ch_earlier, True)
+
+        next_node = self.choose_next_node(num_of_node_earlier)
+
+        if next_node == self.n_num:
+            self.served += 1
+            self.in_sys -= 1
+
+            self.refresh_v_stat(self.ttek - ts.arr_network)
+            self.refresh_w_stat(ts.wait_network)
+
+        else:
+            self.qs[next_node].arrival(self.ttek, ts)
+
+    def run(self, job_served, is_real_served=True):
+        """
+        Run simulation
+        """
+        if is_real_served:
+            last_percent = 0
+
+            with tqdm(total=100) as pbar:
+                while self.served < job_served:
+                    self.run_one_step()
+                    percent = int(100*(self.served/job_served))
+                    if last_percent != percent:
+                        last_percent = percent
+                        pbar.update(1)
+                        pbar.set_description(Fore.MAGENTA + '\rJob served: ' +
+                                             Fore.YELLOW + f'{self.served}/{job_served}' + Fore.LIGHTGREEN_EX)
+        else:
+            print(Fore.GREEN + '\rStart simulation')
+            print(Style.RESET_ALL)
+
+            for _ in tqdm(range(job_served)):
+                self.run_one_step()
+
+            print(Fore.GREEN + '\rSimulation is finished')
+            print(Style.RESET_ALL)

{most_queue-1.60 → most_queue-1.62}/most_queue/sim/priority.py

@@ -60,12 +60,9 @@ class PriorityQueueSimulator:
 
         # probability of states of the system (number of requests in it j):
         self.p = []
-        if self.prty_type == "No":
-            # for no priority system, we have one queue for all classes of requests:
-            self.queue = []  # queue of Task's
-        else:
-            for _ in range(self.k):
-                self.queue.append([])
+        
+        for _ in range(self.k):
+            self.queue.append([])
 
         for _ in range(self.k):
             self.busy.append([0, 0, 0])
@@ -369,12 +366,12 @@ class PriorityQueueSimulator:
         """
         if not self.buffer:  # no buffer, infinite queue length
             new_tsk.start_waiting_time = self.ttek
-            self.queue.append(new_tsk)
+            self.queue[k].append(new_tsk)
         else:
 
             if len(self.queue) < self.buffer:
                 new_tsk.start_waiting_time = self.ttek
-                self.queue.append(new_tsk)
+                self.queue[k].append(new_tsk)
             else:
                 self.dropped[k] += 1
                 self.in_sys[k] -= 1
@@ -473,13 +470,14 @@ class PriorityQueueSimulator:
         self.refresh_w_stat(k, end_ts.wait_time)
         self.in_sys[k] -= 1
 
-        if len(self.queue[k]) == 0 and self.free_channels == 1:
-            if self.in_sys[k] == self.n - 1 and self.class_busy_started != -1:
-                # End of busy period
-                self.busy_moments[k] += 1
-                self.refresh_busy_stat(k, self.ttek - self.start_busy)
 
         if self.prty_type != "No":
+            if len(self.queue[k]) == 0 and self.free_channels == 1:
+                if self.in_sys[k] == self.n - 1 and self.class_busy_started != -1:
+                    # End of busy period
+                    self.busy_moments[k] += 1
+                    self.refresh_busy_stat(k, self.ttek - self.start_busy)
+
 
             start_number = 0
             if self.prty_type == "PR" or self.prty_type == "RS" or self.prty_type == "RW":
@@ -507,10 +505,15 @@ class PriorityQueueSimulator:
                     self.free_channels -= 1
                     break
         else:
+            if len(self.queue[0]) == 0 and self.free_channels == 1:
+                if self.in_sys == self.n - 1 and self.class_busy_started != -1:
+                    # End of busy period
+                    self.busy_moments += 1
+                    self.refresh_busy_stat(0, self.ttek - self.start_busy)
             # one queue
-            if len(self.queue) != 0:
+            if len(self.queue[0]) != 0:
 
-                que_ts = self.queue.pop(0)
+                que_ts = self.queue[0].pop(0)
 
                 if self.free_channels == 1 and k != end_ts.k:
                     self.start_busy[k] = self.ttek