vlcSim 0.6.0__tar.gz → 0.6.2__tar.gz

{vlcsim-0.6.0 → vlcsim-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vlcSim
-Version: 0.6.0
+Version: 0.6.2
 Summary: Python Package of Event-Oriented Simulation for visible light communication
 License: MIT
 License-File: LICENSE.md
@@ -27,7 +27,7 @@ Description-Content-Type: text/markdown
 ![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)
 ![Poetry](https://img.shields.io/badge/poetry-2.3+-blue.svg)
 ![Coverage](https://img.shields.io/badge/coverage-72%25-brightgreen.svg)
-![Tests](https://img.shields.io/badge/tests-166%20passing-brightgreen.svg)
+![Tests](https://img.shields.io/badge/tests-173%20passing-brightgreen.svg)
 ![License](https://img.shields.io/badge/license-MIT-blue.svg)
 ![GitLab](https://img.shields.io/badge/gitlab-simvlc-orange.svg)
 [![PyPI](https://img.shields.io/badge/PyPI-vlcSim-blue.svg)](https://pypi.org/project/vlcSim/)
@@ -42,7 +42,7 @@ VLCSim is an **Event-Oriented simulator** package for **Visible Light Communicat
 - **TDM Frame Management**: Time-Division Multiplexing with configurable slices
 - **Configurable Parameters**: Customize VLC/room parameters for different scenarios
 - **Event-Driven Simulation**: Efficient discrete event simulation engine
-- **Performance Metrics**: Built-in SNR and capacity calculations
+- **Performance Metrics**: Built-in SNR, capacity, blocking, waiting, and allocation metrics
 
 ## Installation
 
@@ -116,11 +116,16 @@ sim.run()
 
 # Get results
 print(f"Blocking Probability: {sim.get_Blocking_Probability()}")
+print(f"Waiting Probability: {sim.get_Waiting_Probability()}")
+print(f"Attempted Connections: {sim.get_Attempted_Connections()}")
+print(f"Allocated Connections: {sim.get_Allocated_Connections()}")
+print(f"Waiting Connections: {sim.get_Waiting_Connections()}")
+print(f"Blocked Connections: {sim.get_Blocked_Connections()}")
 ```
 
 **The built-in default algorithm** (`Controller.default_alloc`):
 - ✅ Selects VLeds with best SNR (maximum 5 connections per VLed)
-- ✅ Falls back to RF if all VLeds are busy or have poor SNR
+- ✅ Falls back to RF if all VLeds are busy (maximum 12 connections per RF)
 - ✅ Automatically allocates TDM frame/slice positions
 - ✅ Works well for most VLC research scenarios
 
@@ -306,6 +311,14 @@ sim.print_initial_info()  # Display scenario configuration
 - `upper_random_wait, lower_random_wait`: Retry delay bounds (seconds)
 - `upper_capacity_required, lower_capacity_required`: Capacity bounds (bps)
 
+**Key Metrics:**
+- `get_Blocking_Probability()`: Ratio of definitively blocked (`NOT_ALLOCATED`) connections to attempted connections
+- `get_Waiting_Probability()`: Ratio of currently waiting (`WAIT`) connections to attempted connections
+- `get_Attempted_Connections()`: Connection arrivals processed by the simulator
+- `get_Allocated_Connections()`: Connections assigned to an AP
+- `get_Waiting_Connections()`: Connections currently waiting for retry
+- `get_Blocked_Connections()`: Connections rejected with `NOT_ALLOCATED`
+
 ### Scenario Class
 
 Room configuration with access points.

{vlcsim-0.6.0 → vlcsim-0.6.2}/README.md

@@ -3,7 +3,7 @@
 ![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)
 ![Poetry](https://img.shields.io/badge/poetry-2.3+-blue.svg)
 ![Coverage](https://img.shields.io/badge/coverage-72%25-brightgreen.svg)
-![Tests](https://img.shields.io/badge/tests-166%20passing-brightgreen.svg)
+![Tests](https://img.shields.io/badge/tests-173%20passing-brightgreen.svg)
 ![License](https://img.shields.io/badge/license-MIT-blue.svg)
 ![GitLab](https://img.shields.io/badge/gitlab-simvlc-orange.svg)
 [![PyPI](https://img.shields.io/badge/PyPI-vlcSim-blue.svg)](https://pypi.org/project/vlcSim/)
@@ -18,7 +18,7 @@ VLCSim is an **Event-Oriented simulator** package for **Visible Light Communicat
 - **TDM Frame Management**: Time-Division Multiplexing with configurable slices
 - **Configurable Parameters**: Customize VLC/room parameters for different scenarios
 - **Event-Driven Simulation**: Efficient discrete event simulation engine
-- **Performance Metrics**: Built-in SNR and capacity calculations
+- **Performance Metrics**: Built-in SNR, capacity, blocking, waiting, and allocation metrics
 
 ## Installation
 
@@ -92,11 +92,16 @@ sim.run()
 
 # Get results
 print(f"Blocking Probability: {sim.get_Blocking_Probability()}")
+print(f"Waiting Probability: {sim.get_Waiting_Probability()}")
+print(f"Attempted Connections: {sim.get_Attempted_Connections()}")
+print(f"Allocated Connections: {sim.get_Allocated_Connections()}")
+print(f"Waiting Connections: {sim.get_Waiting_Connections()}")
+print(f"Blocked Connections: {sim.get_Blocked_Connections()}")
 ```
 
 **The built-in default algorithm** (`Controller.default_alloc`):
 - ✅ Selects VLeds with best SNR (maximum 5 connections per VLed)
-- ✅ Falls back to RF if all VLeds are busy or have poor SNR
+- ✅ Falls back to RF if all VLeds are busy (maximum 12 connections per RF)
 - ✅ Automatically allocates TDM frame/slice positions
 - ✅ Works well for most VLC research scenarios
 
@@ -282,6 +287,14 @@ sim.print_initial_info()  # Display scenario configuration
 - `upper_random_wait, lower_random_wait`: Retry delay bounds (seconds)
 - `upper_capacity_required, lower_capacity_required`: Capacity bounds (bps)
 
+**Key Metrics:**
+- `get_Blocking_Probability()`: Ratio of definitively blocked (`NOT_ALLOCATED`) connections to attempted connections
+- `get_Waiting_Probability()`: Ratio of currently waiting (`WAIT`) connections to attempted connections
+- `get_Attempted_Connections()`: Connection arrivals processed by the simulator
+- `get_Allocated_Connections()`: Connections assigned to an AP
+- `get_Waiting_Connections()`: Connections currently waiting for retry
+- `get_Blocked_Connections()`: Connections rejected with `NOT_ALLOCATED`
+
 ### Scenario Class
 
 Room configuration with access points.

{vlcsim-0.6.0 → vlcsim-0.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vlcSim"
-version = "0.6.0"  # Placeholder, will be replaced by dynamic versioning
+version = "0.6.2"  # Placeholder, will be replaced by dynamic versioning
 description = "Python Package of Event-Oriented Simulation for visible light communication"
 authors = ["Danilo Bórquez-Paredes <danilo.borquez.p@uai.cl>"]
 license = "MIT"

{vlcsim-0.6.0 → vlcsim-0.6.2}/vlcsim/__init__.py

@@ -24,12 +24,13 @@ Example:
         sim = Simulator(scenario)
         sim.run()
         print(f"Blocking Probability: {sim.get_Blocking_Probability()}")
+        print(f"Waiting Probability: {sim.get_Waiting_Probability()}")
 
 See Also:
     For detailed documentation, visit the project repository or build the Sphinx docs.
 """
 
-__version__ = "0.6.0"  # placeholder for poetry-dynamic-versioning
+__version__ = "0.6.2"  # placeholder for poetry-dynamic-versioning
 
 from .scene import *
 from .controller import *

{vlcsim-0.6.0 → vlcsim-0.6.2}/vlcsim/controller/controller.py

@@ -8,7 +8,6 @@ algorithms and TDM frame/slice management.
 from __future__ import annotations
 from typing import Optional, Union, Callable, Any
 from enum import Enum
-import sys
 
 # Import all necessary classes from scene and connection modules
 from ..scene import AccessPoint, VLed, RF, Receiver, Scenario
@@ -68,6 +67,12 @@ class Controller:
            - Allocator function must be set before calling `assignConnection()`
     """
 
+    MAX_ACTIVE_CONNECTIONS_PER_VLED = 5
+    """Maximum number of active connections allowed per VLed."""
+
+    MAX_ACTIVE_CONNECTIONS_PER_RF = 12
+    """Maximum number of active connections allowed per RF access point."""
+
     status = Enum("status", "ALLOCATED NOT_ALLOCATED WAIT")
     """Allocation algorithm return status.
     
@@ -603,6 +608,100 @@ class Controller:
         """
         return self.__activeConnections[self.APPosition(ap)]
 
+    @staticmethod
+    def _assign_frame_slices(
+        connection: Connection,
+        controller: "Controller",
+        numberOfSlices: int,
+    ) -> None:
+        actualSlice = connection.nextSliceInAPWhenArriving(connection.AP)
+        aux = 0
+        auxFrame = 0
+
+        # Actual frame
+        for slice in range(actualSlice, connection.AP.slicesInFrame):
+            if (
+                len(controller.framesState(connection.AP)) == 0
+                or controller.framesState(connection.AP)[0][slice] == False
+            ):
+                connection.assignFrameSlice(0, slice)
+                aux += 1
+                break
+
+        # Next frames
+        for frameIndex in range(1, len(controller.framesState(connection.AP))):
+            for slice in range(connection.AP.slicesInFrame):
+                if controller.framesState(connection.AP)[frameIndex][slice] == False:
+                    connection.assignFrameSlice(frameIndex, slice)
+                    aux += 1
+                    auxFrame = frameIndex
+                    break
+
+            if aux == numberOfSlices:
+                break
+
+        frameIndex = auxFrame + 1
+        while aux < numberOfSlices:
+            connection.assignFrameSlice(frameIndex, 0)
+            frameIndex += 1
+            aux += 1
+
+    @staticmethod
+    def _select_vled_candidate(
+        receiver: "Receiver",
+        connection: Connection,
+        scenario: Scenario,
+        controller: "Controller",
+        vled_snr: list[float],
+    ) -> Optional[tuple[VLed, float, float, int]]:
+        best_candidate: Optional[tuple[VLed, float, float, int]] = None
+
+        for vled_pos, vled in enumerate(scenario.vleds):
+            if (
+                controller.numberOfActiveConnections(vled)
+                >= Controller.MAX_ACTIVE_CONNECTIONS_PER_VLED
+            ):
+                continue
+
+            capacity = scenario.capacityVled(receiver, vled)
+            numberOfSlices = connection.numberOfSlicesNeeded(
+                connection.capacityRequired,
+                capacity,
+            )
+            candidate = (vled, vled_snr[vled_pos], capacity, numberOfSlices)
+            if best_candidate is None or candidate[1] > best_candidate[1]:
+                best_candidate = candidate
+
+        return best_candidate
+
+    @staticmethod
+    def _select_rf_candidate(
+        receiver: "Receiver",
+        connection: Connection,
+        scenario: Scenario,
+        controller: "Controller",
+        rf_snr: list[float],
+    ) -> Optional[tuple[RF, float, float, int]]:
+        best_candidate: Optional[tuple[RF, float, float, int]] = None
+
+        for rf_pos, rf in enumerate(scenario.rfs):
+            if (
+                controller.numberOfActiveConnections(rf)
+                >= Controller.MAX_ACTIVE_CONNECTIONS_PER_RF
+            ):
+                continue
+
+            capacity = scenario.capacityRf(receiver, rf)
+            numberOfSlices = connection.numberOfSlicesNeeded(
+                connection.capacityRequired,
+                capacity,
+            )
+            candidate = (rf, rf_snr[rf_pos], capacity, numberOfSlices)
+            if best_candidate is None or candidate[1] > best_candidate[1]:
+                best_candidate = candidate
+
+        return best_candidate
+
     @staticmethod
     def default_alloc(
         receiver: "Receiver",
@@ -613,9 +712,9 @@ class Controller:
         """Default allocation algorithm for connections.
 
         Implements a hybrid VLC/RF allocation strategy:
-        1. Try to allocate to VLed with best SNR (if < 5 active connections)
-        2. If all VLeds busy or poor SNR, fall back to best RF
-        3. Select VLed requiring fewer than 5 slices
+        1. Try to allocate to the best available VLed
+        2. If no VLed is available, fall back to the best available RF
+        3. Wait only when both VLed and RF access points are unavailable
         4. Assign available frame/slice positions
 
         Args:
@@ -625,14 +724,16 @@ class Controller:
             controller: Controller managing allocation
 
         Returns:
-            tuple: (Controller.status.ALLOCATED, connection)
+            tuple: (Controller.status.ALLOCATED, connection) when an AP is assigned,
+            otherwise (Controller.status.WAIT, connection)
 
         Raises:
-            ValueError: If connection cannot be allocated (no valid AP)
+            ValueError: If the connection lacks a capacity requirement
 
         Note:
-            - Prefers VLC over RF when SNR is better
+            - Prefers available VLed APs over RF fallback
             - Limits VLed connections to 5 per AP
+            - Limits RF connections to 12 per AP
             - Automatically finds free frame/slice positions
 
         Example:
@@ -641,6 +742,9 @@ class Controller:
                 controller.allocator = Controller.default_alloc
                 # Or create custom allocator with similar signature
         """
+        if connection.capacityRequired is None:
+            raise ValueError("Connection must have capacityRequired set.")
+
         vleds = scenario.vleds
         rfs = scenario.rfs
         vled_snr: list[float] = []
@@ -650,101 +754,28 @@ class Controller:
         for rf in rfs:
             rf_snr.append(scenario.snrRf(receiver, rf))
 
-        numberOfSlices = 0
-        number_better_rf = 0
-        for vled_pos in range(len(vleds)):
-            number_better_rf = 0
-            for rf_pos in range(len(rfs)):
-                if vled_snr[vled_pos] > rf_snr[rf_pos]:
-                    if controller.numberOfActiveConnections(vleds[vled_pos]) < 5:
-                        connection.AP = vleds[vled_pos]
-                        connection.receiver.capacityFromAP = scenario.capacityVled(
-                            receiver, connection.AP
-                        )
-                        numberOfSlices = connection.numberOfSlicesNeeded(
-                            connection.capacityRequired,
-                            connection.receiver.capacityFromAP,
-                        )
-                        connection.snr = vled_snr[vled_pos]
-                        if numberOfSlices < 5:
-                            number_better_rf += 1
-                            break
-                    else:
-                        number_better_rf += 1
-                        break
-                else:
-                    number_better_rf += 1
-                    break
-            if number_better_rf == 0:
-                break
-        if number_better_rf != 0:
-            best_rf_SNR = sys.float_info.min
-            best_rf = None
-            for rf_pos in range(len(rfs)):
-                if rf_snr[rf_pos] > best_rf_SNR:
-                    best_rf_SNR = rf_snr[rf_pos]
-                    best_rf = rf_pos
-            if best_rf is not None:
-                connection.AP = rfs[best_rf]
-                connection.receiver.capacityFromAP = scenario.capacityRf(
-                    receiver, connection.AP
-                )
-                numberOfSlices = connection.numberOfSlicesNeeded(
-                    connection.capacityRequired, connection.receiver.capacityFromAP
-                )
-                connection.snr = rf_snr[best_rf]
-        else:
-            for vled_pos in range(len(vleds)):
-                if vled_snr[vled_pos] > connection.snr:
-                    connection.AP = vleds[vled_pos]
-                    connection.receiver.capacityFromAP = scenario.capacityVled(
-                        receiver, connection.AP
-                    )
-                    numberOfSlices = connection.numberOfSlicesNeeded(
-                        connection.capacityRequired, connection.receiver.capacityFromAP
-                    )
-                    connection.snr = vled_snr[vled_pos]
-
-        if connection.AP is None:
-            raise ValueError("Failed to assign an AccessPoint to the connection.")
-
-        if (
-            connection.capacityRequired is None
-            or connection.receiver.capacityFromAP is None
-        ):
-            raise ValueError(
-                "Connection must have valid capacityRequired and capacityFromAP."
+        candidate = Controller._select_vled_candidate(
+            receiver,
+            connection,
+            scenario,
+            controller,
+            vled_snr,
+        )
+        if candidate is None:
+            candidate = Controller._select_rf_candidate(
+                receiver,
+                connection,
+                scenario,
+                controller,
+                rf_snr,
             )
 
-        actualSlice = connection.nextSliceInAPWhenArriving(connection.AP)
-        aux = 0
-        auxFrame = 0
+        if candidate is None:
+            return Controller.status.WAIT, connection
 
-        # Actual frame
-        for slice in range(actualSlice, connection.AP.slicesInFrame):
-            if (
-                len(controller.framesState(connection.AP)) == 0
-                or controller.framesState(connection.AP)[0][slice] == False
-            ):
-                connection.assignFrameSlice(0, slice)
-                aux += 1
-                break
-
-        # next frames
-        for frameIndex in range(1, len(controller.framesState(connection.AP))):
-            for slice in range(connection.AP.slicesInFrame):
-                if controller.framesState(connection.AP)[frameIndex][slice] == False:
-                    connection.assignFrameSlice(frameIndex, slice)
-                    aux += 1
-                    auxFrame = frameIndex
-                    break
-
-            if aux == numberOfSlices:
-                break
-
-        frameIndex = auxFrame + 1
-        while aux < numberOfSlices:
-            connection.assignFrameSlice(frameIndex, 0)
-            frameIndex += 1
-            aux += 1
+        ap, snr, capacity, numberOfSlices = candidate
+        connection.AP = ap
+        connection.receiver.capacityFromAP = capacity
+        connection.snr = snr
+        Controller._assign_frame_slices(connection, controller, numberOfSlices)
         return Controller.status.ALLOCATED, connection

{vlcsim-0.6.0 → vlcsim-0.6.2}/vlcsim/simulator.py

@@ -11,7 +11,7 @@ The Simulator module handles:
     - Event scheduling and management using Future Event List (FEL)
     - Random variable generation for arrivals, departures, and positions
     - Connection lifecycle tracking (arrive → allocate → transmit → depart)
-    - Statistical data collection (blocking probability, AP utilization)
+    - Statistical data collection (blocking/waiting probability, AP utilization)
     - Scenario initialization and execution control
 
 Example:
@@ -37,6 +37,7 @@ Example:
 
         # Get results
         print(f"Blocking probability: {sim.get_Blocking_Probability()}")
+        print(f"Waiting probability: {sim.get_Waiting_Probability()}")
 
 Note:
     - Must call `init()` before `run()`
@@ -159,7 +160,7 @@ class Simulator:
         1. **Initialization**: Configure scenario, APs, and simulation parameters
         2. **Event Scheduling**: Maintain chronologically ordered Future Event List (FEL)
         3. **Event Processing**: Execute event routines (arrive, pause, resume, depart)
-        4. **Statistics Collection**: Track blocking probability, AP utilization, delays
+        4. **Statistics Collection**: Track blocking/waiting probability, AP utilization, delays
 
     Key Features:
         - Poisson arrival process (exponential inter-arrival times)
@@ -193,7 +194,9 @@ class Simulator:
 
             # Get results
             blocking = sim.get_Blocking_Probability()
+            waiting = sim.get_Waiting_Probability()
             print(f"Blocking Probability: {blocking}")
+            print(f"Waiting Probability: {waiting}")
 
     Note:
         - Must call `init()` before `run()`
@@ -246,6 +249,10 @@ class Simulator:
         self.__rtn_allocation: Optional[Any] = None
 
         self.__allocatedConnections: int = 0
+        self.__attemptedConnections: int = 0
+        self.__allocatedConnectionIds: set[int] = set()
+        self.__blockedConnectionIds: set[int] = set()
+        self.__waitingConnectionIds: set[int] = set()
         # time
         self.__clock: float = 0.0
         self.__time_duration: Optional[float] = None
@@ -305,6 +312,10 @@ class Simulator:
         self.__lower_capacity_required = 1e5
         self.__upper_capacity_required = 5e5
         self.__allocatedConnections = 0
+        self.__attemptedConnections = 0
+        self.__allocatedConnectionIds = set()
+        self.__blockedConnectionIds = set()
+        self.__waitingConnectionIds = set()
         self.__controller.allocator = Controller.default_alloc
 
     @property
@@ -790,6 +801,7 @@ class Simulator:
         # print(self.__controller.activeConnections[3])
         # print(self.__controller.activeConnections[4])
         if self.__current_event.type == Event.event.ARRIVE:
+            self.__attemptedConnections += 1
             next_event_time = self.__clock + self.__arrival_variable.exponential(
                 self.__lambdaS
             )
@@ -857,9 +869,10 @@ class Simulator:
                             e.connection = connection
                             self.__events.insert(pos + 1, e)
                             break
-                    self.__allocatedConnections += 1
+                self.__record_allocated_connection(connection)
             elif next_status == Controller.nextStatus.RND_WAIT:
                 self.__current_event.connection = connection
+                self.__record_waiting_connection(connection)
                 next_event_time = self.__clock + self.__random_wait_variable.uniform(
                     low=self.__lower_random_wait,
                     high=self.upper_random_wait,
@@ -875,6 +888,8 @@ class Simulator:
                     if self.__events[pos].time < next_event_time:
                         self.__events.insert(pos + 1, next_event)
                         break
+            elif next_status == Controller.nextStatus.IDLE:
+                self.__record_blocked_connection(connection)
         elif self.__current_event.type == Event.event.NEXT_CONNECTION_TRY:
             if not self.__current_event.connection:
                 return
@@ -900,8 +915,9 @@ class Simulator:
                             e.connection = connection
                             self.__events.insert(pos + 1, e)
                             break
-                    self.__allocatedConnections += 1
+                self.__record_allocated_connection(connection)
             elif next_status == Controller.nextStatus.RND_WAIT:
+                self.__record_waiting_connection(connection)
                 next_event_time = self.__clock + self.__random_wait_variable.uniform(
                     low=self.__lower_random_wait,
                     high=self.upper_random_wait,
@@ -916,6 +932,8 @@ class Simulator:
                     if self.__events[pos].time < next_event_time:
                         self.__events.insert(pos + 1, next_event)
                         break
+            elif next_status == Controller.nextStatus.IDLE:
+                self.__record_blocked_connection(connection)
         elif self.__current_event.type == Event.event.PAUSE:
             if not self.__current_event.connection:
                 return
@@ -977,6 +995,28 @@ class Simulator:
 
         return self.__rtn_allocation
 
+    def __record_allocated_connection(self, connection: Connection) -> None:
+        connection_id = connection.id
+        if connection_id in self.__allocatedConnectionIds:
+            return
+        self.__waitingConnectionIds.discard(connection_id)
+        self.__allocatedConnectionIds.add(connection_id)
+        self.__allocatedConnections += 1
+
+    def __record_waiting_connection(self, connection: Connection) -> None:
+        connection_id = connection.id
+        if connection_id in self.__allocatedConnectionIds:
+            return
+        if connection_id in self.__blockedConnectionIds:
+            return
+        self.__waitingConnectionIds.add(connection_id)
+
+    def __record_blocked_connection(self, connection: Connection) -> None:
+        connection_id = connection.id
+        self.__waitingConnectionIds.discard(connection_id)
+        if connection_id not in self.__allocatedConnectionIds:
+            self.__blockedConnectionIds.add(connection_id)
+
     def init(self):
         """Initialize the simulation engine and prepare for execution.
 
@@ -1011,6 +1051,10 @@ class Simulator:
         self.__events = []
         self.__numberOfConnections = 0
         self.__allocatedConnections = 0
+        self.__attemptedConnections = 0
+        self.__allocatedConnectionIds = set()
+        self.__blockedConnectionIds = set()
+        self.__waitingConnectionIds = set()
         self.__users_by_vlc = []
         self.__users_by_rf = []
         self.__current_event = None
@@ -1109,19 +1153,65 @@ class Simulator:
         """
         return self.__time_duration if self.__time_duration is not None else 0.0
 
+    def get_Attempted_Connections(self) -> int:
+        """Get the number of arrival events processed by the simulator.
+
+        Returns:
+            int: Number of distinct connection requests that reached allocation logic
+        """
+        return self.__attemptedConnections
+
+    def get_Allocated_Connections(self) -> int:
+        """Get the number of connections successfully allocated.
+
+        Returns:
+            int: Number of distinct connections assigned to an access point
+        """
+        return self.__allocatedConnections
+
+    def get_Waiting_Connections(self) -> int:
+        """Get the number of connections currently waiting for a retry.
+
+        Returns:
+            int: Number of distinct connections in WAIT state
+        """
+        return len(self.__waitingConnectionIds)
+
+    def get_Blocked_Connections(self) -> int:
+        """Get the number of connections definitively rejected.
+
+        Returns:
+            int: Number of distinct connections that returned NOT_ALLOCATED
+        """
+        return len(self.__blockedConnectionIds)
+
+    def get_Waiting_Probability(self) -> float:
+        """Calculate the fraction of attempted connections currently waiting.
+
+        Returns:
+            float: Waiting probability (0.0 to 1.0, rounded to 2 decimals)
+        """
+        if self.__attemptedConnections == 0:
+            return 0.0
+        return round(
+            self.get_Waiting_Connections() / self.__attemptedConnections,
+            2,
+        )
+
     def get_Blocking_Probability(self) -> float:
         """Calculate the connection blocking probability.
 
-        Blocking probability is the fraction of connections that were NOT successfully
-        allocated. It represents the percentage of connection requests that were denied
-        due to insufficient resources.
+        Blocking probability is the fraction of attempted connections that were
+        definitively rejected with NOT_ALLOCATED. Connections waiting for a retry are
+        reported separately by `get_Waiting_Connections()` and
+        `get_Waiting_Probability()`.
 
         Returns:
             float: Blocking probability (0.0 to 1.0, rounded to 2 decimals)
 
         Formula::
 
-            Blocking Probability = 1 - (allocated_connections / total_connections)
+            Blocking Probability = blocked_connections / attempted_connections
 
         Example::
 
@@ -1129,10 +1219,12 @@ class Simulator:
             blocking = sim.get_Blocking_Probability()
             print(f"Blocking rate: {blocking * 100:.1f}%")  # e.g., "Blocking rate: 5.2%"
         """
-        blocking = round(
-            1 - self.__allocatedConnections / self.__numberOfConnections, 2
+        if self.__attemptedConnections == 0:
+            return 0.0
+        return round(
+            self.get_Blocked_Connections() / self.__attemptedConnections,
+            2,
         )
-        return blocking
 
     def set_allocation_algorithm(
         self,