Finalised tests for WFQ, all pass

Axel Dahlberg · Axel Dahlberg · commit cbd044d5b609 · 2018-12-11T18:28:07.000+01:00
diff --git a/.flake8 b/.flake8
@@ -1,6 +1,6 @@
 [flake8]
 count = True
 exclude = bin, docs, .git, .idea, __pycache__
-ignore = W291 W293 E402
+ignore = W291 W293 E402 W503 W504
 max-line-length = 120
 statistics = True
diff --git a/qlinklayer/datacollection.py b/qlinklayer/datacollection.py
@@ -1,6 +1,5 @@
 import abc
 import numpy as np
-import bitstring
 from easysquid.puppetMaster import PM_SQLDataSequence
 from easysquid.toolbox import logger
 from netsquid.pydynaa import Entity, EventHandler
diff --git a/qlinklayer/egp.py b/qlinklayer/egp.py
@@ -1003,7 +1003,7 @@ def _create_ok(self, creq, mhp_seq):
         """
         # Get the fidelity estimate from FEU
         logger.debug("Estimating fidelity")
-        fidelity_estimate = self.feu.estimated_fidelity
+        fidelity_estimate = self.feu.estimate_fidelity_of_request(creq)
 
         # Create entanglement identifier
         logical_id = self.scheduler.curr_storage_id()
diff --git a/qlinklayer/feu.py b/qlinklayer/feu.py
@@ -99,7 +99,7 @@ def get_max_fidelity(self):
 
         return max([f[1] for f in self.achievable_fidelities])
 
-    def select_bright_state(self, min_fidelity):
+    def select_bright_state(self, min_fidelity, return_fidelity=False):
         """
         Given a minimum desired fidelity returns the largest bright state population that achieves this fidelity
         :param min_fidelity: float
@@ -109,10 +109,23 @@ def select_bright_state(self, min_fidelity):
         """
         for bright_state, fidelity in reversed(self.achievable_fidelities):
             if fidelity >= min_fidelity:
-                return bright_state
+                if return_fidelity:
+                    return bright_state, fidelity
+                else:
+                    return bright_state
 
         return None
 
+    def estimate_fidelity_of_request(self, request):
+        """
+        Estimates the fidelity of a given request
+        The request object must have an attribute 'min_fidelity'.
+        :param request:
+        :return: float
+        """
+        _, fidelity = self.select_bright_state(request.min_fidelity, return_fidelity=True)
+        return fidelity
+
     def _estimate_fidelity(self, alphaA=None, alphaB=None):
         """
         Calculates the fidelity by extracting parameters from the mhp components, calculating an estimated state of
@@ -141,8 +154,13 @@ def _compute_total_detection_probability_of_node(self, node):
         what is the probability that a detector clicks at the midpoint. (assuming no dark counts)
         :return: float
         """
-        p_zero_phonon = node.qmem.photon_emission_noise.p_zero_phonon
-        collection_eff = node.qmem.photon_emission_noise.collection_eff
+        photon_emission_noise = node.qmem.photon_emission_noise
+        if photon_emission_noise is None:
+            p_zero_phonon = 1
+            collection_eff = 1
+        else:
+            p_zero_phonon = node.qmem.photon_emission_noise.p_zero_phonon
+            collection_eff = node.qmem.photon_emission_noise.collection_eff
         mhp_conn = self.mhp_service.get_mhp_conn(node)
         if node == mhp_conn.nodeA:
             p_no_loss = self.mhp_service.get_fibre_transmissivities(node)[0]
@@ -156,7 +174,8 @@ def _compute_total_detection_probability_of_node(self, node):
 
     def _compute_conditional_detection_probabilities(self, alphaA=None, alphaB=None):
         """
-        Computes the probabilites p_uu, p_ud, pdu, pdd as given in eq (10) in https://arxiv.org/src/1712.07567v2/anc/SupplementaryInformation.pdf
+        Computes the probabilites p_uu, p_ud, pdu, pdd as given in eq (10) in
+        https://arxiv.org/src/1712.07567v2/anc/SupplementaryInformation.pdf
         Note that this assumed low detection efficiencies
         If either alphaA or alphaB is None, then alpha is assumed to be the same for the two nodes.
 
@@ -174,17 +193,18 @@ def _compute_conditional_detection_probabilities(self, alphaA=None, alphaB=None)
         mhp_conn = self.mhp_service.get_mhp_conn(self.node)
         p_dc = mhp_conn.midPoint.pdark
         # Dark count probabilities for both detectors
-        p_no_dc = (1 - p_dc)**2
+        p_no_dc = (1 - p_dc) ** 2
         p_at_least_one_dc = 1 - p_no_dc
 
-        prob_click_given_two_photons = (p_no_dc * (p_det_A*(1-p_det_B) + p_det_B*(1-p_det_A) + p_det_A*p_det_B) +
-                                        p_at_least_one_dc * (1-p_det_A) * (1-p_det_B))
+        prob_click_given_two_photons = (
+            p_no_dc * (p_det_A * (1 - p_det_B) + p_det_B * (1 - p_det_A) + p_det_A * p_det_B)
+            + p_at_least_one_dc * (1 - p_det_A) * (1 - p_det_B))
         p_uu = alphaA * alphaB * prob_click_given_two_photons
 
-        prob_click_given_photon_A = p_no_dc * p_det_A + p_at_least_one_dc * (1-p_det_A)
-        prob_click_given_photon_B = p_no_dc * p_det_B + p_at_least_one_dc * (1-p_det_B)
-        p_ud = alphaA * (1-alphaB) * prob_click_given_photon_A
-        p_du = alphaB * (1-alphaA) * prob_click_given_photon_B
+        prob_click_given_photon_A = p_no_dc * p_det_A + p_at_least_one_dc * (1 - p_det_A)
+        prob_click_given_photon_B = p_no_dc * p_det_B + p_at_least_one_dc * (1 - p_det_B)
+        p_ud = alphaA * (1 - alphaB) * prob_click_given_photon_A
+        p_du = alphaB * (1 - alphaA) * prob_click_given_photon_B
 
         prob_click_given_no_photons = p_at_least_one_dc
         p_dd = (1 - alphaA) * (1 - alphaB) * prob_click_given_no_photons
diff --git a/qlinklayer/localQueue.py b/qlinklayer/localQueue.py
@@ -425,15 +425,15 @@ def update_mhp_cycle_number(self, current_cycle, max_cycle):
             The max MHP cycle
         """
         logger.debug("Updating to MHP cycle {}".format(current_cycle))
-        if self.timeout_cycle is not None and self.timeout_cycle > 0:
+        if self.timeout_cycle is not None:
             if check_schedule_cycle_bounds(current_cycle, max_cycle, self.timeout_cycle):
                 logger.debug("Item timed out, calling callback")
                 if not self.acked:
                     logger.warning("Item timed out before being acknowledged.")
                 self.timeout_callback(self)
         if self.acked:
             if not self.ready:
-                if self.schedule_cycle > 0:
+                if self.schedule_cycle is not None:
                     if check_schedule_cycle_bounds(current_cycle, max_cycle, self.schedule_cycle):
                         self.ready = True
                         logger.debug("Item is ready to be scheduled")
@@ -456,7 +456,8 @@ def update_virtual_finish(self):
         :return: None
         """
         if not self.request.atomic:
-            self.virtual_finish += self.cycles_per_pair
+            if self.virtual_finish is not None:
+                self.virtual_finish += self.cycles_per_pair
 
 
 class _TimeoutLocalQueueItem(_LocalQueueItem, Entity):
diff --git a/qlinklayer/scheduler.py b/qlinklayer/scheduler.py
@@ -13,12 +13,14 @@
 SchedulerRequest = namedtuple("Scheduler_request",
                               ["sched_cycle", "timeout_cycle", "min_fidelity", "purpose_id", "create_id", "num_pairs",
                                "priority", "store", "atomic", "measure_directly", "master_request"])
-SchedulerRequest.__new__.__defaults__ = (0,) * 7 + (True, False, False, True)
+SchedulerRequest.__new__.__defaults__ = (0,) * 5 + (1,) + (0,) + (True, False, False, True)
 
 WFQSchedulerRequest = namedtuple("WFQ_Scheduler_request",
-                                 ["sched_cycle", "timeout_cycle", "min_fidelity", "purpose_id", "create_id", "num_pairs",
-                                  "priority", "init_virtual_finish", "est_cycles_per_pair", "store", "atomic", "measure_directly", "master_request"])
-WFQSchedulerRequest.__new__.__defaults__ = (0,) * 9 + (True, False, False, True)
+                                 ["sched_cycle", "timeout_cycle", "min_fidelity", "purpose_id", "create_id",
+                                  "num_pairs",
+                                  "priority", "init_virtual_finish", "est_cycles_per_pair", "store", "atomic",
+                                  "measure_directly", "master_request"])
+WFQSchedulerRequest.__new__.__defaults__ = (0,) * 5 + (1,) + (0,) * 3 + (True, False, False, True)
 
 SchedulerGen = namedtuple("Scheduler_gen", ["flag", "aid", "comm_q", "storage_q", "param"])
 SchedulerGen.__new__.__defaults__ = (False,) + (None,) * 4
