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 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_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_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_single_atom_get():
class PhotonSendWrapper():
def __init__(self, mem1, mem2, bsm):
self.bsm = bsm
mem1.owner = self
mem2.owner = self
def send_qubit(self, dst, photon):
self.bsm.get(photon)
tl = Timeline()
tl.seed(0)
detectors = [{"efficiency": 1}] * 2
bsm = make_bsm("bsm", tl, encoding_type="single_atom", detectors=detectors)
parent = Parent()
bsm.attach(parent)
mem_1 = Memory("mem_1",
tl,
fidelity=1,
frequency=0,
efficiency=1,
coherence_time=1,
wavelength=500)
mem_2 = Memory("mem_2",
tl,
fidelity=1,
frequency=0,
efficiency=1,
coherence_time=1,
wavelength=500)
pw = PhotonSendWrapper(mem_1, mem_2, bsm)
# initially opposite states
tl.time = 0
mem_1.update_state([complex(1), complex(0)])
mem_2.update_state([complex(0), complex(1)])
mem_1.excite() # send w/o destination as have direct_receiver set
mem_2.excite()
assert len(parent.results) == 1
# flip state and resend
tl.time = 1e6
circ = Circuit(1)
circ.x(0)
tl.quantum_manager.run_circuit(circ, [mem_1.qstate_key])
tl.quantum_manager.run_circuit(circ, [mem_2.qstate_key])
mem_1.excite()
mem_2.excite()
assert len(parent.results) == 2
# check that we've entangled
assert len(tl.quantum_manager.get(mem_1.qstate_key).state) == 4
assert tl.quantum_manager.get(mem_1.qstate_key) is tl.quantum_manager.get(
mem_2.qstate_key)
def test_polarization_get():
tl = Timeline()
tl.seed(0)
detectors = [{"efficiency": 1}] * 4
bsm = make_bsm("bsm",
tl,
encoding_type="polarization",
detectors=detectors)
parent = Parent()
bsm.attach(parent)
# get 2 photons in orthogonal states (map to Psi+)
p1 = Photon("p1", location=1, quantum_state=(complex(1), complex(0)))
p2 = Photon("p2", location=2, quantum_state=(complex(0), complex(1)))
bsm.get(p1)
bsm.get(p2)
assert len(parent.results) == 1
# get 2 photons in same state (map to Phi+ / can't measure)
tl.time = 1e6
p3 = Photon("p3", location=1, quantum_state=(complex(1), complex(0)))
p4 = Photon("p4", location=2, quantum_state=(complex(1), complex(0)))
bsm.get(p3)
bsm.get(p4)
assert len(parent.results) == 1
def test_base_get():
tl = Timeline()
tl.seed(0)
photon1 = Photon("", location=1)
photon2 = Photon("", location=2)
photon3 = Photon("", location=3)
photon1_2 = Photon("", location=1)
detectors = [{}] * 2
bsm = make_bsm("bsm", tl, encoding_type="time_bin", detectors=detectors)
bsm.get(photon1)
assert len(bsm.photons) == 1
# same location
bsm.get(photon1_2)
assert len(bsm.photons) == 1
# different location
bsm.get(photon2)
assert len(bsm.photons) == 2
# later time
tl.time = 1
bsm.get(photon3)
assert len(bsm.photons) == 1
def test_QuantumChannel_schedule_transmit():
tl = Timeline()
qc = QuantumChannel("qc", tl, attenuation=0, distance=1e3, frequency=1e12)
# send at time 1 with low min time
tl.time = 0
time = qc.schedule_transmit(0)
assert time == 0
# high min time
time = qc.schedule_transmit(2)
assert time == 2
# another with low
time = qc.schedule_transmit(0)
assert time == 1
# new time
tl.time = 2
time = qc.schedule_transmit(0)
assert time == 3
def test_RandomRequestApp_update_last_rsvp_metrics():
tl = Timeline()
node = QuantumRouter("n1", tl)
app = RandomRequestApp(node, [], 0)
app._update_last_rsvp_metrics()
assert len(app.get_throughput()) == 0
app.cur_reserve = ["n2", 1e13, 2e13, 5, 0.9]
app.reserves.append(app.cur_reserve)
app.memory_counter = 10
tl.time = 20
assert app.request_time == 0
app._update_last_rsvp_metrics()
assert len(app.get_throughput()) == 1 and app.get_throughput()[0] == 1
assert app.cur_reserve == []
assert app.request_time == 20
assert app.memory_counter == 0
def test_QSDetectorPolarization():
tl = Timeline()
tl.seed(1)
qsdetector = QSDetectorPolarization("qsd", tl)
qsdetector.update_detector_params(0, "efficiency", 1)
qsdetector.update_detector_params(1, "efficiency", 1)
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), quantum_state=polarization["bases"][basis][bit])
qsdetector.get(photon)
trigger_times = qsdetector.get_photon_times()
length = len(trigger_times[0] + trigger_times[1])
assert length == 1000
assert qsdetector.get_photon_times() == [[], []]
tl.run() print(tl.time, store.opening) # close store at 19:00 close_proc = Process(store, 'close', []) close_event = Event(19, close_proc) tl.schedule(close_event) tl.run() print(tl.time, store.opening) # what if we schedule two events before run simulation tl.time = 0 tl.schedule(open_event) tl.schedule(close_event) tl.run() print(tl.time, store.opening) # what if we swap the order of scheduling two events tl.time = 0 tl.schedule(open_event) tl.schedule(close_event) tl.run() print(tl.time, store.opening)
def test_BeamSplitter_get():
tl = Timeline()
bs = BeamSplitter("bs", tl)
receiver0 = Receiver(tl)
bs.set_receiver(0, receiver0)
receiver1 = Receiver(tl)
bs.set_receiver(1, receiver1)
frequency = 8e7
start_time = 0
basis_len = 1000
basis_list = []
# z-basis states, measurement
for i in range(basis_len):
basis_list.append(0)
bs.set_basis_list(basis_list, start_time, frequency)
bits = []
for i in range(basis_len):
time = 1e12 / frequency * i
tl.time = time
bit = random.randint(2)
bits.append(bit)
photon = Photon(str(i), quantum_state=polarization["bases"][0][bit])
bs.get(photon)
for i in range(basis_len):
time = 1e12 / frequency * i
r_i = bits[i]
assert time in bs.receivers[r_i].log
# x-basis states, measurement
receiver0.log = []
receiver1.log = []
basis_list = []
for i in range(basis_len):
basis_list.append(1)
bs.set_basis_list(basis_list, start_time, frequency)
bits2 = []
for i in range(basis_len):
time = 1e12 / frequency * i
tl.time = time
bit = random.randint(2)
bits2.append(bit)
photon = Photon(str(i), quantum_state=polarization["bases"][1][bit])
bs.get(photon)
for i in range(basis_len):
time = 1e12 / frequency * i
r_i = bits2[i]
assert time in bs.receivers[r_i].log
# z-basis states, x-basis measurement
receiver0.log = []
receiver1.log = []
basis_list = []
for i in range(basis_len):
basis_list.append(1)
bs.set_basis_list(basis_list, start_time, frequency)
bits = []
for i in range(basis_len):
time = 1e12 / frequency * i
tl.time = time
bit = random.randint(2)
bits.append(bit)
photon = Photon(str(i), quantum_state=polarization["bases"][0][bit])
bs.get(photon)
print(len(receiver1.log), len(receiver0.log))
true_counter, false_counter = 0, 0
for i in range(basis_len):
time = 1e12 / frequency * i
r_i = bits[i]
if time in bs.receivers[r_i].log:
true_counter += 1
else:
false_counter += 1
assert true_counter / basis_len - 0.5 < 0.1
bsm_node.bsm.update_detectors_params('efficiency', 1)
qc1 = QuantumChannel('qc1', tl, attenuation=0, distance=1000)
qc2 = QuantumChannel('qc2', tl, attenuation=0, distance=1000)
qc1.set_ends(node1, bsm_node)
qc2.set_ends(node2, bsm_node)
nodes = [node1, node2, bsm_node]
for i in range(3):
for j in range(3):
cc= ClassicalChannel('cc_%s_%s'%(nodes[i].name, nodes[j].name), tl, 1000, 1e8)
cc.set_ends(nodes[i], nodes[j])
for i in range(1000):
tl.time = tl.now() + 1e11
node1.create_protocol('bsm_node', 'node2')
node2.create_protocol('bsm_node', 'node1')
pair_protocol(node1.protocols[0], node2.protocols[0])
node1.memory.reset()
node2.memory.reset()
node1.protocols[0].start()
node2.protocols[0].start()
tl.init()
tl.run()
print(node1.resource_manager.ent_counter, ':', node1.resource_manager.raw_counter)