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_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
from sequence.kernel.process import Process
class Store(object):
def __init__(self, tl: Timeline):
self.opening = False
self.timeline = tl
def open(self) -> None:
self.opening = True
process = Process(self, 'close', [])
event = Event(self.timeline.now() + 12, process)
self.timeline.schedule(event)
def close(self) -> None:
self.opening = False
process = Process(self, 'open', [])
event = Event(self.timeline.now() + 12, process)
self.timeline.schedule(event)
tl = Timeline(60)
store = Store(tl)
print(tl.now())
process = Process(store, 'open', [])
event = Event(7, process)
tl.schedule(event)
tl.run()
print(store.opening)
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)