add NodeClassMatrix tracker

Author: geraintpalmer

ciw/tests/test_simulation.py

@@ -225,6 +225,16 @@ def test_simulate_until_deadlock_method(self):
         Q.simulate_until_deadlock()
         self.assertEqual(round(Q.times_to_deadlock[(0, 0)], 8), 53.88526441)
 
+        # NodeClassMatrix 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.NodeClassMatrix())
+        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

@@ -175,6 +175,184 @@ def test_systempop_accept_method_within_simulation(self):
         self.assertEqual(Q.statetracker.state,  1)
 
 
+class TestNodePopulation(unittest.TestCase):
+    def test_nodepop_init_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodePopulation()
+        B.initialise(Q)
+        self.assertEqual(B.simulation, Q)
+        self.assertEqual(B.state, [0, 0, 0, 0])
+
+    def test_nodepop_change_state_accept_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodePopulation()
+        B.initialise(Q)
+        self.assertEqual(B.state, [0, 0, 0, 0])
+        B.change_state_accept(1, 1)
+        self.assertEqual(B.state, [1, 0, 0, 0])
+
+    def test_nodepop_change_state_block_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodePopulation()
+        B.initialise(Q)
+        B.state = [1, 0, 0, 0]
+        B.change_state_block(1, 1, 2)
+        self.assertEqual(B.state, [1, 0, 0, 0])
+
+    def test_nodepop_change_state_release_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodePopulation()
+        B.initialise(Q)
+        B.state = [3, 3, 1, 8]
+        B.change_state_release(1, 1, 2, False)
+        self.assertEqual(B.state, [2, 3, 1, 8])
+        B.change_state_release(1, 1, 2, True)
+        self.assertEqual(B.state, [1, 3, 1, 8])
+
+    def test_nodepop_hash_state_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodePopulation()
+        B.initialise(Q)
+        B.state = [7, 3, 1, 0]
+        self.assertEqual(B.hash_state(), (7, 3, 1, 0))
+
+    def test_nodepop_release_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.NodePopulation())
+        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 = [5, 3, 6, 0]
+        self.assertEqual(Q.statetracker.state, [5, 3, 6, 0])
+        Q.current_time = 43.11
+        N.release(0, Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, [6, 3, 5, 0])
+        N.all_individuals[1].is_blocked = True
+        Q.current_time = 46.72
+        N.release(1, Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, [7, 3, 4, 0])
+        N.release(1, Q.nodes[-1])
+        self.assertEqual(Q.statetracker.state, [7, 3, 3, 0])
+
+    def test_nodepop_block_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.NodePopulation())
+        N = Q.transitive_nodes[2]
+        Q.statetracker.state = [5, 3, 6, 0]
+        self.assertEqual(Q.statetracker.state, [5, 3, 6, 0])
+        N.block_individual(ciw.Individual(1), Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, [5, 3, 6, 0])
+
+    def test_nodepop_accept_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.NodePopulation())
+        N = Q.transitive_nodes[2]
+        self.assertEqual(Q.statetracker.state, [0, 0, 0, 0])
+        Q.current_time = 45.6
+        N.accept(ciw.Individual(3, 2))
+        self.assertEqual(Q.statetracker.state, [0, 0, 1, 0])
+
+
+class TestNodeClassMatrix(unittest.TestCase):
+    def test_nodeclassmatrix_init_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodeClassMatrix()
+        B.initialise(Q)
+        self.assertEqual(B.simulation, Q)
+        self.assertEqual(B.state, [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
+
+    def test_nodeclassmatrix_change_state_accept_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodeClassMatrix()
+        B.initialise(Q)
+        self.assertEqual(B.state, [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
+        B.change_state_accept(1, 1)
+        self.assertEqual(B.state, [[0, 1, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
+
+    def test_nodeclassmatrix_change_state_block_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodeClassMatrix()
+        B.initialise(Q)
+        B.state = [[0, 1, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
+        B.change_state_block(1, 1, 1)
+        self.assertEqual(B.state, [[0, 1, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
+
+    def test_nodeclassmatrix_change_state_release_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodeClassMatrix()
+        B.initialise(Q)
+        B.state = [[0, 1, 2], [1, 1, 1], [0, 1, 0], [4, 3, 1]]
+        B.change_state_release(1, 1, 2, False)
+        self.assertEqual(B.state, [[0, 1, 1], [1, 1, 1], [0, 1, 0], [4, 3, 1]])
+        B.change_state_release(1, 1, 2, True)
+        self.assertEqual(B.state, [[0, 1, 0], [1, 1, 1], [0, 1, 0], [4, 3, 1]])
+
+    def test_nodeclassmatrix_hash_state_method(self):
+        Q = ciw.Simulation(ciw.create_network_from_yml(
+          'ciw/tests/testing_parameters/params.yml'))
+        B = ciw.trackers.NodeClassMatrix()
+        B.initialise(Q)
+        B.state = [[0, 2, 0], [1, 1, 1], [0, 1, 0], [4, 3, 1]]
+        self.assertEqual(B.hash_state(), ((0, 2, 0), (1, 1, 1), (0, 1, 0), (4, 3, 1)))
+
+    def test_nodeclassmatrix_release_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.NodeClassMatrix())
+        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 = [[3, 2, 1], [1, 1, 1], [3, 1, 2], [0, 0, 0]]
+        self.assertEqual(Q.statetracker.state, [[3, 2, 1], [1, 1, 1], [3, 1, 2], [0, 0, 0]])
+        Q.current_time = 43.11
+        N.release(0, Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, [[4, 2, 1], [1, 1, 1], [2, 1, 2], [0, 0, 0]])
+        N.all_individuals[1].is_blocked = True
+        Q.current_time = 46.72
+        N.release(1, Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, [[5, 2, 1], [1, 1, 1], [1, 1, 2], [0, 0, 0]])
+        N.release(1, Q.nodes[-1])
+        self.assertEqual(Q.statetracker.state, [[5, 2, 1], [1, 1, 1], [0, 1, 2], [0, 0, 0]])
+
+    def test_nodeclassmatrix_block_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.NodeClassMatrix())
+        N = Q.transitive_nodes[2]
+        Q.statetracker.state = [[3, 2, 1], [1, 1, 1], [3, 1, 2], [0, 0, 0]]
+        self.assertEqual(Q.statetracker.state, [[3, 2, 1], [1, 1, 1], [3, 1, 2], [0, 0, 0]])
+        N.block_individual(ciw.Individual(1), Q.nodes[1])
+        self.assertEqual(Q.statetracker.state, [[3, 2, 1], [1, 1, 1], [3, 1, 2], [0, 0, 0]])
+
+    def test_nodeclassmatrix_accept_method_within_simulation(self):
+        params = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = ciw.Simulation(params, tracker=ciw.trackers.NodeClassMatrix())
+        N = Q.transitive_nodes[2]
+        self.assertEqual(Q.statetracker.state, [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
+        Q.current_time = 45.6
+        N.accept(ciw.Individual(3, 2))
+        self.assertEqual(Q.statetracker.state, [[0, 0, 0], [0, 0, 0], [0, 0, 1], [0, 0, 0]])
+
+
 class TestNaiveBlocking(unittest.TestCase):
     def test_naive_init_method(self):
         Q = ciw.Simulation(ciw.create_network_from_yml(
@@ -264,7 +442,6 @@ def test_naive_accept_method_within_simulation(self):
         self.assertEqual(Q.statetracker.state, [[0, 0], [0, 0], [1, 0], [0, 0]])
 
 
-
 class TestMatrixBlocking(unittest.TestCase):
     def test_matrix_init_method(self):
         Q = ciw.Simulation(ciw.create_network_from_yml(
@@ -558,3 +735,39 @@ def test_one_node_deterministic_nodepopulation(self):
         [Decimal('15.0'), (0,)]
         ]
         self.assertEqual(Q.statetracker.history, expected_history)
+
+    def test_one_node_deterministic_nodeclassmatrix(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.NodeClassMatrix()
+        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

@@ -128,6 +128,54 @@ def hash_state(self):
         return tuple(self.state)
 
 
+class NodeClassMatrix(StateTracker):
+    """
+    The node-class matrix tracker records the number of customers of each
+    class at each node.
+
+    Example:
+        ((3, 1),
+         (0, 1))
+        This denotes 4 customers at the first node (3 of Class 0, 1 of
+        Class 0), and 1 customer at the second node (0 of Class 0, 1 of
+        Class 1).
+    """
+    def initialise(self, simulation):
+        """
+        Initialises the state tracker class.
+        """
+        self.simulation = simulation
+        self.state = [[0 for cls in range(
+            self.simulation.network.number_of_classes)] 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][cust_clss] += 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][cust_clss] -= 1
+
+    def hash_state(self):
+        """
+        Returns a hashable state.
+        """
+        return tuple(tuple(obs) for obs in self.state)
+
+
 class NaiveBlocking(StateTracker):
     """
     The naive blocking tracker records the number of customers at each node,

docs/Reference/state_trackers.rst

@@ -8,8 +8,9 @@ Currently Ciw has the following state trackers:
 
 - :ref:`population`
 - :ref:`nodepop`
-- :ref:`naive`
-- :ref:`matrix`
+- :ref:`nodeclssmatrix`
+- :ref:`naiveblock`
+- :ref:`matrixblock`
 
 
 .. _population:
@@ -32,9 +33,9 @@ The Simulation object takes in the optional argument :code:`tracker` used as fol
 
 .. _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::
@@ -48,8 +49,30 @@ The Simulation object takes in the optional argument :code:`tracker` used as fol
     >>> Q = ciw.Simulation(N, tracker=ciw.trackers.NodePopulation()) # doctest:+SKIP
 
 
+.. _nodeclssmatrix:
+
+---------------------------
+The NodeClassMatrix Tracker
+---------------------------
+
+The NodeClassPopulation Tracker records the number of customers at each node, split by customer class.
+States take the form of matrix, that is a list of lists, where the rows denote the nodes and the columns denote the customer classes. An example for a three node queueing network with two customer classes is shown below::
+
+    [[3, 0],
+     [0, 1],
+     [4, 1]]
+
+This denotes that there are:
+  + Three customers at the first node - three of Class 0, and none of Class 1
+  + One customer at the second node - none of Class 0, and one of Class 1
+  + Five customers at the third node - four of Class 0, and one of Class 1.
+
+The Simulation object takes in the optional argument :code:`tracker` used as follows::
+
+    >>> Q = ciw.Simulation(N, tracker=ciw.trackers.NodeClassMatrix()) # doctest:+SKIP
+
 
-.. _naive:
+.. _naiveblock:
 
 -------------------------
 The NaiveBlocking Tracker
@@ -67,7 +90,7 @@ The Simulation object takes in the optional argument :code:`tracker` used as fol
     >>> Q = ciw.Simulation(N, tracker=ciw.trackers.NaiveBlocking()) # doctest:+SKIP
 
 
-.. _matrix:
+.. _matrixblock:
 
 --------------------------
 The MatrixBlocking Tracker