add NodePopulation tracker

Author: geraintpalmer

ciw/tests/test_simulation.py

@@ -197,7 +197,8 @@ def test_simulate_until_max_customers_with_pbar_method(self):
         self.assertEqual(Q3.progress_bar.total, max_custs)
         self.assertEqual(Q3.progress_bar.n, max_custs)
 
-    def test_simulate_until_deadlock_method_naiveblocking(self):
+    def test_simulate_until_deadlock_method(self):
+        # NaiveBlocking tracker
         ciw.seed(3)
         Q = ciw.Simulation(ciw.create_network_from_yml(
             'ciw/tests/testing_parameters/params_deadlock.yml'),
@@ -206,7 +207,7 @@ def test_simulate_until_deadlock_method_naiveblocking(self):
         Q.simulate_until_deadlock()
         self.assertEqual(round(Q.times_to_deadlock[((0, 0), (0, 0))], 8), 53.88526441)
 
-    def test_simulate_until_deadlock_method_systempopulation(self):
+        # SystemPopulation tracker
         ciw.seed(3)
         Q = ciw.Simulation(ciw.create_network_from_yml(
             'ciw/tests/testing_parameters/params_deadlock.yml'),
@@ -215,6 +216,15 @@ def test_simulate_until_deadlock_method_systempopulation(self):
         Q.simulate_until_deadlock()
         self.assertEqual(round(Q.times_to_deadlock[0], 8), 53.88526441)
 
+        # NodePopulation tracker
+        ciw.seed(3)
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params_deadlock.yml'),
+             deadlock_detector=ciw.deadlock.StateDigraph(),
+             tracker=ciw.trackers.NodePopulation())
+        Q.simulate_until_deadlock()
+        self.assertEqual(round(Q.times_to_deadlock[(0, 0)], 8), 53.88526441)
+
     def test_detect_deadlock_method(self):
         Q = ciw.Simulation(ciw.create_network_from_yml(
             'ciw/tests/testing_parameters/params_deadlock.yml'),

ciw/tests/test_state_tracker.py

@@ -521,3 +521,40 @@ def test_one_node_deterministic_systempopulation(self):
         [Decimal('15.0'), 0]
         ]
         self.assertEqual(Q.statetracker.history, expected_history)
+
+
+    def test_one_node_deterministic_nodepopulation(self):
+        N = ciw.create_network(
+            arrival_distributions=[ciw.dists.Sequential([1.5, 0.3, 2.4, 1.1])],
+            service_distributions=[ciw.dists.Sequential([1.8, 2.2, 0.2, 0.2, 0.2, 0.2])],
+            number_of_servers=[1]
+        )
+        B = ciw.trackers.NodePopulation()
+        Q = ciw.Simulation(N, tracker=B, exact=26)
+        Q.simulate_until_max_time(15.5)
+        expected_history = [
+        [Decimal('0.0'), (0,)],
+        [Decimal('1.5'), (1,)],
+        [Decimal('1.8'), (2,)],
+        [Decimal('3.3'), (1,)],
+        [Decimal('4.2'), (2,)],
+        [Decimal('5.3'), (3,)],
+        [Decimal('5.5'), (2,)],
+        [Decimal('5.7'), (1,)],
+        [Decimal('5.9'), (0,)],
+        [Decimal('6.8'), (1,)],
+        [Decimal('7.0'), (0,)],
+        [Decimal('7.1'), (1,)],
+        [Decimal('7.3'), (0,)],
+        [Decimal('9.5'), (1,)],
+        [Decimal('10.6'), (2,)],
+        [Decimal('11.3'), (1,)],
+        [Decimal('12.1'), (2,)],
+        [Decimal('12.4'), (3,)],
+        [Decimal('13.5'), (2,)],
+        [Decimal('13.7'), (1,)],
+        [Decimal('13.9'), (0,)],
+        [Decimal('14.8'), (1,)],
+        [Decimal('15.0'), (0,)]
+        ]
+        self.assertEqual(Q.statetracker.history, expected_history)

ciw/trackers/state_tracker.py

@@ -48,7 +48,7 @@ class SystemPopulation(StateTracker):
 
     Example:
         3
-        This denotes 3 customers at in the whole system.
+        This denotes 3 customers in the whole system.
     """
     def initialise(self, simulation):
         """
@@ -84,6 +84,50 @@ def hash_state(self):
         return self.state
 
 
+class NodePopulation(StateTracker):
+    """
+    The node population tracker records the number of customers at each node.
+
+    Example:
+        (3, 1)
+        This denotes 3 customers at the first node, and 1 customer at the
+        second node.
+    """
+    def initialise(self, simulation):
+        """
+        Initialises the state tracker class.
+        """
+        self.simulation = simulation
+        self.state = [0 for i in range(
+            self.simulation.network.number_of_nodes)]
+        self.history = []
+        self.timestamp()
+
+    def change_state_accept(self, node_id, cust_clss):
+        """
+        Changes the state of the system when a customer is accepted.
+        """
+        self.state[node_id-1] += 1
+
+    def change_state_block(self, node_id, destination, cust_clss):
+        """
+        Changes the state of the system when a customer gets blocked.
+        """
+        pass
+
+    def change_state_release(self, node_id, destination, cust_clss, blocked):
+        """
+        Changes the state of the system when a customer is released.
+        """
+        self.state[node_id-1] -= 1
+
+    def hash_state(self):
+        """
+        Returns a hashable state.
+        """
+        return tuple(self.state)
+
+
 class NaiveBlocking(StateTracker):
     """
     The naive blocking tracker records the number of customers at each node,

docs/Reference/state_trackers.rst

@@ -1,12 +1,13 @@
 .. _refs-statetrackers:
 
-=========================================================
-List of Implemented State Trackers for Deadlock Detection
-=========================================================
+==================================
+List of Implemented State Trackers
+==================================
 
 Currently Ciw has the following state trackers:
 
 - :ref:`population`
+- :ref:`nodepop`
 - :ref:`naive`
 - :ref:`matrix`
 
@@ -29,6 +30,24 @@ The Simulation object takes in the optional argument :code:`tracker` used as fol
     >>> Q = ciw.Simulation(N, tracker=ciw.trackers.SystemPopulation()) # doctest:+SKIP
 
 
+.. _nodepop:
+
+----------------------------
+The NodePopulation Tracker
+----------------------------
+
+The NodePopulation Tracker records the number of customers at each node.
+States take the form of list of numbers. An example for a three node queueing network is shown below::
+
+    [2, 0, 5]
+
+This denotes that there are two customers at the first node, no customers at the second node, and five customers at the third node.
+
+The Simulation object takes in the optional argument :code:`tracker` used as follows::
+
+    >>> Q = ciw.Simulation(N, tracker=ciw.trackers.NodePopulation()) # doctest:+SKIP
+
+
 
 .. _naive: