def create_switch(basis_list, photons): class Receiver(): def __init__(self, tl): self.timeline = tl self.log = [] def get(self, photon=None): self.log.append((self.timeline.now(), photon)) tl = Timeline() sw = Switch("sw", tl) r1 = Receiver(tl) r2 = Receiver(tl) sw.set_detector(r1) sw.set_interferometer(r2) sw.set_basis_list(basis_list, 0, FREQ) tl.init() for i, photon in enumerate(photons): tl.time = 1e12 / FREQ * i sw.get(photons[i]) tl.time = 0 tl.run() return r1.log, r2.log
def test_generation_expire(): class DumbBSM(): def __init__(self): pass def get(self, qubit): pass tl = Timeline(1e12) e0 = Node("e0", tl) e1 = Node("e1", tl) m0 = FakeNode("m0", tl) qc0 = QuantumChannel("qc_e0m0", tl, 0, 1e3) qc1 = QuantumChannel("qc_e1m0", tl, 0, 1e3) qc0.set_ends(e0, m0) qc1.set_ends(e1, m0) cc0 = ClassicalChannel("cc_e0m0", tl, 1e3, delay=1e12) cc1 = ClassicalChannel("cc_e1m0", tl, 1e3, delay=1e12) cc2 = ClassicalChannel("cc_e0e1", tl, 2e3, delay=1e9) cc3 = ClassicalChannel("cc_e1e0", tl, 2e3, delay=1e9) cc0.set_ends(e0, m0) cc1.set_ends(e1, m0) cc2.set_ends(e0, e1) cc3.set_ends(e1, e0) e0.memory_array = MemoryArray("e0mem", tl, coherence_time=1) e1.memory_array = MemoryArray("e1mem", tl, coherence_time=1) e0.memory_array.owner = e0 e1.memory_array.owner = e1 m0.bsm = DumbBSM() tl.init() protocol0 = EntanglementGenerationA(e0, "e0prot", middle="m0", other="e1", memory=e0.memory_array[0]) protocol1 = EntanglementGenerationA(e1, "e1prot", middle="m0", other="e0", memory=e1.memory_array[0]) protocol0.primary = True e0.protocols.append(protocol0) e1.protocols.append(protocol1) protocol0.set_others(protocol1) protocol1.set_others(protocol0) process = Process(protocol0, "start", []) event = Event(0, process) tl.schedule(event) process = Process(protocol1, "start", []) event = Event(0, process) tl.schedule(event) tl.run() assert e0.memory_array[0].expiration_event.time > 1e12
def test_BB84_time_bin(): tl = Timeline(1e12) # stop time is 1 s alice = QKDNode("alice", tl, encoding=time_bin, stack_size=1) bob = QKDNode("bob", tl, encoding=time_bin, stack_size=1) pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0]) qc = QuantumChannel("qc", tl, distance=10e3, polarization_fidelity=0.99, attenuation=0.00002) qc.set_ends(alice, bob) cc = ClassicalChannel("cc", tl, distance=10e3) cc.set_ends(alice, bob) # Parent pa = Parent(alice, 128, "alice") pb = Parent(bob, 128, "bob") alice.protocol_stack[0].upper_protocols.append(pa) pa.lower_protocols.append(alice.protocol_stack[0]) bob.protocol_stack[0].upper_protocols.append(pb) pb.lower_protocols.append(bob.protocol_stack[0]) process = Process(pa, "push", []) event = Event(0, process) tl.schedule(event) tl.init() tl.run() assert pa.counter == pb.counter == 10
def test_run(): from numpy import random random.seed(0) tl = Timeline() dummy = Dummy("dummy", tl) times = random.randint(0, 20, 200) priorities = random.randint(0, 20, 200) for t, p in zip(times, priorities): process = Process(dummy, "op", []) e = Event(t, process, p) tl.schedule(e) tl.init() tl.run() assert dummy.counter == 200 tl = Timeline(5) for t, p in zip(times, priorities): process = Process(dummy, "op", []) e = Event(t, process, p) tl.schedule(e) tl.init() tl.run() assert tl.now() == tl.time < 5 and len(tl.events) > 0
def test_BBPSSW_success_rate(): tl = Timeline() a1 = FakeNode("a1", tl) a2 = FakeNode("a2", tl) cc0 = ClassicalChannel("cc0", tl, 0, 1e5) cc1 = ClassicalChannel("cc1", tl, 0, 1e5) cc0.delay = ONE_MILLISECOND cc1.delay = ONE_MILLISECOND cc0.set_ends(a1, a2) cc1.set_ends(a2, a1) tl.init() counter1 = counter2 = 0 fidelity = 0.8 for i in range(1000): kept_memo1 = Memory("a1.kept", tl, fidelity=fidelity, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON) kept_memo2 = Memory("a2.kept", tl, fidelity, 0, 1, 1, HALF_MICRON) meas_memo1 = Memory("a1.meas", tl, fidelity, 0, 1, 1, HALF_MICRON) meas_memo2 = Memory("a2.meas", tl, fidelity, 0, 1, 1, HALF_MICRON) kept_memo1.entangled_memory["node_id"] = "a2" kept_memo1.entangled_memory["memo_id"] = "a2.kept" kept_memo1.fidelity = fidelity kept_memo2.entangled_memory["node_id"] = "a1" kept_memo2.entangled_memory["memo_id"] = "a1.kept" kept_memo2.fidelity = fidelity meas_memo1.entangled_memory["node_id"] = "a2" meas_memo1.entangled_memory["memo_id"] = "a2.meas" meas_memo1.fidelity = fidelity meas_memo2.entangled_memory["node_id"] = "a1" meas_memo2.entangled_memory["memo_id"] = "a1.meas" meas_memo2.fidelity = fidelity pair1 = np.random.choice(range(4), 1, p=[fidelity, (1 - fidelity) / 3, (1 - fidelity) / 3, (1 - fidelity) / 3]) pair2 = np.random.choice(range(4), 1, p=[fidelity, (1 - fidelity) / 3, (1 - fidelity) / 3, (1 - fidelity) / 3]) tl.quantum_manager.set([kept_memo1.qstate_key, kept_memo2.qstate_key], BELL_STATES[pair1[0]]) tl.quantum_manager.set([meas_memo1.qstate_key, meas_memo2.qstate_key], BELL_STATES[pair2[0]]) ep1 = BBPSSW(a1, "a1.ep1.%d" % i, kept_memo1, meas_memo1) ep2 = BBPSSW(a2, "a2.ep2.%d" % i, kept_memo2, meas_memo2) a1.protocols.append(ep1) a2.protocols.append(ep2) ep1.set_others(ep2) ep2.set_others(ep1) ep1.start() ep2.start() if ep1.meas_res == ep2.meas_res: counter1 += 1 else: counter2 += 1 tl.run() assert abs(counter1 / (counter1 + counter2) - BBPSSW.success_probability(fidelity)) < 0.1
def test_QuantumChannel_transmit(): from sequence.components.photon import Photon random.seed(1) class FakeNode(Node): def __init__(self, name, tl): Node.__init__(self, name, tl) self.log = [] def receive_qubit(self, src, photon): self.log.append((src, self.timeline.now(), photon.name)) tl = Timeline() qc = QuantumChannel("qc", tl, attenuation=0.0002, distance=1e4) sender = FakeNode("sender", tl) receiver = FakeNode("receiver", tl) qc.set_ends(sender, receiver) tl.init() for i in range(1000): photon = Photon(str(i)) qc.transmit(photon, sender) tl.time = tl.time + 1 for i in range(1000): photon = Photon(str(i)) qc.transmit(photon, receiver) tl.time = tl.time + 1 assert len(sender.log) == len(receiver.log) == 0 tl.run() expect_rate = 1 - qc.loss assert abs(len(sender.log) / 1000 - expect_rate) < 0.1 assert abs(len(receiver.log) / 1000 - expect_rate) < 0.1
def create_intf(quantum_state): class Receiver(): def __init__(self, name, timeline): self.name = name self.timeline = timeline self.log = [] def get(self): self.log.append(self.timeline.now()) tl = Timeline() intfm = Interferometer("interferometer", tl, time_bin["bin_separation"]) d0 = Receiver("d0", tl) d1 = Receiver("d1", tl) intfm.set_receiver(0, d0) intfm.set_receiver(1, d1) tl.init() for i in range(NUM_TRIALS): tl.time = i * 1e6 photon = Photon(str(i), quantum_state=quantum_state) intfm.get(photon) tl.time = 0 tl.run() return intfm.receivers[0].log, intfm.receivers[1].log
def test_init(): tl = Timeline() tl.seed(0) detectors = [{"dark_count": 1}] * 2 bsm = make_bsm("bsm", tl, encoding_type="time_bin", detectors=detectors) tl.init() assert len(tl.events) == len(detectors) * 2
def test_init(): tl = Timeline() dummys = [Dummy(str(i), tl) for i in range(100)] for d in dummys: assert d.flag is False tl.init() for d in dummys: assert d.flag is True
def test_BBPSSW2(): tl = Timeline() a1 = FakeNode("a1", tl) a2 = FakeNode("a2", tl) cc = ClassicalChannel("cc", tl, 0, 1e5) cc.delay = 1e9 cc.set_ends(a1, a2) tl.init() counter1 = counter2 = 0 fidelity = 0.8 for i in range(1000): kept_memo1 = Memory("a1.kept", tl, fidelity=fidelity, frequency=0, efficiency=1, coherence_time=1, wavelength=500) kept_memo2 = Memory("a2.kept", tl, fidelity, 0, 1, 1, 500) meas_memo1 = Memory("a1.meas", tl, fidelity, 0, 1, 1, 500) meas_memo2 = Memory("a2.meas", tl, fidelity, 0, 1, 1, 500) kept_memo1.entangled_memory["node_id"] = "a2" kept_memo1.entangled_memory["memo_id"] = "a2.kept" kept_memo1.fidelity = fidelity kept_memo2.entangled_memory["node_id"] = "a1" kept_memo2.entangled_memory["memo_id"] = "a1.kept" kept_memo2.fidelity = fidelity meas_memo1.entangled_memory["node_id"] = "a2" meas_memo1.entangled_memory["memo_id"] = "a2.meas" meas_memo1.fidelity = fidelity meas_memo2.entangled_memory["node_id"] = "a1" meas_memo2.entangled_memory["memo_id"] = "a1.meas" meas_memo2.fidelity = fidelity ep1 = BBPSSW(a1, "a1.ep1.%d" % i, kept_memo1, meas_memo1) ep2 = BBPSSW(a2, "a2.ep2.%d" % i, kept_memo2, meas_memo2) a1.protocols.append(ep1) a2.protocols.append(ep2) ep1.set_others(ep2) ep2.set_others(ep1) ep1.start() ep2.start() assert ep1.is_success == ep2.is_success if ep1.is_success: counter1 += 1 else: counter2 += 1 tl.run() assert abs(counter1 / (counter1 + counter2) - BBPSSW.success_probability(fidelity)) < 0.1
def create_scenario(state1, state2, seed): tl = Timeline() tl.seed(seed) a1 = FakeNode("a1", tl) a2 = FakeNode("a2", tl) a3 = FakeNode("a3", tl) cc0 = ClassicalChannel("a2-a1", tl, 0, 1e5) cc1 = ClassicalChannel("a2-a3", tl, 0, 1e5) cc0.set_ends(a2, a1) cc1.set_ends(a2, a3) tl.init() memo1 = Memory("a1.0", timeline=tl, fidelity=0.9, frequency=0, efficiency=1, coherence_time=1, wavelength=500) memo2 = Memory("a2.0", tl, 0.9, 0, 1, 1, 500) memo3 = Memory("a2.1", tl, 0.9, 0, 1, 1, 500) memo4 = Memory("a3.0", tl, 0.9, 0, 1, 1, 500) memo1.fidelity = memo2.fidelity = memo3.fidelity = memo4.fidelity = 1 memo1.entangled_memory = {'node_id': 'a2', 'memo_id': memo2.name} memo2.entangled_memory = {'node_id': 'a1', 'memo_id': memo1.name} memo3.entangled_memory = {'node_id': 'a3', 'memo_id': memo4.name} memo4.entangled_memory = {'node_id': 'a2', 'memo_id': memo3.name} tl.quantum_manager.set([memo1.qstate_key, memo2.qstate_key], state1) tl.quantum_manager.set([memo3.qstate_key, memo4.qstate_key], state2) es1 = EntanglementSwappingB(a1, "a1.ESb0", memo1) a1.protocols.append(es1) es2 = EntanglementSwappingA(a2, "a2.ESa0", memo2, memo3) a2.protocols.append(es2) es3 = EntanglementSwappingB(a3, "a3.ESb1", memo4) a3.protocols.append(es3) es1.set_others(es2) es3.set_others(es2) es2.set_others(es1) es2.set_others(es3) es2.start() tl.run() ket1, ket2, ket3, ket4 = map(tl.quantum_manager.get, [memo1.qstate_key, memo2.qstate_key, memo3.qstate_key, memo4.qstate_key]) assert id(ket1) == id(ket4) assert id(ket2) != id(ket3) assert len(ket1.keys) == 2 and memo1.qstate_key in ket1.keys and memo4.qstate_key in ket1.keys assert len(ket2.keys) == 1 assert memo2.entangled_memory == memo3.entangled_memory == {'node_id': None, 'memo_id': None} assert memo1.entangled_memory["node_id"] == "a3" and memo4.entangled_memory["node_id"] == "a1" assert a1.resource_manager.log[-1] == (memo1, "ENTANGLED") assert a3.resource_manager.log[-1] == (memo4, "ENTANGLED") return ket1, ket2, ket3, ket4, a3
def test_MemoryWithRandomCoherenceTime__schedule_expiration(): NUM_TRIALS = 200 coherence_period_avg = 1 coherence_period_stdev = 0.15 tl = Timeline() mem = MemoryWithRandomCoherenceTime( "mem", tl, fidelity=1, frequency=0, efficiency=1, coherence_time=coherence_period_avg, coherence_time_stdev=coherence_period_stdev, wavelength=500) parent = DumbParent(mem) times_of_expiration_calculated = [0] np.random.seed(2) for i in range(NUM_TRIALS): times_of_expiration_calculated.append( times_of_expiration_calculated[-1] + int(mem.coherence_time_distribution() * 1e12)) times_of_expiration_calculated.pop(0) np.random.seed(2) process = Process(mem, "update_state", [[complex(math.sqrt(1 / 2)), complex(math.sqrt(1 / 2))]]) for i in range(NUM_TRIALS): event = Event(tl.now(), process) tl.schedule(event) tl.init() tl.run() assert times_of_expiration_calculated[i] == tl.now() period_sum = times_of_expiration_calculated[0] period_squared_sum = times_of_expiration_calculated[0]**2 for i in range(1, len(times_of_expiration_calculated)): period = times_of_expiration_calculated[ i] - times_of_expiration_calculated[i - 1] period_sum += period period_squared_sum += period * period avg_simulated = period_sum / NUM_TRIALS * 1e-12 stdev_simulated = np.sqrt( (period_squared_sum - period_sum * period_sum * 1.0 / NUM_TRIALS) / NUM_TRIALS) * 1e-12 #check that values in series are different assert stdev_simulated > 0.0 #probability of error below is less then 0.3% assert abs(avg_simulated - coherence_period_avg ) < 3 * coherence_period_stdev / np.sqrt(NUM_TRIALS)
def test_remove_event(): tl = Timeline() dummy = Dummy('1', tl) event = Event(1, Process(dummy, 'op', [])) d2 = Dummy('2', tl) event2 = Event(1, Process(d2, 'op', [])) tl.schedule(event) tl.schedule(event2) tl.init() assert dummy.counter == 0 and d2.counter == 0 tl.remove_event(event) tl.run() assert dummy.counter == 0 and d2.counter == 1
def test_expire(): tl = Timeline() node = FakeNode("node", tl) tl.init() for info in node.resource_manager.memory_manager: info.to_occupied() rule = Rule(0, None, None) for i in range(6): node.memory_array[i].detach(node.memory_array) p1 = FakeProtocol("waiting_protocol", [node.memory_array[0]]) node.memory_array[0].attach(p1) p2 = FakeProtocol("pending_protocol", [node.memory_array[1]]) node.memory_array[1].attach(p2) p3 = FakeProtocol("running_protocol", [node.memory_array[2]]) node.memory_array[2].attach(p3) p4 = FakeProtocol("other_waiting_protocol", [node.memory_array[3]]) node.memory_array[3].attach(p4) p5 = FakeProtocol("other_pending_protocol", [node.memory_array[4]]) node.memory_array[4].attach(p5) p6 = FakeProtocol("other_running_protocol", [node.memory_array[5]]) node.memory_array[5].attach(p6) for p in [p1, p2, p3]: p.rule = rule rule.protocols.append(p) node.resource_manager.rule_manager.load(rule) for p in [p3, p6]: node.protocols.append(p) for p in [p2, p5]: node.resource_manager.pending_protocols.append(p) for p in [p1, p4]: node.resource_manager.waiting_protocols.append(p) for i in range(6): assert node.resource_manager.memory_manager[i].state == "OCCUPIED" node.resource_manager.expire(rule) assert p1 not in node.resource_manager.waiting_protocols and p4 in node.resource_manager.waiting_protocols assert p2 not in node.resource_manager.pending_protocols assert p5 in node.resource_manager.pending_protocols assert p3 not in node.protocols and p6 in node.protocols for i in range(3): assert node.resource_manager.memory_manager[i].state == "RAW" for i in range(3, 6): assert node.resource_manager.memory_manager[i].state == "OCCUPIED" for i, memory in enumerate(node.memory_array): if i < 3: assert len(memory._observers) == 1 and isinstance( memory._observers.pop(), MemoryArray) elif i < 6: assert len(memory._observers) == 1 and isinstance( memory._observers.pop(), FakeProtocol)
def test_update_event_time(): tl = Timeline() d1 = Dummy('1', tl) event1 = Event(10, Process(d1, 'click', [])) d2 = Dummy('2', tl) event2 = Event(10, Process(d2, 'click', [])) tl.schedule(event1) tl.schedule(event2) tl.init() assert d1.click_time is None and d2.click_time is None tl.update_event_time(event2, 20) tl.run() assert d1.click_time == 10 and d2.click_time == 20
def test_cascade_run(): KEYSIZE = 512 KEYNUM = 10 tl = Timeline(1e11) alice = QKDNode("alice", tl) bob = QKDNode("bob", tl) pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0]) pair_cascade_protocols(alice.protocol_stack[1], bob.protocol_stack[1]) qc0 = QuantumChannel("qc0", tl, distance=1e3, attenuation=2e-5, polarization_fidelity=0.97) qc1 = QuantumChannel("qc1", tl, distance=1e3, attenuation=2e-5, polarization_fidelity=0.97) qc0.set_ends(alice, bob) qc1.set_ends(bob, alice) cc0 = ClassicalChannel("cc0", tl, distance=1e3) cc1 = ClassicalChannel("cc1", tl, distance=1e3) cc0.set_ends(alice, bob) cc1.set_ends(bob, alice) # Parent pa = Parent(alice, KEYSIZE, KEYNUM) pb = Parent(bob, KEYSIZE, KEYNUM) alice.protocol_stack[1].upper_protocols.append(pa) pa.lower_protocols.append(alice.protocol_stack[1]) bob.protocol_stack[1].upper_protocols.append(pb) pb.lower_protocols.append(bob.protocol_stack[1]) process = Process(pa, "push", []) event = Event(0, process) tl.schedule(event) tl.init() tl.run() assert pa.counter == pb.counter == KEYNUM for k1, k2 in zip(pa.keys, pb.keys): assert k1 == k2 assert k1 < 2**KEYSIZE # check that key is not too large assert alice.protocol_stack[1].error_bit_rate == 0
def test_Node_send_message(): class FakeNode(Node): def __init__(self, name, tl): Node.__init__(self, name, tl) self.log = [] def receive_message(self, src, msg): self.log.append((self.timeline.now(), src, msg)) tl = Timeline() node1 = FakeNode("node1", tl) node2 = FakeNode("node2", tl) cc0 = ClassicalChannel("cc0", tl, 1e3) cc1 = ClassicalChannel("cc1", tl, 1e3) cc0.set_ends(node1, node2) cc1.set_ends(node2, node1) for i in range(10): node1.send_message("node2", str(i)) tl.time += 1 for i in range(10): node2.send_message("node1", str(i)) tl.time += 1 assert len(node1.log) == len(node2.log) == 0 tl.init() tl.run() expect_res = [(5000010, 'node2', '0'), (5000011, 'node2', '1'), (5000012, 'node2', '2'), (5000013, 'node2', '3'), (5000014, 'node2', '4'), (5000015, 'node2', '5'), (5000016, 'node2', '6'), (5000017, 'node2', '7'), (5000018, 'node2', '8'), (5000019, 'node2', '9')] for actual, expect in zip(node1.log, expect_res): assert actual == expect expect_res = [(5000000, 'node1', '0'), (5000001, 'node1', '1'), (5000002, 'node1', '2'), (5000003, 'node1', '3'), (5000004, 'node1', '4'), (5000005, 'node1', '5'), (5000006, 'node1', '6'), (5000007, 'node1', '7'), (5000008, 'node1', '8'), (5000009, 'node1', '9')] for actual, expect in zip(node2.log, expect_res): assert actual == expect
def test_log(): open(filename, 'w').close() assert file_len(filename) == 0 tl = Timeline() de = DumbEntity() lg.set_logger(__name__, tl, filename) lg.set_logger_level("DEBUG") lg.track_module(__name__) tl.init() de.log() # TODO: fix (should be 1) assert file_len(filename) == 2
def create_scenario(state1, state2, seed): tl = Timeline() tl.seed(seed) a1 = FakeNode("a1", tl) a2 = FakeNode("a2", tl) cc0 = ClassicalChannel("cc0", tl, 0, 1e5) cc1 = ClassicalChannel("cc1", tl, 0, 1e5) cc0.delay = ONE_MILLISECOND cc1.delay = ONE_MILLISECOND cc0.set_ends(a1, a2) cc1.set_ends(a2, a1) kept1 = Memory('kept1', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON) kept2 = Memory('kept2', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON) meas1 = Memory('mea1', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON) meas2 = Memory('mea2', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON) tl.init() tl.quantum_manager.set([kept1.qstate_key, kept2.qstate_key], state1) tl.quantum_manager.set([meas1.qstate_key, meas2.qstate_key], state2) kept1.entangled_memory = {'node_id': 'a2', 'memo_id': 'kept2'} kept2.entangled_memory = {'node_id': 'a1', 'memo_id': 'kept1'} meas1.entangled_memory = {'node_id': 'a2', 'memo_id': 'meas2'} meas2.entangled_memory = {'node_id': 'a1', 'memo_id': 'meas1'} kept1.fidelity = kept2.fidelity = meas1.fidelity = meas2.fidelity = 1 ep1 = BBPSSW(a1, "a1.ep1", kept1, meas1) ep2 = BBPSSW(a2, "a2.ep2", kept2, meas2) a1.protocols.append(ep1) a2.protocols.append(ep2) ep1.set_others(ep2) ep2.set_others(ep1) ep1.start() ep2.start() tl.run() assert meas1.entangled_memory == meas2.entangled_memory == {'node_id': None, 'memo_id': None} return tl, kept1, kept2, meas1, meas2, ep1, ep2
def test_Node_send_qubit(): from sequence.components.photon import Photon from numpy import random random.seed(0) class FakeNode(Node): def __init__(self, name, tl): Node.__init__(self, name, tl) self.log = [] def receive_qubit(self, src, qubit): self.log.append((self.timeline.now(), src, qubit.name)) tl = Timeline() node1 = FakeNode("node1", tl) node2 = FakeNode("node2", tl) qc0 = QuantumChannel("qc0", tl, 2e-4, 2e4) qc1 = QuantumChannel("qc1", tl, 2e-4, 2e4) qc0.set_ends(node1, node2) qc1.set_ends(node2, node1) tl.init() for i in range(1000): photon = Photon(str(i)) node1.send_qubit("node2", photon) tl.time += 1 for i in range(1000): photon = Photon(str(i)) node2.send_qubit("node1", photon) tl.time += 1 assert len(node1.log) == len(node2.log) == 0 tl.run() expect_rate_0 = 1 - qc0.loss expect_rate_1 = 1 - qc1.loss assert abs(len(node1.log) / 1000 - expect_rate_1) < 0.1 assert abs(len(node2.log) / 1000 - expect_rate_0) < 0.1
def test_light_source(): class Receiver(Node): def __init__(self, name, tl): Node.__init__(self, name, tl) self.log = [] def receive_qubit(self, src: str, qubit) -> None: self.log.append((self.timeline.now(), src, qubit)) tl = Timeline() FREQ, MEAN = 1e8, 0.1 ls = LightSource("ls", tl, frequency=FREQ, mean_photon_num=MEAN) sender = FakeNode("sender", tl, ls) assert sender.lightsource.frequency == FREQ and sender.lightsource.mean_photon_num == MEAN receiver = Receiver("receiver", tl) qc = QuantumChannel("qc", tl, distance=1e5, attenuation=0) qc.set_ends(sender, receiver) state_list = [] STATE_LEN = 1000 for _ in range(STATE_LEN): basis = random.randint(2) bit = random.randint(2) state_list.append(polarization["bases"][basis][bit]) tl.init() ls.emit(state_list, "receiver") tl.run() assert (len(receiver.log) / STATE_LEN) - MEAN < 0.1 for time, src, qubit in receiver.log: index = int(qubit.name) assert state_list[index] == qubit.quantum_state.state assert time == index * (1e12 / FREQ) + qc.delay assert src == "sender"
def test_QSDetectorPolarization_init(): tl = Timeline() tl.seed(1) qsdetector = QSDetectorPolarization("qsd", tl) tl.init()
qc0.set_ends(alice, bob) qc1.set_ends(bob, alice) cc0.set_ends(alice, bob) cc1.set_ends(bob, alice) # BB84 config pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0]) # cascade config pair_cascade_protocols(alice.protocol_stack[1], bob.protocol_stack[1]) process = Process(alice.protocol_stack[1], 'push', [256, math.inf, 12e12]) tl.schedule(Event(0, process)) tl.init() tl.run() print("completed distance {}".format(distance)) # log results bba = alice.protocol_stack[0] cascade_a = alice.protocol_stack[1] dist_list.append(distance) tp_list.append(cascade_a.throughput) key_error_list.append(cascade_a.error_bit_rate) latency_list.append(cascade_a.latency) setup_time_list.append(cascade_a.setup_time) start_time_list.append(cascade_a.start_time) bb84_latency_list.append(bba.latency)
def test_ResourceManager2(): from sequence.kernel.process import Process from sequence.kernel.event import Event from sequence.components.optical_channel import ClassicalChannel, QuantumChannel from sequence.topology.node import BSMNode from sequence.entanglement_management.generation import EntanglementGenerationA class TestNode(Node): def __init__(self, name, tl): Node.__init__(self, name, tl) self.memory_array = MemoryArray(name + ".MemoryArray", tl, num_memories=50) self.memory_array.owner = self self.resource_manager = ResourceManager(self) def receive_message(self, src: str, msg: "Message") -> None: if msg.receiver == "resource_manager": self.resource_manager.received_message(src, msg) else: if msg.receiver is None: matching = [ p for p in self.protocols if type(p) == msg.protocol_type ] for p in matching: p.received_message(src, msg) else: for protocol in self.protocols: if protocol.name == msg.receiver: protocol.received_message(src, msg) break def get_idle_memory(self, info): pass def eg_rule_condition(memory_info, manager): if memory_info.state == "RAW": return [memory_info] else: return [] def eg_rule_action1(memories_info): def eg_req_func(protocols): for protocol in protocols: if isinstance(protocol, EntanglementGenerationA): return protocol memories = [info.memory for info in memories_info] memory = memories[0] protocol = EntanglementGenerationA(None, "EGA." + memory.name, "mid_node", "node2", memory) protocol.primary = True return [protocol, ["node2"], [eg_req_func]] def eg_rule_action2(memories_info): memories = [info.memory for info in memories_info] memory = memories[0] protocol = EntanglementGenerationA(None, "EGA." + memory.name, "mid_node", "node1", memory) return [protocol, [None], [None]] tl = Timeline() node1, node2 = TestNode("node1", tl), TestNode("node2", tl) mid_node = BSMNode("mid_node", tl, [node1.name, node2.name]) mid_node.bsm.detectors[0].efficiency = 1 mid_node.bsm.detectors[1].efficiency = 1 cc0 = ClassicalChannel("cc_n1_n2", tl, 0, 1e3) cc1 = ClassicalChannel("cc_n2_n1", tl, 0, 1e3) cc2 = ClassicalChannel("cc_n1_m", tl, 0, 1e3) cc3 = ClassicalChannel("cc_m_n1", tl, 0, 1e3) cc4 = ClassicalChannel("cc_n2_m", tl, 0, 1e3) cc5 = ClassicalChannel("cc_m_n2", tl, 0, 1e3) cc0.set_ends(node1, node2) cc1.set_ends(node2, node1) cc2.set_ends(node1, mid_node) cc3.set_ends(mid_node, node1) cc4.set_ends(node2, mid_node) cc5.set_ends(mid_node, node2) qc0 = QuantumChannel("qc_n1_m", tl, 0, 1e3, frequency=8e7) qc1 = QuantumChannel("qc_n2_m", tl, 0, 1e3, frequency=8e7) qc0.set_ends(node1, mid_node) qc1.set_ends(node2, mid_node) tl.init() rule1 = Rule(10, eg_rule_action1, eg_rule_condition) node1.resource_manager.load(rule1) rule2 = Rule(10, eg_rule_action2, eg_rule_condition) node2.resource_manager.load(rule2) process = Process(node1.resource_manager, "expire", [rule1]) event = Event(10, process) tl.schedule(event) process = Process(node2.resource_manager, "expire", [rule2]) event = Event(10, process) tl.schedule(event) tl.run() # for info in node1.resource_manager.memory_manager: # print(info.memory.name, info.state, info.remote_memo) # # for info in node2.resource_manager.memory_manager: # print(info.memory.name, info.state, info.remote_memo) for info in node1.resource_manager.memory_manager: assert info.state == "RAW" for info in node2.resource_manager.memory_manager: assert info.state == "RAW" assert len(node1.protocols) == len(node2.protocols) == 0 assert len(node1.resource_manager.pending_protocols) == len( node2.resource_manager.pending_protocols) == 0 assert len(node1.resource_manager.waiting_protocols) == len( node2.resource_manager.waiting_protocols) == 0
def program(config_file, SEED): # Experiment params and config print(config_file, SEED, "start") network_config_file = "%s.json" % config_file runtime = 1e15 seed(SEED) tl = Timeline(runtime) network_topo = Topology("network_topo", tl) network_topo.load_config(network_config_file) # display components # nodes can be interated from Topology.nodes.values() # quantum channels from Topology.qchannels # classical channels from Topology.cchannels # print("Nodes:") # for name, node in network_topo.nodes.items(): # print("\t" + name + ": ", node) # print("Quantum Channels:") # for qc in network_topo.qchannels: # print("\t" + qc.name + ": ", qc) # print("Classical Channels:") # for cc in network_topo.cchannels: # print("\t" + cc.name + ": ", cc, "\tdelay:", cc.delay) # update forwarding table # for name, node in network_topo.nodes.items(): # if isinstance(node, QuantumRouter): # table = network_topo.generate_forwarding_table(name) # # print(name) # for dst in table: # next_node = table[dst] # node.network_manager.protocol_stack[0].add_forwarding_rule(dst, next_node) # # print(" ", dst, next_node) # set memory parameters MEMO_FREQ = 2e5 MEMO_EXPIRE = 1.3 MEMO_EFFICIENCY = 0.75 MEMO_FIDELITY = 0.9909987775181183 for name, node in network_topo.nodes.items(): if isinstance(node, QuantumRouter): node.memory_array.update_memory_params("frequency", MEMO_FREQ) node.memory_array.update_memory_params("coherence_time", MEMO_EXPIRE) node.memory_array.update_memory_params("efficiency", MEMO_EFFICIENCY) node.memory_array.update_memory_params("raw_fidelity", MEMO_FIDELITY) # set detector parameters DETECTOR_EFFICIENCY = 0.8 DETECTOR_COUNT_RATE = 5e7 DETECTOR_RESOLUTION = 100 for name, node in network_topo.nodes.items(): if isinstance(node, BSMNode): node.bsm.update_detectors_params("efficiency", DETECTOR_EFFICIENCY) node.bsm.update_detectors_params("count_rate", DETECTOR_COUNT_RATE) node.bsm.update_detectors_params("time_resolution", DETECTOR_RESOLUTION) # set quantum channel parameters ATTENUATION = 0.0002 QC_FREQ = 5e7 for qc in network_topo.qchannels: qc.attenuation = ATTENUATION qc.frequency = QC_FREQ # set entanglement swapping parameters SWAP_SUCC_PROB = 0.64 SWAP_DEGRADATION = 0.99 for name, node in network_topo.nodes.items(): if isinstance(node, QuantumRouter): node.network_manager.protocol_stack[1].set_swapping_success_rate(SWAP_SUCC_PROB) node.network_manager.protocol_stack[1].set_swapping_degradation(SWAP_DEGRADATION) nodes_name = [] for name, node in network_topo.nodes.items(): if isinstance(node, QuantumRouter): nodes_name.append(name) apps = [] for i, name in enumerate(nodes_name): app_node_name = name others = nodes_name[:] others.remove(app_node_name) app = RandomRequestApp(network_topo.nodes[app_node_name], others, i+SEED) apps.append(app) app.start() tl.init() tl.run() for app in apps: # print(app.node.name) # print(" ", len(app.get_wait_time())) # print(" ", app.get_wait_time()) throughput = app.get_throughput() # print(" ", app.reserves) # print(" ", throughput) initiators = [] responders = [] start_times = [] end_times = [] memory_sizes = [] fidelities = [] wait_times = [] throughputs = [] for node in network_topo.nodes.values(): if isinstance(node, QuantumRouter): initiator = node.name reserves = node.app.reserves _wait_times = node.app.get_wait_time() _throughputs = node.app.get_throughput() min_size = min(len(reserves), len(_wait_times), len(_throughputs)) reserves = reserves[:min_size] _wait_times = _wait_times[:min_size] _throughputs = _throughputs[:min_size] for reservation, wait_time, throughput in zip(reserves, _wait_times, _throughputs): responder, s_t, e_t, size, fidelity = reservation initiators.append(initiator) responders.append(responder) start_times.append(s_t) end_times.append(e_t) memory_sizes.append(size) fidelities.append(fidelity) wait_times.append(wait_time) throughputs.append(throughput) log = {"Initiator": initiators, "Responder": responders, "Start_time": start_times, "End_time": end_times, "Memory_size": memory_sizes, "Fidelity": fidelities, "Wait_time": wait_times, "Throughput": throughputs} log_path = "%s/%s/" % (config_file, SEED) import os if not os.path.exists(log_path): os.makedirs(log_path) df = pd.DataFrame(log) df.to_csv("%srequest.csv"%log_path) node_names = [] start_times = [] end_times = [] memory_sizes = [] for node in network_topo.nodes.values(): if isinstance(node, QuantumRouter): node_name = node.name for reservation in node.network_manager.protocol_stack[1].accepted_reservation: s_t, e_t, size = reservation.start_time, reservation.end_time, reservation.memory_size if reservation.initiator != node.name and reservation.responder != node.name: size *= 2 node_names.append(node_name) start_times.append(s_t) end_times.append(e_t) memory_sizes.append(size) log = {"Node": node_names, "Start_time": start_times, "End_time": end_times, "Memory_size": memory_sizes} df = pd.DataFrame(log) df.to_csv("%smemory_usage.csv" % log_path) print(config_file, SEED, "done")
def test_BBPSSW1(): tl = Timeline() a1 = FakeNode("a1", tl) a2 = FakeNode("a2", tl) cc = ClassicalChannel("cc", tl, 0, 1e5) cc.delay = 1e9 cc.set_ends(a1, a2) tl.init() for i in range(1000): fidelity = numpy.random.uniform(0.5, 1) kept_memo1 = Memory("a1.kept", tl, fidelity=fidelity, frequency=0, efficiency=1, coherence_time=1, wavelength=500) kept_memo2 = Memory("a2.kept", tl, fidelity, 0, 1, 1, 500) meas_memo1 = Memory("a1.meas", tl, fidelity, 0, 1, 1, 500) meas_memo2 = Memory("a2.meas", tl, fidelity, 0, 1, 1, 500) kept_memo1.entangled_memory["node_id"] = "a2" kept_memo1.entangled_memory["memo_id"] = "a2.kept" kept_memo1.fidelity = fidelity kept_memo2.entangled_memory["node_id"] = "a1" kept_memo2.entangled_memory["memo_id"] = "a1.kept" kept_memo2.fidelity = fidelity meas_memo1.entangled_memory["node_id"] = "a2" meas_memo1.entangled_memory["memo_id"] = "a2.meas" meas_memo1.fidelity = fidelity meas_memo2.entangled_memory["node_id"] = "a1" meas_memo2.entangled_memory["memo_id"] = "a1.meas" meas_memo2.fidelity = fidelity ep1 = BBPSSW(a1, "a1.ep1.%d" % i, kept_memo1, meas_memo1) ep2 = BBPSSW(a2, "a2.ep2.%d" % i, kept_memo2, meas_memo2) a1.protocols.append(ep1) a2.protocols.append(ep2) ep1.set_others(ep2) ep2.set_others(ep1) ep1.start() ep2.start() assert ep1.is_success == ep2.is_success tl.run() assert a1.resource_manager.log[-2] == (meas_memo1, "RAW") assert a2.resource_manager.log[-2] == (meas_memo2, "RAW") assert meas_memo1.fidelity == meas_memo2.fidelity == 0 if ep1.is_success: assert kept_memo1.fidelity == kept_memo2.fidelity == BBPSSW.improved_fidelity( fidelity) assert kept_memo1.entangled_memory[ "node_id"] == "a2" and kept_memo2.entangled_memory[ "node_id"] == "a1" assert a1.resource_manager.log[-1] == (kept_memo1, "ENTANGLED") assert a2.resource_manager.log[-1] == (kept_memo2, "ENTANGLED") else: assert kept_memo1.fidelity == kept_memo2.fidelity == 0 assert kept_memo1.entangled_memory[ "node_id"] == kept_memo2.entangled_memory["node_id"] == None assert a1.resource_manager.log[-1] == (kept_memo1, "RAW") assert a2.resource_manager.log[-1] == (kept_memo2, "RAW")
def test_NetworkManager(): tl = Timeline(1e10) n1 = FakeNode("n1", tl, 50) n2 = FakeNode("n2", tl, 50) n3 = FakeNode("n3", tl, 20) m1 = BSMNode("m1", tl, ["n1", "n2"]) m2 = BSMNode("m2", tl, ["n2", "n3"]) cc = ClassicalChannel("cc_n1_n2", tl, 10, delay=1e5) cc.set_ends(n1, n2) cc = ClassicalChannel("cc_n1_m1", tl, 10, delay=1e5) cc.set_ends(n1, m1) cc = ClassicalChannel("cc_n2_m1", tl, 10, delay=1e5) cc.set_ends(n2, m1) cc = ClassicalChannel("cc_n2_n3", tl, 10, delay=1e5) cc.set_ends(n2, n3) cc = ClassicalChannel("cc_n2_m2", tl, 10, delay=1e5) cc.set_ends(n2, m2) cc = ClassicalChannel("cc_n3_m2", tl, 10, delay=1e5) cc.set_ends(n3, m2) qc = QuantumChannel("qc_n1_m1", tl, 0, 10) qc.set_ends(n1, m1) qc = QuantumChannel("qc_n2_m1", tl, 0, 10) qc.set_ends(n2, m1) qc = QuantumChannel("qc_n2_m2", tl, 0, 10) qc.set_ends(n2, m2) qc = QuantumChannel("qc_n3_m2", tl, 0, 10) qc.set_ends(n3, m2) n1.network_manager.protocol_stack[0].add_forwarding_rule("n2", "n2") n1.network_manager.protocol_stack[0].add_forwarding_rule("n3", "n2") n2.network_manager.protocol_stack[0].add_forwarding_rule("n1", "n1") n2.network_manager.protocol_stack[0].add_forwarding_rule("n3", "n3") n3.network_manager.protocol_stack[0].add_forwarding_rule("n1", "n2") n3.network_manager.protocol_stack[0].add_forwarding_rule("n2", "n2") tl.init() # approved request n1.network_manager.request("n3", 1e12, 2e12, 20, 0.9) tl.run() assert len(n1.send_log) == len(n1.receive_log) == 1 assert n1.send_log[0][0] == "n2" and n1.receive_log[0][0] == "n2" assert n1.send_log[0][1].payload.payload.msg_type == RSVPMsgType.REQUEST assert n1.receive_log[0][1].payload.payload.msg_type == RSVPMsgType.APPROVE assert len(n2.send_log) == len(n2.receive_log) == 2 assert n2.send_log[0][0] == "n3" and n2.receive_log[0][0] == "n1" assert n2.send_log[1][0] == "n1" and n2.receive_log[1][0] == "n3" assert len(n3.send_log) == len(n3.receive_log) == 1 assert n3.send_log[0][0] == "n2" and n3.receive_log[0][0] == "n2" n1.reset() n2.reset() n3.reset() # rejected request n1.network_manager.request("n3", 3e12, 4e12, 50, 0.9) tl.run() assert len(n1.send_log) == len(n1.receive_log) == 1 assert n1.send_log[0][0] == "n2" and n1.receive_log[0][0] == "n2" assert n1.send_log[0][1].payload.payload.msg_type == RSVPMsgType.REQUEST assert n1.receive_log[0][1].payload.payload.msg_type == RSVPMsgType.REJECT assert len(n2.send_log) == len(n2.receive_log) == 1 assert n2.send_log[0][0] == "n1" and n2.receive_log[0][0] == "n1" n1.reset() n2.reset() n3.reset() n1.network_manager.request("n3", 5e12, 6e12, 25, 0.9) tl.run() assert len(n1.send_log) == len(n1.receive_log) == 1 assert n1.send_log[0][0] == "n2" and n1.receive_log[0][0] == "n2" assert n1.send_log[0][1].payload.payload.msg_type == RSVPMsgType.REQUEST assert n1.receive_log[0][1].payload.payload.msg_type == RSVPMsgType.REJECT assert len(n2.send_log) == len(n2.receive_log) == 2 assert n2.send_log[0][0] == "n3" and n2.receive_log[0][0] == "n1" assert n2.send_log[1][0] == "n1" and n2.receive_log[1][0] == "n3" assert len(n3.send_log) == len(n3.receive_log) == 1 assert n3.send_log[0][0] == "n2" and n3.receive_log[0][0] == "n2"
def test_generation_run(): random.seed(1) NUM_TESTS = 500 tl = Timeline() e0 = FakeNode("e0", tl) m0 = FakeNode("m0", tl) e1 = FakeNode("e1", tl) # add connections qc0 = QuantumChannel("qc_e0m0", tl, 0, 1e3) qc1 = QuantumChannel("qc_e1m0", tl, 0, 1e3) qc0.set_ends(e0, m0) qc1.set_ends(e1, m0) cc0 = ClassicalChannel("cc_e0m0", tl, 1e3, delay=1e12) cc1 = ClassicalChannel("cc_m0e0", tl, 1e3, delay=1e12) cc2 = ClassicalChannel("cc_e1m0", tl, 1e3, delay=1e12) cc3 = ClassicalChannel("cc_m0e1", tl, 1e3, delay=1e12) cc4 = ClassicalChannel("cc_e0e1", tl, 2e3, delay=1e9) cc5 = ClassicalChannel("cc_e1e0", tl, 2e3, delay=1e9) cc0.set_ends(e0, m0) cc1.set_ends(m0, e0) cc2.set_ends(e1, m0) cc3.set_ends(m0, e1) cc4.set_ends(e0, e1) cc5.set_ends(e1, e0) # add hardware e0.memory_array = MemoryArray("e0.memory_array", tl, num_memories=NUM_TESTS) e0.memory_array.owner = e0 e1.memory_array = MemoryArray("e1.memory_array", tl, num_memories=NUM_TESTS) e1.memory_array.owner = e1 detectors = [{"efficiency": 1, "count_rate": 1e11}] * 2 m0.bsm = make_bsm("m0.bsm", tl, encoding_type="single_atom", detectors=detectors) # add middle protocol eg_m0 = EntanglementGenerationB(m0, "eg_m0", others=["e0", "e1"]) m0.bsm.attach(eg_m0) tl.init() protocols_e0 = [] protocols_e1 = [] for i in range(NUM_TESTS): name0 = "eg_e0[{}]".format(i) name1 = "eg_e1[{}]".format(i) protocol0 = EntanglementGenerationA(e0, name0, middle="m0", other="e1", memory=e0.memory_array[i]) e0.protocols.append(protocol0) protocols_e0.append(protocol0) protocol1 = EntanglementGenerationA(e1, name1, middle="m0", other="e0", memory=e1.memory_array[i]) e1.protocols.append(protocol1) protocols_e1.append(protocol1) protocol0.set_others(protocol1) protocol1.set_others(protocol0) process = Process(protocols_e0[i], "start", []) event = Event(i * 1e12, process) tl.schedule(event) process = Process(protocols_e1[i], "start", []) event = Event(i * 1e12, process) tl.schedule(event) tl.run() empty_count = 0 for i in range(NUM_TESTS): if e0.resource_manager.log[i][1] == "RAW": empty_count += 1 else: assert e0.resource_manager.log[i][1] == "ENTANGLED" memory0 = e0.resource_manager.log[i][0] memory1 = e1.resource_manager.log[i][0] assert memory0.fidelity == memory0.raw_fidelity assert memory1.fidelity == memory1.raw_fidelity assert memory0.entangled_memory["node_id"] == e1.name assert memory1.entangled_memory["node_id"] == e0.name ratio = empty_count / NUM_TESTS assert abs(ratio - 0.5) < 0.1
def test_generation_fidelity_ket(): random.seed(0) NUM_TESTS = 1000 FIDELITY = 0.75 tl = Timeline() e0 = FakeNode("e0", tl) m0 = FakeNode("m0", tl) e1 = FakeNode("e1", tl) # add connections qc0 = QuantumChannel("qc_e0m0", tl, 0, 1e3) qc1 = QuantumChannel("qc_e1m0", tl, 0, 1e3) qc0.set_ends(e0, m0) qc1.set_ends(e1, m0) cc0 = ClassicalChannel("cc_e0m0", tl, 1e3, delay=1e12) cc1 = ClassicalChannel("cc_m0e0", tl, 1e3, delay=1e12) cc2 = ClassicalChannel("cc_e1m0", tl, 1e3, delay=1e12) cc3 = ClassicalChannel("cc_m0e1", tl, 1e3, delay=1e12) cc4 = ClassicalChannel("cc_e0e1", tl, 2e3, delay=1e9) cc5 = ClassicalChannel("cc_e1e0", tl, 2e3, delay=1e9) cc0.set_ends(e0, m0) cc1.set_ends(m0, e0) cc2.set_ends(e1, m0) cc3.set_ends(m0, e1) cc4.set_ends(e0, e1) cc5.set_ends(e1, e0) # add hardware e0.memory_array = MemoryArray("e0.memory_array", tl, fidelity=FIDELITY, num_memories=NUM_TESTS) e0.memory_array.owner = e0 e1.memory_array = MemoryArray("e1.memory_array", tl, fidelity=FIDELITY, num_memories=NUM_TESTS) e1.memory_array.owner = e1 detectors = [{"efficiency": 1, "count_rate": 1e11}] * 2 m0.bsm = make_bsm("m0.bsm", tl, encoding_type="single_atom", detectors=detectors) # add middle protocol eg_m0 = EntanglementGenerationB(m0, "eg_m0", others=["e0", "e1"]) m0.bsm.attach(eg_m0) tl.init() protocols_e0 = [] protocols_e1 = [] for i in range(NUM_TESTS): name0 = "eg_e0[{}]".format(i) name1 = "eg_e1[{}]".format(i) protocol0 = EntanglementGenerationA(e0, name0, middle="m0", other="e1", memory=e0.memory_array[i]) e0.protocols.append(protocol0) protocols_e0.append(protocol0) protocol1 = EntanglementGenerationA(e1, name1, middle="m0", other="e0", memory=e1.memory_array[i]) e1.protocols.append(protocol1) protocols_e1.append(protocol1) protocol0.set_others(protocol1) protocol1.set_others(protocol0) process = Process(protocols_e0[i], "start", []) event = Event(i * 1e12, process) tl.schedule(event) process = Process(protocols_e1[i], "start", []) event = Event(i * 1e12, process) tl.schedule(event) tl.run() desired = np.array([ complex(np.sqrt(1 / 2)), complex(0), complex(0), complex(np.sqrt(1 / 2)) ]) correct = 0 total = 0 for mem in e0.memory_array: if mem.fidelity > 0: total += 1 mem_state = tl.quantum_manager.get(mem.qstate_key).state if np.array_equal(desired, mem_state): correct += 1 ratio = correct / total assert abs(ratio - FIDELITY) < 0.1
def test_QuantumChannel_init(): tl = Timeline() qc = QuantumChannel("qc", tl, attenuation=0.0002, distance=1e4) tl.init() assert qc.loss - 0.3690426555 > 1e-11 and qc.delay == 50000000