add SystemPopulation state tracker

Author: geraintpalmer

ciw/tests/test_simulation.py

@@ -197,7 +197,7 @@ 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(self):
+    def test_simulate_until_deadlock_method_naiveblocking(self):
         ciw.seed(3)
         Q = ciw.Simulation(ciw.create_network_from_yml(
             'ciw/tests/testing_parameters/params_deadlock.yml'),
@@ -206,6 +206,15 @@ def test_simulate_until_deadlock_method(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):
+        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.SystemPopulation())
+        Q.simulate_until_deadlock()
+        self.assertEqual(round(Q.times_to_deadlock[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

@@ -86,6 +86,93 @@ def test_base_accept_method_within_simulation(self):
         self.assertEqual(Q.statetracker.state, None)
 
 
+class TestSystemPopulation(unittest.TestCase):
+    def test_systempop_init_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.SystemPopulation()
+        B.initialise(Q)
+        self.assertEqual(B.simulation, Q)
+        self.assertEqual(B.state, 0)
+
+    def test_systempop_change_state_accept_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.SystemPopulation()
+        B.initialise(Q)
+        self.assertEqual(B.state, 0)
+        B.change_state_accept(1, 1)
+        self.assertEqual(B.state, 1)
+
+    def test_systempop_change_state_block_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.SystemPopulation()
+        B.initialise(Q)
+        B.state = 1
+        B.change_state_block(1, 1, 2)
+        self.assertEqual(B.state, 1)
+
+    def test_systempop_change_state_release_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.SystemPopulation()
+        B.initialise(Q)
+        B.state = 15
+        B.change_state_release(1, 1, 2, False)
+        self.assertEqual(B.state, 14)
+        B.change_state_release(1, 1, 2, True)
+        self.assertEqual(B.state, 13)
+
+    def test_systempop_hash_state_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.SystemPopulation()
+        B.initialise(Q)
+        B.state = 13
+        self.assertEqual(B.hash_state(), 13)
+
+    def test_systempop_release_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.SystemPopulation())
+        N = Q.transitive_nodes[2]
+        inds = [ciw.Individual(i) for i in range(5)]
+        N.individuals = [inds]
+        for ind in N.individuals[0]:
+            srvr = N.find_free_server()
+            N.attach_server(srvr, ind)
+        Q.statetracker.state = 14
+        self.assertEqual(Q.statetracker.state, 14)
+        Q.current_time = 43.11
+        N.release(0, Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, 14)
+        N.all_individuals[1].is_blocked = True
+        Q.current_time = 46.72
+        N.release(1, Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, 14)
+        N.release(1, Q.nodes[-1])
+        self.assertEqual(Q.statetracker.state, 13)
+
+    def test_systempop_block_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.SystemPopulation())
+        N = Q.transitive_nodes[2]
+        Q.statetracker.state = 14
+        self.assertEqual(Q.statetracker.state, 14)
+        N.block_individual(ciw.Individual(1), Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, 14)
+
+    def test_systempop_accept_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.SystemPopulation())
+        N = Q.transitive_nodes[2]
+        self.assertEqual(Q.statetracker.state, 0)
+        Q.current_time = 45.6
+        N.accept(ciw.Individual(3, 2))
+        self.assertEqual(Q.statetracker.state,  1)
 
 
 class TestNaiveBlocking(unittest.TestCase):
@@ -363,7 +450,7 @@ def test_matrix_accept_method_within_simulation(self):
 
 
 class TestTrackHistory(unittest.TestCase):
-    def test_one_node_deterministic_(self):
+    def test_one_node_deterministic_naiveblocking(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])],
@@ -398,3 +485,39 @@ def test_one_node_deterministic_(self):
         [Decimal('15.0'), ((0, 0),)]
         ]
         self.assertEqual(Q.statetracker.history, expected_history)
+
+    def test_one_node_deterministic_systempopulation(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.SystemPopulation()
+        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

@@ -41,10 +41,53 @@ def timestamp(self):
         self.history.append([self.simulation.current_time, self.hash_state()])
 
 
+class SystemPopulation(StateTracker):
+    """
+    The system population tracker records the number of customers in the
+    system, regaerdless of node.
+
+    Example:
+        3
+        This denotes 3 customers at in the whole system.
+    """
+    def initialise(self, simulation):
+        """
+        Initialises the state tracker class.
+        """
+        self.simulation = simulation
+        self.state = 0
+        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 += 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 -= 1
+
+    def hash_state(self):
+        """
+        Returns a hashable state.
+        """
+        return self.state
+
+
 class NaiveBlocking(StateTracker):
     """
-    The naive blocking tracker simple records the number of customers
-    at each node, and how many of those customers are currently blocked.
+    The naive blocking tracker records the number of customers at each node,
+    and how many of those customers are currently blocked.
 
     Example:
         ((3, 0), (1, 4))

docs/Reference/state_trackers.rst

@@ -6,10 +6,30 @@ List of Implemented State Trackers for Deadlock Detection
 
 Currently Ciw has the following state trackers:
 
+- :ref:`population`
 - :ref:`naive`
 - :ref:`matrix`
 
 
+.. _population:
+
+----------------------------
+The SystemPopulation Tracker
+----------------------------
+
+The SystemPopulation Tracker records the number of customers in the whole system, regardless of which node they are at.
+States take the form of a number:
+
+    4
+
+This denotes that there are four customers in the system.
+
+The Simulation object takes in the optional argument :code:`tracker` used as follows::
+
+    >>> Q = ciw.Simulation(N, tracker=ciw.trackers.SystemPopulation()) # doctest:+SKIP
+
+
+
 .. _naive:
 
 -------------------------