vlcSim 0.3.2__tar.gz → 0.3.4__tar.gz

{vlcSim-0.3.2 → vlcSim-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vlcSim
-Version: 0.3.2
+Version: 0.3.4
 Summary: Python Package of Event-Oriented Simulation for visible light communication
 Home-page: https://gitlab.com/DaniloBorquez/simvlc/
 Author: Danilo Bórquez-Paredes

{vlcSim-0.3.2 → vlcSim-0.3.4}/setup.py

@@ -10,7 +10,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="vlcSim",
-    version="0.3.2",
+    version="0.3.4",
     license="MIT",
     description="Python Package of Event-Oriented Simulation for visible light communication",
     author="Danilo Bórquez-Paredes",

{vlcSim-0.3.2 → vlcSim-0.3.4}/vlcSim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vlcSim
-Version: 0.3.2
+Version: 0.3.4
 Summary: Python Package of Event-Oriented Simulation for visible light communication
 Home-page: https://gitlab.com/DaniloBorquez/simvlc/
 Author: Danilo Bórquez-Paredes

{vlcSim-0.3.2 → vlcSim-0.3.4}/vlcsim/controller.py

@@ -2,6 +2,7 @@
 The :mod:`vlcsim.controller` module is in charge of managing the connections and the physical sustrate.
 """
 
+from __future__ import annotations
 from .scene import *
 from enum import Enum
 import math
@@ -321,8 +322,7 @@ class Controller:
         if self.__allocationStatus == Controller.status.ALLOCATED:
             index = self.APPosition(connection.AP)
             self.__numberActiveConnections[index] += 1
-            actualSlice = connection.nextSliceInAPWhenArriving(
-                connection.AP) - 1
+            actualSlice = connection.nextSliceInAPWhenArriving(connection.AP) - 1
             actualTime = (
                 (time // (connection.AP.slicesInFrame * connection.AP.sliceTime))
                 * connection.AP.slicesInFrame
@@ -535,3 +535,101 @@ class Controller:
         :return: A list of lists containing the frames and slices of this AP
         """
         return self.__activeConnections[self.APPosition(ap)]
+
+    def default_alloc(
+        receiver, connection: Connection, scenario: Scenario, controller: Controller
+    ):
+        vleds = scenario.vleds
+        rfs = scenario.rfs
+        vled_snr = []
+        rf_snr = []
+        for vled in vleds:
+            vled_snr.append(scenario.snrVled(receiver, vled))
+        for rf in rfs:
+            rf_snr.append(scenario.snrRf(receiver, rf))
+
+        numberOfSlices = 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
+            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[rf_pos]
+        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]
+
+        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
+        return Controller.status.ALLOCATED, connection

{vlcSim-0.3.2 → vlcSim-0.3.4}/vlcsim/scene.py

@@ -467,6 +467,17 @@ class RF(AccessPoint):
 
     @property
     def pif(self) -> float:
+        """
+        The received SNR discrepancy from the continuous input memoryless channel’s capacity at the target BER. (pif=-1.5log2-1(5 BERf))
+
+        .. math::
+            \\begin{eqnarray}
+                pif = -1.5 \log_2^{-1}(5\cdot BERf)
+            \\end{eqnarray}
+
+        :return: SNR discrepancy
+        :rtype: float
+        """
         return self.__pif
 
     @pif.setter
@@ -489,6 +500,12 @@ class RF(AccessPoint):
 
     @property
     def nFactor_rf(self) -> float:
+        """
+        RF constant
+
+        :return: RF constant
+        :rtype: float
+        """
         return self.__nFactor_rf
 
     @nFactor_rf.setter
@@ -497,6 +514,12 @@ class RF(AccessPoint):
 
     @property
     def A(self) -> float:
+        """
+        Rayleigh distributed channel gain.
+
+        :return: Rayleigh distributed channel gain.
+        :rtype: float
+        """
         return self.__A
 
     @A.setter
@@ -505,7 +528,14 @@ class RF(AccessPoint):
 
 
 class Receiver:
+    """
+    Class that represents a VLC object
+    """
+
     receiversCreated = 0