@@ -48,11 +50,10 @@ def next(self):
 
 
 class StrictPriorityRequestScheduler(Scheduler):
-
     # The scheduler request named tuple to use
     _scheduler_request_named_tuple = SchedulerRequest
 
-    def __init__(self, distQueue, qmm, feu):
+    def __init__(self, distQueue, qmm, feu=None):
         """
         Stub for a scheduler to decide how we assign and consume elements of the queue.
         This scheduler puts requests in queues depending on only their specified priority
@@ -199,11 +200,13 @@ def _get_scheduler_request(cls, egp_request, create_id, sched_cycle, timeout_cyc
         :return: :obj:`~qlinklayer.scheduler.SchedulerRequest`
         """
         scheduler_request = cls._scheduler_request_named_tuple(sched_cycle=sched_cycle, timeout_cycle=timeout_cycle,
-                                             min_fidelity=egp_request.min_fidelity, purpose_id=egp_request.purpose_id,
-                                             create_id=create_id, num_pairs=egp_request.num_pairs,
-                                             priority=egp_request.priority, store=egp_request.store,
-                                             atomic=egp_request.atomic, measure_directly=egp_request.measure_directly,
-                                             master_request=master_request)
+                                                               min_fidelity=egp_request.min_fidelity,
+                                                               purpose_id=egp_request.purpose_id,
+                                                               create_id=create_id, num_pairs=egp_request.num_pairs,
+                                                               priority=egp_request.priority, store=egp_request.store,
+                                                               atomic=egp_request.atomic,
+                                                               measure_directly=egp_request.measure_directly,
+                                                               master_request=master_request)
 
         return scheduler_request
 
@@ -793,11 +796,10 @@ def _reset_outstanding_req_data(self):
 
 
 class WFQRequestScheduler(StrictPriorityRequestScheduler):
-
     # The scheduler request named tuple to use
     _scheduler_request_named_tuple = WFQSchedulerRequest
 
