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_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_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_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_Memory__schedule_expiration(): tl = Timeline() mem = Memory("mem", tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=500) parent = DumbParent(mem) process = Process(mem, "expire", []) event = Event(1e12, process) tl.schedule(event) mem.expiration_event = event mem._schedule_expiration() counter = 0 for event in tl.events: if event.is_invalid(): counter += 1 assert counter == 1
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
for name, param in detector_params[i].items(): bob.update_detector_params(i, name, param) 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)
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
}] bob = QKDNode("bob", tl, encoding=time_bin, stack_size=1) for i in range(len(detector_params)): for name, param in detector_params[i].items(): bob.update_detector_params(i, name, param) qc.set_ends(alice, bob) cc.set_ends(alice, bob) # BB84 pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0]) process = Process(alice.protocol_stack[0], "push", [256, 10, math.inf]) event = Event(0, process) tl.schedule(event) tl.init() tl.run() bba = alice.protocol_stack[0] error = statistics.mean(bba.error_rates) throughput = statistics.mean(bba.throughputs) latency = bba.latency print("{} km:".format(distance)) print("\tbb84 error:\t\t\t{}".format(error)) print("\tbb84 throughput:\t{}".format(throughput)) errors.append(error)
self.timeline = tl def open(self) -> None: self.opening = True def close(self) -> None: self.opening = False tl = Timeline() store = Store(tl) # open store at 7:00 open_proc = Process(store, 'open', []) open_event = Event(7, open_proc) tl.schedule(open_event) 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
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_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_run(): random.seed(0) NUM_TESTS = 200 tl = Timeline() e0 = FakeNode("e0", tl) m0 = FakeNode("m0", tl) e1 = FakeNode("e1", tl) # add connections cc = ClassicalChannel("cc_e0m0", tl, 1e3) cc.set_ends(e0, m0) cc = ClassicalChannel("cc_e1m0", tl, 1e3) cc.set_ends(e1, m0) cc = ClassicalChannel("cc_e0e1", tl, 1e3) cc.set_ends(e0, e1) qc = QuantumChannel("qc_e0m0", tl, 0, 1e3) qc.set_ends(e0, m0) qc = QuantumChannel("qc_e1m0", tl, 0, 1e3) qc.set_ends(e1, m0) # 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}] * 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 ratio = empty_count / NUM_TESTS assert abs(ratio - 0.5) < 0.1
tl = Timeline(runtime) # nodes and hardware node1 = SenderNode("node1", tl) node2 = ReceiverNode("node2", tl) qc = QuantumChannel("qc", tl, attenuation=0, distance=1e3) qc.set_ends(node1, node2) # counter counter = Counter() node2.detector.attach(counter) # schedule events time_bin = int(1e12 / FREQUENCY) process1 = Process(node1.memory, "update_state", [[complex(math.sqrt(1 / 2)), complex(math.sqrt(1 / 2))]]) process2 = Process(node1.memory, "excite", ["node2"]) for i in range(NUM_TRIALS): event1 = Event(i * time_bin, process1) event2 = Event(i * time_bin + (time_bin / 2), process2) tl.schedule(event1) tl.schedule(event2) tl.init() tl.run() print("percent measured: {}%".format(100 * counter.count / NUM_TRIALS))