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)