+    """
+    Number of receivers created by this class.
+    """
 
     def __init__(
         self,
@@ -549,7 +579,7 @@ class Receiver:
         :type fov: float
         :param q: electronic load. Default is -1.602e-19 culombios
         :type q: float
-        :param s: ibg b - parameter of the Ib - Galactic model. Default i 5 seconds.
+        :param s: ibg b - parameter of the Ib - Galactic model. Default is 5 seconds.
         :type s: float
         :param b: c b - parameter of the Ib - Galactic model. Default is 5 seconds.
         :type b: float
@@ -678,6 +708,12 @@ class Receiver:
 
     @property
     def aDet(self) -> float:
+        """
+        aDet value of the object's coordinate.
+
+        :return: aDet value of the object's coordinate.
+        :rtype: float
+        """
         return self.__aDet
 
     @aDet.setter
@@ -686,6 +722,12 @@ class Receiver:
 
     @property
     def ts(self) -> float:
+        """
+        time of the object's coordinate. Default is 10 seconds.
+
+        :return: time of the object's coordinate.
+        :rtype: float
+        """
         return self.__ts
 
     @ts.setter
@@ -694,6 +736,12 @@ class Receiver:
 
     @property
     def index(self) -> float:
+        """
+        order of Lambertian emission that depends on the half-angle at half illumination of the LED.
+
+        :return: order of Lambertian emission
+        :rtype: float
+        """
         return self.__index
 
     @index.setter
@@ -702,6 +750,12 @@ class Receiver:
 
     @property
     def fov(self) -> float:
+        """
+        width of the field of view.
+
+        :return: width of the field of view.
+        :rtype: float
+        """
         return self.__fov
 
     @fov.setter
@@ -713,7 +767,7 @@ class Receiver:
         return self.__gCon
 
     @property
-    def position(self):
+    def position(self) -> float:
         """
         Return the position of the object. This is a tuple of ( x y z)
 
@@ -724,6 +778,12 @@ class Receiver:
 
     @property
     def q(self):
+        """
+        electronic load. Default is -1.602e-19 culombios
+
+        :return: electronic load.
+        :rtype: _type_
+        """
         return self.__q
 
     @q.setter
@@ -732,6 +792,11 @@ class Receiver:
 
     @property
     def s(self):
+        """
+        ibg b - parameter of the Ib - Galactic model. Default is 5 seconds.
+
+        :return: ibg b - parameter of the Ib - Galactic model.
+        """
         return self.__s
 
     @s.setter
@@ -740,6 +805,11 @@ class Receiver:
 
     @property
     def b(self):
+        """
+        c b - parameter of the Ib - Galactic model.
+
+        :return: c b - parameter of the Ib - Galactic model.
+        """
         return self.__b
 
     @b.setter
@@ -747,7 +817,13 @@ class Receiver:
         self.__b = value
 
     @property
-    def ibg(self):
+    def ibg(self) -> float:
+        """
+        background current. Default is 5.1e-3 Amperes.
+
+        :return: background current.
+        :rtype: float
+        """
         return self.__ibg
 
     @ibg.setter
@@ -755,7 +831,13 @@ class Receiver:
         self.__ibg = value
 
     @property
-    def cb(self):
+    def cb(self) -> float:
+        """
+        Boltzmann constant. Default is 1.380649e-23 J/K.
+
+        :return: Boltzmann constant.
+        :rtype: float
+        """
         return self.__cb
 
     @cb.setter
@@ -763,7 +845,7 @@ class Receiver:
         self.__cb = value
 
     @property
-    def tk(self):
+    def tk(self) -> float:
         return self.__tk
 
     @tk.setter
@@ -771,7 +853,13 @@ class Receiver:
         self.__tk = value
 
     @property
-    def a(self):
+    def a(self) -> float:
+        """
+        n n - parameter of the B - parameter. Default is 10 seconds.
+
+        :return: n n -  B - parameter
+        :rtype: float
+        """
         return self.__a
 
     @a.setter
@@ -779,7 +867,13 @@ class Receiver:
         self.__a = value
 
     @property
-    def gv(self):
+    def gv(self) -> float:
+        """
+        Open-loop voltage gain. Default is 10
+
+        :return: Open-loop voltage gain.
+        :rtype: float
+        """
         return self.__gv
 
     @gv.setter
@@ -787,7 +881,13 @@ class Receiver:
         self.__gv = value
 
     @property
-    def n(self):
+    def n(self) -> float:
+        """
+        Fixed capacitance of the PD per unit area. Default is 1.12e-6.
+
+        :return: Fixed capacitance of the PD per unit area.
+        :rtype: float
+        """
         return self.__n
 
     @n.setter
@@ -795,7 +895,13 @@ class Receiver:
         self.__n = value
 
     @property
-    def fr(self):
+    def fr(self) -> float:
+        """
+        FET channel noise factor. Default is 1.5
+
+        :return: FET channel noise factor.
+        :rtype: float
+        """
         return self.__fr
 
     @fr.setter
@@ -803,7 +909,13 @@ class Receiver:
         self.__fr = value
 
     @property
-    def gm(self):
+    def gm(self) -> float:
+        """
+        FET transconductance. Default is 3e-2.
+
+        :return: FET transconductance.
+        :rtype: float
+        """
         return self.__gm
 
     @gm.setter
@@ -811,7 +923,13 @@ class Receiver:
         self.__gm = value
 
     @property
-    def i1(self):
+    def i1(self) -> float:
+        """
+        constant experimental value. Default is 0.562.
+
+        :return: constant experimental value.
+        :rtype: float
+        """
         return self.__i1
 
     @i1.setter
@@ -819,7 +937,13 @@ class Receiver:
         self.__i1 = value
 
     @property
-    def i2(self):
+    def i2(self) -> float:
+        """
+        constant experimental value. Default is 0.0868.
+
+        :return: constant experimental value.
+        :rtype: float
+        """
         return self.__i2
 
     @i2.setter
@@ -827,7 +951,13 @@ class Receiver:
         self.__i2 = value
 
     @property
-    def timeFirstConnected(self):
+    def timeFirstConnected(self) -> float:
+        """
+        time point at which this receiver was first connected
+
+        :return: time point at which this receiver was first connected
+        :rtype: float
+        """
         return self.__timeFirstConnected
 
     @timeFirstConnected.setter
@@ -835,7 +965,13 @@ class Receiver:
         self.__timeFirstConnected = value
 
     @property
-    def goalTime(self):
+    def goalTime(self) -> float:
+        """
+        Amount of time that this receiver will be connected. Depends on tha SNR.
+
+        :return: Amount of time that this receiver will be connected.
+        :rtype: float
+        """
         return self.__goalTime
 
     @goalTime.setter
@@ -843,7 +979,13 @@ class Receiver:
         self.__goalTime = value
 
     @property
-    def timeActive(self):
+    def timeActive(self) -> float:
+        """
+        Effective time connected.
+
+        :return: Effective time connected
+        :rtype: float
+        """
         return self.__timeActive
 
     @timeActive.setter
@@ -851,7 +993,13 @@ class Receiver:
         self.__timeActive = value
 
     @property
-    def timeFinished(self):
+    def timeFinished(self) -> float:
+        """
+        point in time when this receiver wil be finished.
+
+        :return: point in time when this receiver wil be finished.
+        :rtype: float
+        """
         return self.__timeFinished
 
     @timeFinished.setter
@@ -860,7 +1008,21 @@ class Receiver:
 
 
 class Scenario:
+    """
+    Class that represents the characteristics of the scenario
+
+    :return: _description_
+    :rtype: _type_
+    """
+
     numberOfAPs = 0
+    """
+    Number of access points in the scenario.
+
+    :return: Number of access points in the scenario.
+    :rtype: int
+    """
+
     warnings.filterwarnings(
         "ignore", message="invalid value encountered in double_scalars"
     )
@@ -868,6 +1030,19 @@ class Scenario:
     def __init__(
         self, width: float, length: float, height: float, nGrids: int, rho: float
     ) -> None:
+        """Scenario Constructor
+
+        :param width: Width of the room
+        :type width: float
+        :param length: Length of the room
+        :type length: float
+        :param height: Height of the room
+        :type height: float
+        :param nGrids: Number of grids of each VLED
+        :type nGrids: int
+        :param rho: Reflexion coefficient
+        :type rho: float
+        """
         self.__length = length  # x
         self.__width = width  # y
         self.__height = height  # z
@@ -897,16 +1072,38 @@ class Scenario:
         self.__g_xyz = np.array([self.__g_x, self.__g_y, self.__g_z], dtype=object)
 
     def addVLed(self, vled: VLed):
+        """
+        Add a VLED to this Scenario
+
+        :param vled: the VLED to be added
+        :type vled: VLed
+        """
         self.__vleds.append(vled)
         self.__vledsPositions.append(Scenario.numberOfAPs)
         Scenario.numberOfAPs += 1
 
     def addRF(self, rf: RF):
+        """
+        Add an RF to this Scenario
+
+        :param rf: The RF to be added
+        :type rf: RF
+        """
         self.__femtocells.append(rf)
         self.__rfsPositions.append(Scenario.numberOfAPs)
         Scenario.numberOfAPs += 1
 
     def getPowerInPointFromWalls(self, receiver: Receiver, vledID: int) -> float:
+        """
+        Get the incident power in an specific point in the room, received from the walls.
+
+        :param receiver: The receiver which is in the point
+        :type receiver: Receiver
+        :param vledID: The VLED that is sending the signal
+        :type vledID: int
+        :return: Power from walls
+        :rtype: float
+        """
         vled = self.__vleds[vledID]
         h1 = self.__channelGainWall(receiver, vled, 1, 0)
         h2 = self.__channelGainWall(receiver, vled, 0, 1)
@@ -916,6 +1113,16 @@ class Scenario:
         return float(power)
 
     def getPowerInPointFromVled(self, receiver: Receiver, vledID: int) -> float:
+        """
+        Get the power from the VLED in LOS
+
+        :param receiver: The receiver which is in the point
+        :type receiver: Receiver
+        :param vledID: The VLED that is sending the signal
+        :type vledID: int
+        :return: Power from VLED
+        :rtype: float
+        """
         vled = self.__vleds[vledID]
         D_los = m.sqrt(
             (receiver.x - vled.x) ** 2
@@ -940,7 +1147,23 @@ class Scenario:
         )
         return power
 
-    def __channelGainWall(self, receiver: Receiver, vled, posVar, posFixed) -> float:
+    def __channelGainWall(
+        self, receiver: Receiver, vled: VLed, posVar: int, posFixed: int
+    ) -> float:
+        """
+        Gain in channel from walls
+
+        :param receiver: The receiver which is in the point
+        :type receiver: Receiver
+        :param vled: The VLED that is sending the signal
+        :type vled: VLed
+        :param posVar: Auxiliar variable
+        :type posVar: int
+        :param posFixed: Auxiliar variable
+        :type posFixed: int
+        :return: Gain in channel
+        :rtype: float
+        """
         wall = None
         dA = self.__height
         if posFixed == 0:
@@ -978,23 +1201,53 @@ class Scenario:
         return h
 
     @property
-    def numberOfVLeds(self):
+    def numberOfVLeds(self) -> int:
+        """
+        number of VLeds in this scenario
+
+        :return: number of vleds
+        :rtype: int
+        """
         return len(self.__vleds)
 
     @property
-    def numberOfRFs(self):
+    def numberOfRFs(self) -> int:
+        """
+        Number of RFs in this scenario
+
+        :return: number of RFs
+        :rtype: int
+        """
         return len(self.__femtocells)
 
     @property
-    def vleds(self):
+    def vleds(self) -> list:
+        """
+        set of VLEDs in this scenario.
+
+        :return: set of VLEDs
+        :rtype: list
+        """
         return self.__vleds
 
     @property
-    def rfs(self):
+    def rfs(self) -> list:
+        """
+        List of RFs in this scenario
+
+        :return: List of RFs
+        :rtype: list
+        """
         return self.__femtocells
 
     @property
-    def start_x(self):
+    def start_x(self) -> float:
+        """
+        Auxiliar variable determining the starting X coordinate of the room
+
+        :return: Starting X coordinate
+        :rtype: float
+        """
         return self.__start_x
 
     @start_x.setter
@@ -1002,7 +1255,13 @@ class Scenario:
         self.__start_x = value
 
     @property
-    def start_y(self):
+    def start_y(self) -> float:
+        """
+        Auxiliar variable determining the starting Y coordinate of the room
+
+        :return: Starting Y coordinate
+        :rtype: float
+        """
         return self.__start_y
 
     @start_y.setter
@@ -1010,7 +1269,13 @@ class Scenario:
         self.__start_y = value
 
     @property
-    def end_x(self):
+    def end_x(self) -> float:
+        """
+        Auxiliar variable determining the ending X coordinate of the room
+
+        :return: Ending X coordinate
+        :rtype: float
+        """
         return self.__end_x
 
     @end_x.setter
@@ -1018,7 +1283,13 @@ class Scenario:
         self.__end_x = value
 
     @property
-    def end_y(self):
+    def end_y(self) -> float:
+        """
+        Auxiliar variable determining the ending Y coordinate of the room
+
+        :return: Ending Y coordinate
+        :rtype: float
+        """
         return self.__end_y
 
     @end_y.setter
@@ -1026,7 +1297,13 @@ class Scenario:
         self.__end_y = value
 
     @property
-    def height(self):
+    def height(self) -> float:
+        """
+        Scenario height
+
+        :return: Scenario height
+        :rtype: float
+        """
         return self.__height
 
     @height.setter
@@ -1034,7 +1311,13 @@ class Scenario:
         self.__height = value
 
     @property
-    def length(self):
+    def length(self) -> float:
+        """
+        Scenario Length
+
+        :return: Scenario Length
+        :rtype: float
+        """
         return self.__length
 
     @length.setter
@@ -1042,7 +1325,13 @@ class Scenario:
         self.__length = value
 
     @property
-    def width(self):
+    def width(self) -> float:
+        """
+        Scenario width
+
+        :return: Scenario width
+        :rtype: float
+        """
         return self.__width
 
     @width.setter
@@ -1050,14 +1339,36 @@ class Scenario:
         self.__width = value
 
     @property
-    def vledsPositions(self):
+    def vledsPositions(self) -> list:
+        """
+        Vleds positions in room
+
+        :return: Vleds position
+        :rtype: list
+        """
         return self.__vledsPositions
 
     @property
-    def rfsPositions(self):
+    def rfsPositions(self) -> list:
+        """
+        RFs positions
+
+        :return: RFs positions
+        :rtype: list
+        """
         return self.__rfsPositions
 
     def snrVled(self, receiver: Receiver, vled: VLed) -> float:
+        """
+        Total SNR in an specific point from a VLED, considering walls and positions.
+
+        :param receiver: Receiver device
+        :type receiver: Receiver
+        :param vled: VLED
+        :type vled: VLed
+        :return: Total SNR
+        :rtype: float
+        """
         powerReceived = self.getPowerInPointFromVled(
             receiver, vled.ID
         ) + self.getPowerInPointFromWalls(receiver, vled.ID)
@@ -1087,6 +1398,16 @@ class Scenario:
         return (receiver.s * powerReceived) ** 2 / rg
 
     def snrRf(self, receiver: Receiver, rf: RF) -> float:
+        """
+        Total SNR in an specific point from an RF.
+
+        :param receiver: Receiver device
+        :type receiver: Receiver
+        :param rf: RF device
+        :type rf: RF
+        :return: Total SNR
+        :rtype: float
+        """
         df = m.sqrt(
             (receiver.x - rf.x) ** 2
             + (receiver.y - rf.y) ** 2
@@ -1096,7 +1417,27 @@ class Scenario:
         return rf.pf * rf.Af * df ** (-rf.Ef)
 
     def capacityVled(self, receiver: Receiver, vled: VLed) -> float:
+        """
+        Capacity of the VLED channel considering receiver devices in an specific point.
+
+        :param receiver: Receiver device
+        :type receiver: Receiver
+        :param vled: VLED
+        :type vled: VLed
+        :return: Capacity
+        :rtype: float
+        """
         return vled.B * m.log2(1 + self.snrVled(receiver, vled))
 
     def capacityRf(self, receiver: Receiver, rf: RF) -> float:
+        """
+        Capacity of the RF channel considering receiver devices in an specific point.
+
+        :param receiver: Receiver device
+        :type receiver: Receiver
+        :param rf: RF
+        :type rf: RF
+        :return: Capacity
+        :rtype: float
+        """
         return rf.B * m.log2(1 + self.snrRf(receiver, rf))

{vlcSim-0.3.2 → vlcSim-0.3.4}/vlcsim/simulator.py

@@ -1,30 +1,26 @@
+"""
+The Module **Simulator** has all the Simulation Dynamics. 
+"""
+
 from .controller import *
 from .scene import *
 import numpy as np
 from enum import Enum
 
-"""
-The Module **Simulator** has all the Simulation Dynamics. 
-"""
-
 
 class Event:
-    """This is a conceptual class representation of a simple BLE device
-    (GATT Server). It is essentially an extended combination of the
-
-    :param type: A handle to the :class:`simpleble.SimpleBleClient` client
-        object that detected the device
-    :type type: class:`Event.event`
-    :param time: Device MAC address, defaults to None
-    :type time: float, optional
-    :param id_connection: Device address type - one of ADDR_TYPE_PUBLIC or
-        ADDR_TYPE_RANDOM, defaults to ADDR_TYPE_PUBLIC
-    :type id_connection: int, optional
+    """
+    The Event class has the information about the event, containing the time when the event occurs, the type of event, and the connection ID.
     """
 
     event = Enum("event", "ARRIVE DEPARTURE PAUSE RESUME NEXT_CONNECTION_TRY")
+    """
+    There are five event types. The **ARRIVE** event is used when a connection arrives to the scenario. **DEPARTURE** event when the connection leaves. **PAUSE** and **RESUME** is related to a connection that is currently served by an AP, but because of the frame-slot behavior is paused and resumed multiple times. Finally, **NEXT_CONNECTION_TRY** is used when a connection couldn't be stablished because capacity, and waits a random time and need to be served in future·
+    """
 
-    def __init__(self, type=None, time=-1, id_connection=-1):
+    def __init__(
+        self, type: event = None, time: float = -1, id_connection: int = -1
+    ) -> None:
         self.__time = time
         self.__id_connection = id_connection
         if type == None:
@@ -34,28 +30,70 @@ class Event:
         self.__connection = None
 
     @property
-    def type(self):
+    def type(self) -> event:
+        """
+        The connection type. Could be one of the fives types described before.
+
+        :return: Connection type
+        :rtype: event
+        """
         return self.__type
 
     @property
-    def time(self):
+    def time(self) -> float:
+        """
+        The instant when this event occurs.
+
+        :return: Instant time of this event
+        :rtype: float
+        """
         return self.__time
 
     @property
-    def id_connection(self):
+    def id_connection(self) -> int:
+        """
+        Connection ID of the connection related to this event
+
+        :return: Connection ID
+        :rtype: int
+        """
         return self.__id_connection
 
     @property
-    def connection(self):
+    def connection(self) -> Connection:
+        """
+        Connection object related to this event.
+
+        :return: Connection object
+        :rtype: Connection
+        """
         return self.__connection
 
     @connection.setter
-    def connection(self, value):
+    def connection(self, value: Connection):
         self.__connection = value
 
 
 class Simulator:
-    def __init__(self, x, y, z, nGrids, rho):
+    """
+    Simulator class. In chanrge of randomness and the clock routine.
+    """
+
+    def __init__(self, x: float, y: float, z: float, nGrids: int, rho: float) -> None:
+        """
+        Simulator object constructor
+
+        :param x: Length of the scenario
+        :type x: float
+        :param y: Width of the scenario
+        :type y: float
+        :param z: Height of the scenario
+        :type z: float
+        :param nGrids: Number of segments on each dimension. Usefull for precision.
+        :type nGrids: int
+        :param rho: reflexion coefficient. A floating number between 0 and 1.
+        :type rho: float
+        """
         self.__controller = Controller(x, y, z, nGrids, rho)
         self.__events = []
         self.__current_event = None
@@ -98,6 +136,22 @@ class Simulator:
         self.default_values()
 
     def default_values(self):
+        """
+        Set the default simulation values, that are:
+
+        * lambdaS = 3
+        * mu = 10
+        * seedArrive = 12345
+        * seedDeparture = 1234
+        * seedX = 1235
+        * seedY = 1245
+        * seedZ = 1345
+        * seedRandomWait = 1345
+        * seedCapacityRequired = 1345
+        * goalConnections = 10000
+        * lower_random_wait = 5
+        * upper_random_wait = 15
+        """
         self.__initReady = False
         self.__lambdaS = 3
         self.__mu = 10
@@ -113,9 +167,16 @@ class Simulator:
         self.__goalConnections = 10000
         self.__lower_random_wait = 5
         self.__upper_random_wait = 15
+        self.__controller.allocator = Controller.default_alloc
 
     @property
-    def upper_capacity_required(self):
+    def upper_capacity_required(self) -> float:
+        """
+        The upper possible capacity required
+
+        :return: Upper capacity required
+        :rtype: float
+        """
         return self.__upper_capacity_required
 
     @upper_capacity_required.setter
@@ -123,7 +184,13 @@ class Simulator:
         self.__upper_capacity_required = value
 
     @property
-    def lower_capacity_required(self):
+    def lower_capacity_required(self) -> float:
+        """
+        The lower possible capacity required
+
+        :return: Lower capacity required
+        :rtype: float
+        """
         return self.__lower_capacity_required
 
     @lower_capacity_required.setter
@@ -132,6 +199,12 @@ class Simulator:
 
     @property
     def seedCapacityRequired(self) -> int:
+        """
+        Seed of capacity required random generator
+
+        :return: random generator seed
+        :rtype: int
+        """
         return self.__seedCapacityRequired
 
     @seedCapacityRequired.setter
@@ -139,7 +212,13 @@ class Simulator:
         self.__seedCapacityRequired = value
 
     @property
-    def upper_random_wait(self):
+    def upper_random_wait(self) -> float:
+        """
+        the upper possible random wait
+
+        :return: upper waiting time
+        :rtype: float
+        """
         return self.__upper_random_wait
 
     @upper_random_wait.setter
@@ -147,7 +226,13 @@ class Simulator:
         self.__upper_random_wait = value
 
     @property
-    def lower_random_wait(self):
+    def lower_random_wait(self) -> float:
+        """
+        The lower possible random wait
+
+        :return: lower waiting time
+        :rtype: float
+        """
         return self.__lower_random_wait
 
     @lower_random_wait.setter
@@ -155,9 +240,12 @@ class Simulator:
         self.__lower_random_wait = value
 
     @property
-    def lambdaS(self):
+    def lambdaS(self) -> float:
         """
         Get or set the attribute lambda.
+
+        :return: lambda attribute
+        :rtype: float
         """
         return self.__lambdaS
 
@@ -171,9 +259,12 @@ class Simulator:
         self.__lambdaS = lambdaS
 
     @property
-    def mu(self):
+    def mu(self) -> float:
         """
         Get or set the attribute mu.
+
+        :return: mu attribute
+        :rtype: float
         """
         return self.__mu
 
@@ -187,9 +278,12 @@ class Simulator:
         self.__mu = mu
 
     @property
-    def seedX(self):
+    def seedX(self) -> int:
         """
-        Get or set the attribute seedArrive.
+        Get or set the attribute seedX.
+
+        :return: the seed of random X generator
+        :rtype: int
         """
         return self.__seedX
 
@@ -203,9 +297,12 @@ class Simulator:
         self.__seedX = seedX
 
     @property
-    def seedY(self):
+    def seedY(self) -> int:
         """
-        Get or set the attribute seedDeparture.
+        Get or set the attribute seedY.
+
+        :return: the seed of random Y generator
+        :rtype: int
         """
         return self.__seedY
 
@@ -219,9 +316,12 @@ class Simulator:
         self.__seedY = seedY
 
     @property
-    def seedZ(self):
+    def seedZ(self) -> int:
         """
-        Get or set the attribute seedBitRate.
+        Get or set the attribute seedZ.
+
+        :return: the seed of random Z generator
+        :rtype: int
         """
         return self.__seedZ
 
@@ -235,9 +335,12 @@ class Simulator:
         self.__seedZ = seedZ
 
     @property
-    def seedRandomWait(self):
+    def seedRandomWait(self) -> int:
         """
-        Get or set the attribute seedBitRate.
+        Get or set the attribute seedRandomWait.
+
+        :return: the seed of random random-wait generator
+        :rtype: int
         """
         return self.__seedRandomWait
 
@@ -251,9 +354,12 @@ class Simulator:
         self.__seedRandomWait = seedRandomWait
 
     @property
-    def goalConnections(self):
+    def goalConnections(self) -> int:
         """
         Get or set the attribute goalConnections.
+
+        :return: The goal connections
+        :rtype: int
         """
         return self.__goalConnections
 
@@ -267,6 +373,9 @@ class Simulator:
         self.__goalConnections = goalConnections
 
     def print_initial_info(self):
+        """
+        Prints the initial info of simulation.
+        """
         print(
             "Scenario:\t %s x %s x %s"
             % (
@@ -314,6 +423,12 @@ class Simulator:
         print("=" * 146)
 
     def print_row(self, event):
+        """
+        print every simulation row
+
+        :param event: The event to print_
+        :type event: Event
+        """
         text = ""
         text = "{:9.4f}".format(event.time) + "|"
         if event.type == Event.event.ARRIVE:
@@ -372,6 +487,9 @@ class Simulator:
         print(text)
 
     def event_routine(self):
+        """
+        The event routine. This function selects the event and run the associated routine.
+        """
         self.__current_event = self.__events[0]
         self.__rtn_allocation = None
         self.__clock = self.__current_event.time
@@ -550,11 +668,13 @@ class Simulator:
             #             self.__events.insert(pos + 1, e)
             #             break
         self.__events.pop(0)
-        self.print_row(self.__current_event)
 
         return self.__rtn_allocation
 
     def init(self):
+        """
+        Simulation init. Initialize every simulation parameter.
+        """
         self.__initReady = True
         self.__clock = 0
         self.__arrival_variable = np.random.default_rng(self.__seedArrive)
@@ -586,29 +706,59 @@ class Simulator:
         return
 
     def run(self):
+        """
+        Run this simulation with the parameters.
+        """
         self.print_initial_info()
         while self.__numberOfConnections <= self.__goalConnections:
             # for i in range(self.__goalConnections):
             self.event_routine()
+            self.print_row(self.__current_event)
         self.aggregated_metrics()
 
-    def time_duration(self):
+    def time_duration(self) -> float:
+        """
+        Duration time
+
+        :return: duration time
+        :rtype: float
+        """
         return self.__time_duration
 
-    def get_Blocking_Probability(self):
+    def get_Blocking_Probability(self) -> float:
+        """
+        Blocking probability
+
+        :return: blocking probability
+        :rtype: float
+        """
         blocking = round(
             1 - self.__allocatedConnections / self.__numberOfConnections, 2
         )
         return blocking
 
     def set_allocation_algorithm(self, alloc_alg):
+        """
+        Set allocation algorithm.
+
+        :param alloc_alg: Allocation algorithm
+        """
         self.__controller.allocator = alloc_alg
 
     @property
     def scenario(self):
+        """
+        Scenario used in this simulation
+
+        :return: Scenario
+        :rtype: Scenario
+        """
         return self.__controller.scenario
 
     def aggregated_metrics(self):
+        """
+        Number of users connected to each AP
+        """
         print("Number of users connected to each VLed")
         for i in range(self.__controller.scenario.numberOfVLeds):
             id = self.__controller.scenario.vleds[i].ID