def run(self):
qubitList = []
#receive qubits from A
port = self.node.ports[self.portNameQ1]
qubitList = []
#receive qubits from A
yield self.await_port_input(port)
qubitList.append(port.rx_input().items)
#print("B received qubits:",qubitList)
self.B_checkLoss(qubitList[0])
#put qubits into B memory
for qubit in qubitList:
self.processor.put(qubit)
self.myQG_B_measure = QG_B_measure(basisList=self.basisList,
num_bits=self.num_bits)
self.processor.execute_program(
self.myQG_B_measure,
qubit_mapping=[i for i in range(0, self.num_bits)])
# get meas result
self.processor.set_program_done_callback(self.B_getPGoutput, once=True)
yield self.await_program(processor=self.processor)
# add Loss case
self.loc_measRes = AddLossCase(self.lossList, self.loc_measRes)
self.basisList = AddLossCase(self.lossList, self.basisList)
# add first loss
if self.firstLoss >= 1:
for i in range(self.firstLoss):
self.loc_measRes.insert(0, -1)
self.basisList.insert(0, -1)
# self.B_send_basis()
self.node.ports[self.portNameC1].tx_output(self.basisList)
# wait for A's basisList
port = self.node.ports[self.portNameC2]
yield self.await_port_input(port)
basis_A = port.rx_input().items
#print("B received basis_A:",basis_A)
self.loc_measRes = Compare_basis(self.basisList, basis_A,
self.loc_measRes)
self.key = ''.join(map(str, self.loc_measRes))
#print("B key:",self.key)
self.endTime = ns.sim_time()
def run(self):
self.node.subcomponents['Clock_{}'.format(self.node.name)].start(
) # clock for this particular node to time its source emission
while True:
yield self.await_port_output(
self.node.subcomponents['Clock_{}'.format(
self.node.name)].ports['cout'])
emitted = True if np.random.random_integers(
1, 100
) <= self.probability_emission else False # determine if source should actually emit a qubit this cycle by random sampling [1,100]
if emitted:
self.node.subcomponents['QSource_{}'.format(
self.node.name
)].trigger(
) # manually trigger source when "emitted" is True for this cycle
self.send_signal(Signals.SUCCESS, result=ns.sim_time())
def run_E91_sim(runtimes=1,num_bits=20,fibre_len=10**-9,memNoiseMmodel=None,processorNoiseModel=None
,loss_init=0,loss_len=0,QChV=2.083*10**-4,CChV=2.083*10**-4):
MyE91List_A=[] # local protocol list A
MyE91List_B=[] # local protocol list B
MyKeyRateList=[]
A_originBasisList=[]
B_measureBasisList=[]
for i in range(runtimes):
ns.sim_reset()
# nodes====================================================================
nodeA = Node("Alice", port_names=["portQA_1","portCA_1","portCA_2"])
nodeB = Node("Bob" , port_names=["portQB_1","portCB_1","portCB_2"])
# processors===============================================================
#noise_model=None
Alice_processor=QuantumProcessor("processor_A", num_positions=10**5,
mem_noise_models=memNoiseMmodel, phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,duration=10,q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE, duration=10,q_noise_model=processorNoiseModel, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=10,q_noise_model=processorNoiseModel, parallel=True)])
Bob_processor=QuantumProcessor("processor_B", num_positions=10**5,
mem_noise_models=memNoiseMmodel, phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,duration=10,q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE, duration=10,q_noise_model=processorNoiseModel, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=10,q_noise_model=processorNoiseModel, parallel=True)])
# channels==================================================================
MyQChannel=QuantumChannel("QChannel_A->B",delay=10
,length=fibre_len
,models={"quantum_loss_model":
FibreLossModel(p_loss_init=loss_init,p_loss_length=loss_len, rng=None),
"delay_model": FibreDelayModel(c=QChV)})
nodeA.connect_to(nodeB, MyQChannel,
local_port_name =nodeA.ports["portQA_1"].name,
remote_port_name=nodeB.ports["portQB_1"].name)
MyCChannel = ClassicalChannel("CChannel_B->A",delay=0
,length=fibre_len)
MyCChannel2= ClassicalChannel("CChannel_A->B",delay=0
,length=fibre_len)
nodeB.connect_to(nodeA, MyCChannel,
local_port_name="portCB_1", remote_port_name="portCA_1")
nodeA.connect_to(nodeB, MyCChannel2,
local_port_name="portCA_2", remote_port_name="portCB_2")
startTime=ns.sim_time()
#print("startTime:",startTime)
Alice_protocol = AliceProtocol(nodeA,Alice_processor,num_bits)
Bob_protocol = BobProtocol(nodeB,Bob_processor,num_bits)
Bob_protocol.start()
Alice_protocol.start()
#ns.logger.setLevel(1)
stats = ns.sim_run()
'''
endTime=Bob_protocol.endTime
#print("endTime:",endTime)
MyE91List_A.append(Alice_protocol.key)
MyE91List_B.append(Bob_protocol.key)
#simple key length calibration
s = SequenceMatcher(None, Alice_protocol.key, Bob_protocol.key)# unmatched rate
MyKeyRateList.append((len(Bob_protocol.key)*(1-s.ratio()))*10**9/(endTime-startTime)) #second
'''
MyE91List_A.append(Alice_protocol.key)
MyE91List_B.append(Bob_protocol.key)
A_originBasisList.append(Alice_protocol.basisList)
B_measureBasisList.append(Bob_protocol.basisList)
#return MyE91List_A, MyE91List_B, MyKeyRateList
return MyE91List_A, MyE91List_B, A_originBasisList, B_measureBasisList
def run(self):
qubitList=[]
#receive qubits from A
port = self.node.ports[self.portNameQ1]
qubitList=[]
#receive qubits from A
yield self.await_port_input(port)
qubitList.append(port.rx_input().items)
#print("B received qubits:",qubitList)
#self.B_checkLoss(qubitList[0])
self.lossList=CheckLoss(qubitList[0],2,2*self.num_bits)
#put qubits into B memory
for qubit in qubitList:
self.processor.put(qubit)
# B update measurement basis according to loss
for pos, value in enumerate(self.lossList):
self.basisList[int(value/2-1)]=str('-')
self.myQG_B_measure=QG_B_measure(
basisList=self.basisList,numValidQubits=self.num_bits-len(self.lossList))
self.processor.execute_program(
self.myQG_B_measure,qubit_mapping=[i for i in range(0,self.num_bits)])
# get meas result
self.processor.set_program_done_callback(self.B_getPGoutput,once=True)
self.processor.set_program_fail_callback(ProgramFail,once=True)
yield self.await_program(processor=self.processor)
#padding loc_measRes
#shrink lossList scale to half
self.lossList=[int(i/2) for i in self.lossList]
tmpList=[]
for i in range(self.num_bits):
if i+1 in self.lossList:
tmpList.append(str('-'))
else:
tmpList.append(self.loc_measRes.pop(0))
self.loc_measRes=tmpList
# self.B_send_basis()
self.node.ports[self.portNameC1].tx_output(self.basisList)
# wait for A's basisList
port=self.node.ports[self.portNameC2]
yield self.await_port_input(port)
basis_A=port.rx_input().items
#print("B received basis_A:",basis_A)
self.loc_measRes=Compare_basis(self.basisList,basis_A,self.loc_measRes)
self.key=''.join(map(str, self.loc_measRes))
#print("B key:",self.key)
self.endTime=ns.sim_time()