-    def __init__(self, distQueue, qmm, feu, weights=None):
+    def __init__(self, distQueue, qmm, feu=None, weights=None):
         """
         Stub for a scheduler to decide how we assign and consume elements of the queue.
         This weighted fair queue (WFQ) scheduler implements a weighted fair queue where queue i
@@ -851,6 +853,17 @@ def _compare_mhp_cycle(self, cycle1, cycle2):
         else:
             return 1
 
+    def _get_largest_mhp_cycle(self):
+        """
+        Return the MHP which is considered largest, which comparison of MHP cycles is defined
+        in self._compare_mhp_cycle
+        :return: int
+        """
+        # Compute opposite of current
+        opposite = self.mhp_cycle_number - int(self.max_mhp_cycle_number / 2)
+
+        return (opposite - 1) % self.max_mhp_cycle_number
+
     def _get_relative_weights(self, weights):
         if weights is None:
             return [1] * len(self.distQueue.queueList)
@@ -863,7 +876,8 @@ def _get_relative_weights(self, weights):
                 if weight < 0:
                     raise ValueError("All weights need to be non-zero")
             except TypeError:
-                raise ValueError("Weights need to be comparable, got TypeError when comparing weight={} to 0".format(weight))
+                raise ValueError(
+                    "Weights need to be comparable, got TypeError when comparing weight={} to 0".format(weight))
 
         # Compute relative weights
         total_sum = sum(weights)
@@ -883,16 +897,18 @@ def select_queue(self):
         # Virt start is the virtual start of the service (see https://en.wikipedia.org/wiki/Fair_queuing#Pseudo_code)
         # Look through the head of each queue and pick the one with the smallest virtual_finish
         # unless a queue has infinite (0) weight.
-        min_virtual_finish = float('inf')
+        min_virtual_finish = self._get_largest_mhp_cycle()
         queue_item_to_use = None
-        for local_queue in self.distQueue.queueList:
+
+        # Go in reverse such that if two items have the same virt finish, take the one with the lowest qid
+        for local_queue in reversed(self.distQueue.queueList):
             queue_item = local_queue.peek()
             if queue_item is not None and queue_item.ready:
-                if queue_item.request.virtual_finish is None:
+                if queue_item.request.init_virtual_finish is None:
                     # This queue has infinite weight so just take this queue_item directly
                     queue_item_to_use = queue_item
                     break
-                if self._compare_mhp_cycle(queue_item.virtual_finish, min_virtual_finish) == -1:
+                if self._compare_mhp_cycle(queue_item.virtual_finish, min_virtual_finish) < 1:
                     min_virtual_finish = queue_item.virtual_finish
                     queue_item_to_use = queue_item
         if queue_item_to_use is None:
@@ -912,7 +928,8 @@ def set_virtual_finish(self, scheduler_request, qid):
         # If queue has weight zero (seen as infinite) we put virtual finish to None
         if self.relative_weights[qid] == 0:
             init_virt_finish = None
-            wfq_scheduler_request = WFQSchedulerRequest(**scheduler_request._asdict(), init_virtual_finish=init_virt_finish)
+            wfq_scheduler_request = WFQSchedulerRequest(**scheduler_request._asdict(),
+                                                        init_virtual_finish=init_virt_finish)
         else:
             virt_start = max(self.mhp_cycle_number, self.last_virt_finish[qid])
             est_nr_cycles_per_pair = self._estimate_nr_of_cycles_per_pair(scheduler_request)
@@ -924,11 +941,14 @@ def set_virtual_finish(self, scheduler_request, qid):
                 self.last_virt_finish[qid] = virt_start + virt_duration / self.relative_weights[qid]
             else:
                 virt_duration = est_nr_cycles_per_pair
-                self.last_virt_finish[qid] = virt_start + virt_duration * scheduler_request.num_pairs /self.relative_weights[qid]
+                self.last_virt_finish[qid] = (
+                    virt_start + virt_duration * scheduler_request.num_pairs / self.relative_weights[qid])
 
             # Compute initial virt finish (if non-atomic this will be updated per success)
             init_virt_finish = virt_start + virt_duration / self.relative_weights[qid]
-            wfq_scheduler_request = WFQSchedulerRequest(**scheduler_request._asdict(), init_virtual_finish=init_virt_finish, est_cycles_per_pair=est_nr_cycles_per_pair)
+            wfq_scheduler_request = WFQSchedulerRequest(**scheduler_request._asdict(),
+                                                        init_virtual_finish=init_virt_finish,
+                                                        est_cycles_per_pair=est_nr_cycles_per_pair)
 
         return wfq_scheduler_request
 
diff --git a/tests/test_feu.py b/tests/test_feu.py
@@ -1,10 +1,7 @@
 import unittest
-from easysquid.toolbox import EasySquidException
 from qlinklayer.feu import SingleClickFidelityEstimationUnit
 from qlinklayer.mhp import SimulatedNodeCentricMHPService
 from qlinklayer.toolbox import LinkLayerException
-from easysquid.qnode import QuantumNode
-from easysquid.quantumMemoryDevice import NVCommunicationDevice
 from easysquid.easynetwork import setup_physical_network
 from util.config_paths import ConfigPathStorage
 from netsquid.qubits import dm_fidelity
@@ -65,7 +62,7 @@ def test_success_prob_est(self):
 
         # Test linearity in alpha
         for i in range(11):
-            alpha = i/20
+            alpha = i / 20
             p_succ = self.feuA._estimate_success_probability(alpha)
             self.assertAlmostEqual(p_succ, 2 * alpha * (4e-4), places=4)
 
@@ -78,7 +75,7 @@ def test_fidelity_estimation(self):
 
         # Check linearity in alpha (for high enough alpha due to dark counts)
         for i in range(40, 100):
-            alpha = i/200
+            alpha = i / 200
             F = self.feuA._estimate_fidelity(alpha)
             self.assertAlmostEqual(F, 1 - alpha, places=1)
 
diff --git a/tests/test_scheduler.py b/tests/test_scheduler.py
diff --git a/tests/test_simulations.py b/tests/test_simulations.py
