def test_RandomRequestApp_get_reserve_res():
tl = Timeline()
tl.time = 6
node = FakeNode("n1", tl)
app = RandomRequestApp(node, ["n2", "n3"], 0)
app.cur_reserve = ["n3", 10, 20, 5, 0.9]
reservation = Reservation("n1", "n3", 10, 20, 5, 0.9)
for i, card in enumerate(node.network_manager.protocol_stack[1].timecards):
if i < 20:
card.add(reservation)
app.request_time = 5
app.get_reserve_res(reservation, True)
assert app.get_wait_time()[0] == 5
assert len(tl.events) == 41 and tl.events.data[0].time == 10
tl = Timeline()
tl.time = 6
node = FakeNode("n1", tl)
app = RandomRequestApp(node, ["n2", "n3"], 0)
app.cur_reserve = ["n3", 10, 20, 5, 0.9]
reservation = Reservation("n1", "n3", 10, 20, 5, 0.9)
app.request_time = 5
app.get_reserve_res(reservation, False)
tl.run()
assert len(app.get_wait_time()) == 0
assert app.cur_reserve[0] == "n3"
assert app.cur_reserve[1] != 10
assert app.cur_reserve[2] != 20
assert app.cur_reserve[3] != 5
assert app.cur_reserve[4] == 0.9
assert len(node.reserve_log) == 1
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_ClassicalChannel_transmit():
class FakeNode(Node):
def __init__(self, name, tl, **kwargs):
Node.__init__(self, name, tl, **kwargs)
self.msgs = []
def receive_message(self, src: str, msg: str):
self.msgs.append([tl.now(), src, msg])
tl = Timeline()
cc = ClassicalChannel("cc", tl, 1e3)
n1 = FakeNode('n1', tl)
n2 = FakeNode('n2', tl)
cc.set_ends(n1, n2)
args = [['1-1', n1, 5], ['1-2', n1, 5]]
results = [[cc.delay, 'n1', '1-1'], [1 + cc.delay, 'n1', '1-2']]
for arg in args:
cc.transmit(arg[0], arg[1], arg[2])
tl.time += 1
tl.run()
assert len(n1.msgs) == 0 and len(n2.msgs) == 2
for msg, res in zip(n2.msgs, results):
assert msg == res
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 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 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_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 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_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_QSDetectorTimeBin():
tl = Timeline()
tl.seed(1)
qsdetector = QSDetectorTimeBin("qsd", tl)
[qsdetector.update_detector_params(i, "efficiency", 1) for i in range(3)]
frequency = 1e5
start_time = 0
basis_list = [random.randint(2) for _ in range(1000)]
qsdetector.set_basis_list(basis_list, start_time, frequency)
for i in range(1000):
tl.time = i * 1e12 / frequency
basis = basis_list[i]
bit = random.randint(2)
photon = Photon(str(i),
encoding_type=time_bin,
quantum_state=time_bin["bases"][basis][bit])
qsdetector.get(photon)
tl.time = 0
tl.run()
trigger_times = qsdetector.get_photon_times()
length = len(trigger_times[0] + trigger_times[1] + trigger_times[2])
assert abs(length / 1000 - 7 / 8) < 0.1
def test_RandomRequestApp_get_other_reservation():
tl = Timeline()
node = FakeNode("fake", tl)
reservation = Reservation("initiator", "fake", 10, 100, 10, 0.9)
counter = 0
for card in node.network_manager.protocol_stack[1].timecards:
if counter >= 10:
break
card.add(reservation)
counter += 1
app = RandomRequestApp(node, [], 0)
app.get_other_reservation(reservation)
assert len(app.memo_to_reserve) == 0
tl.stop_time = 11
tl.run()
assert len(app.memo_to_reserve) == 10
info = node.resource_manager.memory_manager[0]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "RAW" and info.memory.entangled_memory[
"node_id"] is None
info = node.resource_manager.memory_manager[10]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
info = node.resource_manager.memory_manager[0]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 0.8
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
info = node.resource_manager.memory_manager[1]
info.memory.entangled_memory = {"node_id": "x", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
tl.stop_time = 101
tl.run()
print(app.memo_to_reserve)
assert len(app.memo_to_reserve) == 0
info = node.resource_manager.memory_manager[0]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
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_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_time_bin_get():
tl = Timeline()
tl.seed(0)
detectors = [{"efficiency": 1, "count_rate": 1e9}] * 2
bsm = make_bsm("bsm", tl, encoding_type="time_bin", detectors=detectors)
parent = Parent()
bsm.attach(parent)
detector_list = bsm.detectors
# get 2 photons in orthogonal states (map to Psi+)
p1 = Photon("p1",
encoding_type=time_bin,
location=1,
quantum_state=(complex(1), complex(0)))
p2 = Photon("p2",
encoding_type=time_bin,
location=2,
quantum_state=(complex(0), complex(1)))
process = Process(bsm, "get", [p1])
event = Event(0, process)
tl.schedule(event)
process = Process(bsm, "get", [p2])
event = Event(0, process)
tl.schedule(event)
tl.run()
assert len(parent.results) == 1
# get 2 photons in same state (map to Phi+ / can't measure)
p3 = Photon("p3",
encoding_type=time_bin,
location=1,
quantum_state=(complex(1), complex(0)))
p4 = Photon("p4",
encoding_type=time_bin,
location=2,
quantum_state=(complex(1), complex(0)))
process = Process(bsm, "get", [p3])
event = Event(1e6, process)
tl.schedule(event)
process = Process(bsm, "get", [p4])
event = Event(1e6, process)
tl.schedule(event)
tl.run()
assert len(parent.results) == 1
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_RandomRequestApp_get_memory():
tl = Timeline(1)
node = FakeNode("n1", tl)
app = RandomRequestApp(node, ["n2", "n3"], 0)
app.cur_reserve = ["n2", 0, 100, 2, 0.85]
reservation = Reservation("n1", "n2", 0, 100, 2, 0.85)
counter = 0
for card in node.network_manager.protocol_stack[1].timecards:
card.add(reservation)
counter += 1
if counter > 2:
break
app.get_other_reservation(reservation)
tl.run()
node.memory_array[0].entangled_memory["node_id"] = "n2"
node.memory_array[0].entangled_memory["memo_id"] = "1"
node.memory_array[0].fidelity = 0.9
node.resource_manager.update(None, node.memory_array[0], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[0])
assert node.resource_manager.memory_manager[0].state == "RAW"
assert node.memory_array[0].entangled_memory["node_id"] == None
assert node.memory_array[0].fidelity == 0
node.memory_array[1].entangled_memory["node_id"] = "n3"
node.memory_array[1].entangled_memory["memo_id"] = "1"
node.memory_array[1].fidelity = 0.9
node.resource_manager.update(None, node.memory_array[1], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[1])
assert node.resource_manager.memory_manager[1].state == "ENTANGLED"
node.memory_array[2].entangled_memory["node_id"] = "n2"
node.memory_array[2].entangled_memory["memo_id"] = "1"
node.memory_array[2].fidelity = 0.84
node.resource_manager.update(None, node.memory_array[2], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[2])
assert node.resource_manager.memory_manager[2].state == "ENTANGLED"
node.memory_array[3].entangled_memory["node_id"] = "n2"
node.memory_array[3].entangled_memory["memo_id"] = "1"
node.memory_array[3].fidelity = 0.9
node.resource_manager.update(None, node.memory_array[3], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[3])
assert node.resource_manager.memory_manager[3].state == "ENTANGLED"
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_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 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_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 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
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_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