def concurrently(a: qreg, b: qreg):
with concur:
X90(a)
Y90(b)
with concur:
X90(a)
Y90(b)
def classical_break():
q1 = QRegister("q1")
for ct in range(3):
X(q1)
if ct >= 1:
X90(q1)
break
X90(q1)
Y90(q1)
def classical_continue():
q1 = QRegister("q1")
for ct in range(3):
X(q1)
if ct >= 1:
X90(q1)
continue
X90(q1)
Y90(q1)
def main():
q1 = QubitFactory("1")
q2 = QubitFactory("2")
with concur:
reset(q1)
reset(q2)
with concur:
X90(q1)
X90(q2)
with concur:
MEAS(q1)
MEAS(q2)
def flipflop_seqs(dragParam, maxNumFFs, qubit: qreg):
""" Helper function to create a list of sequences with a specified drag parameter. """
# QGL2 qubits are read only.
# So instead, supply the dragScaling as an explicit kwarg to all pulses
# qubit.pulse_params['dragScaling'] = dragParam
for rep in range(maxNumFFs):
init(qubit)
X90(qubit, dragScaling=dragParam)
# FIXME: Original used [X90] + [X90, X90m]... is this right?
for _ in range(rep):
X90(qubit, dragScaling=dragParam)
X90m(qubit, dragScaling=dragParam)
Y90(qubit, dragScaling=dragParam)
MEAS(qubit)
def flipflop_seqs(dragScaling, maxNumFFs, qubit: qreg):
""" Helper function to create a list of sequences with a specified drag parameter. """
# QGL2 qubits are read only.
# So instead, supply the dragScaling as an explicit kwarg to all pulses
# qubit.pulse_params['dragScaling'] = dragScaling
for rep in range(maxNumFFs):
init(qubit)
X90(qubit, dragScaling=dragScaling)
for _ in range(rep):
X90(qubit, dragScaling=dragScaling)
X90m(qubit, dragScaling=dragScaling)
Y90(qubit, dragScaling=dragScaling)
MEAS(qubit)
def test_loops(a: qbit, b: qbit):
with concur:
while True:
v1 = MEAS(a)
if v1:
break
X90(a, 1.0, 2.0)
X90(a, 1.0, 2.0)
while True:
v2 = MEAS(b)
if v2:
break
Y90(b)
def main():
q1 = QubitFactory('q1')
q2 = QubitFactory('q2')
X90(q1)
Y90(q2)
def EchoCRPhase(controlQ: qreg, targetQ: qreg, phases, riseFall=40e-9, amp=1, length=100e-9, calRepeats=2, canc_amp=0, canc_phase=np.pi/2):
"""
Variable phase CX experiment, with echo pulse sandwiched between two CR opposite-phase pulses.
Parameters
----------
controlQ : logical channel for the control qubit (LogicalChannel)
targetQ : logical channel for the cross-resonance pulse (LogicalChannel)
phases : pulse phases of the CR pulse to sweep over (iterable)
riseFall : rise/fall time of the CR pulse (s)
amp : amplitude of the CR pulse
length : duration of each of the two flat parts of the CR pulse (s)
calRepeats : number of repetitions of readout calibrations for each 2-qubit state
"""
# Original:
# seqs = [[Id(controlQ)] + echoCR(controlQ, targetQ, length=length, phase=ph, riseFall=riseFall) + [X90(targetQ)*Id(controlQ), MEAS(targetQ)*MEAS(controlQ)] \
# for ph in phases]+[[X(controlQ)] + echoCR(controlQ, targetQ, length=length, phase= ph, riseFall = riseFall) + [X90(targetQ)*X(controlQ), MEAS(targetQ)*MEAS(controlQ)] \
# for ph in phases]+create_cal_seqs((targetQ,controlQ), calRepeats, measChans=(targetQ,controlQ))
cNt = QRegister(controlQ, targetQ)
# Sequence 1
for ph in phases:
init(cNt)
Id(controlQ)
echoCR(controlQ, targetQ, length=length, phase=ph,
riseFall=riseFall, canc_amp=canc_amp, canc_phase=canc_phase)
Barrier(cNt)
X90(targetQ)
Id(controlQ)
measConcurrently(cNt)
# Sequence 2
for ph in phases:
init(cNt)
X(controlQ)
echoCR(controlQ, targetQ, length=length, phase=ph,
riseFall=riseFall, canc_amp=canc_amp, canc_phase=canc_phase)
Barrier(cNt)
X90(targetQ)
X(controlQ)
measConcurrently(cNt)
# Then do calRepeats calibration sequences
create_cal_seqs(cNt, calRepeats)
def main():
q1 = QubitFactory('q1')
q2 = QubitFactory('q2')
q3 = QubitFactory('q3')
X90(q1)
Y90(q2)
Utheta(q3)
def runtime_break():
q1 = QRegister("q1")
for ct in range(3):
m = MEAS(q1)
if m:
X90(q1)
# this should produce an error
break
def SingleQubitRB_DiAC(qubit, seqs, compiled=True, purity=False, add_cals=True):
"""Single qubit randomized benchmarking using diatomic Clifford pulses.
Parameters
----------
qubit : logical channel to implement sequence (LogicalChannel)
seqFile : file containing sequence strings
compiled : if True, compile Z90(m)-X90-Z90(m) to Y90(m) pulses
purity : measure <Z>,<X>,<Y> of final state, to measure purity. See J.J.
Wallman et al., New J. Phys. 17, 113020 (2015)
"""
op = [Id, Y90m, X90]
for ct in range(3 if purity else 1):
for seq in seqs:
init(qubit)
for c in seq:
DiAC(qubit, c, compiled)
# append tomography pulse to measure purity
if ct == 0:
op[ct](qubit, length=0)
else:
op[ct](qubit)
# append measurement
MEAS(qubit)
# axis_descriptor = [{
# 'name': 'length',
# 'unit': None,
# 'points': list(map(len, seqs)),
# 'partition': 1
# }]
# Tack on the calibration sequences
if add_cals:
for _ in range(2):
init(qubit)
Id(qubit)
MEAS(qubit)
for _ in range(2):
init(qubit)
X90(qubit)
X90(qubit)
MEAS(qubit)
def CPMG(qubit: qreg, numPulses, pulseSpacing, calRepeats=2):
"""
CPMG pulse train with fixed pulse spacing. Note this pulse spacing is centre to centre,
i.e. it accounts for the pulse width
Parameters
----------
qubit : logical channel to implement sequence (LogicalChannel)
numPulses : number of 180 pulses; should be even (iterable)
pulseSpacing : spacing between the 180's (seconds)
calRepeats : how many times to repeat calibration scalings (default 2)
"""
# Original:
# # First setup the t-180-t block
# CPMGBlock = [Id(qubit, (pulseSpacing-qubit.pulse_params['length'])/2),
# Y(qubit), Id(qubit, (pulseSpacing-qubit.pulse_params['length'])/2)]
# seqs = [[X90(qubit)] + CPMGBlock*rep + [X90(qubit), MEAS(qubit)] for rep in numPulses]
# # Tack on the calibration scalings
# seqs += create_cal_seqs((qubit,), calRepeats)
# fileNames = compile_to_hardware(seqs, 'CPMG/CPMG')
# print(fileNames)
# if showPlot:
# plot_pulse_files(fileNames)
# Create numPulses sequences
for rep in numPulses:
init(qubit)
X90(qubit)
# Repeat the t-180-t block rep times
for _ in range(rep):
pulseCentered(qubit, Id, pulseSpacing)
Y(qubit)
pulseCentered(qubit, Id, pulseSpacing)
X90(qubit)
MEAS(qubit)
# Tack on calibration
create_cal_seqs(qubit, calRepeats)
def spam_seqs(angle, q: qreg, maxSpamBlocks=10):
for rep in range(maxSpamBlocks):
init(q)
Y90(q)
for _ in range(rep):
X(q)
U(q, phase=pi / 2 + angle)
X(q)
U(q, phase=pi / 2 + angle)
X90(q)
MEAS(q)
def spam_seqs(angle, qubit: qreg, maxSpamBlocks=10):
""" Helper function to create a list of sequences increasing SPAM blocks with a given angle. """
#SPAMBlock = [X(qubit), U(qubit, phase=pi/2+angle), X(qubit), U(qubit, phase=pi/2+angle)]
#return [[Y90(qubit)] + SPAMBlock*rep + [X90(qubit)] for rep in range(maxSpamBlocks)]
for rep in range(maxSpamBlocks):
init(qubit)
Y90(qubit)
for _ in range(rep):
X(qubit)
U(qubit, phase=pi / 2 + angle)
X(qubit)
U(qubit, phase=pi / 2 + angle)
X90(qubit)
MEAS(qubit)
def doRamsey(q:qreg, delays, TPPIFreq, calRepeats):
# Create the phases for the TPPI
phases = 2*pi*TPPIFreq*delays
# Create the basic Ramsey sequence
for d,phase in zip(delays, phases):
init(q)
X90(q)
Id(q, length=d)
U90(q, phase=phase)
MEAS(q)
# Tack on calibration
create_cal_seqs(q, calRepeats)
def Ramsey(qubit: qreg, pulseSpacings, TPPIFreq=0, calRepeats=2):
"""
Variable pulse spacing Ramsey (pi/2 - tau - pi/2) with optional TPPI.
Parameters
----------
qubit : logical channel to implement sequence (LogicalChannel)
pulseSpacings : pulse spacings (iterable; seconds)
TPPIFreq : frequency for TPPI phase updates of second Ramsey pulse (Hz)
calRepeats : how many repetitions of calibration pulses (int)
"""
# Original:
# # Create the phases for the TPPI
# phases = 2*pi*TPPIFreq*pulseSpacings
# # Create the basic Ramsey sequence
# seqs = [[X90(qubit), Id(qubit, d), U90(qubit, phase=phase), MEAS(qubit)]
# for d,phase in zip(pulseSpacings, phases)]
# # Tack on the calibration scalings
# seqs += create_cal_seqs((qubit,), calRepeats)
# fileNames = compile_to_hardware(seqs, 'Ramsey'+('_'+qubit.label)*suffix+'/Ramsey'+('_'+qubit.label)*suffix)
# print(fileNames)
# if showPlot:
# plot_pulse_files(fileNames)
# Create the phases for the TPPI
phases = 2*pi*TPPIFreq*pulseSpacings
# Creating sequences that look like this:
# [['X90', 'Id', 'U90', 'M'], ['X90', 'Id', 'U90', 'M']]
# Create the basic Ramsey sequence
for d,phase in zip(pulseSpacings, phases):
init(qubit)
X90(qubit)
Id(qubit, length=d)
U90(qubit, phase=phase)
MEAS(qubit)
# Tack on calibration
create_cal_seqs(qubit, calRepeats)
def HahnEcho(qubit: qreg, pulseSpacings, periods=0, calRepeats=2):
"""
A single pulse Hahn echo with variable phase of second pi/2 pulse.
Parameters
----------
qubit : logical channel to implement sequence (LogicalChannel)
pulseSpacings : pulse spacings to sweep over; the t in 90-t-180-t-180 (iterable)
periods: number of artificial oscillations
calRepeats : how many times to repeat calibration scalings (default 2)
"""
# Original:
# seqs=[];
# for k in range(len(pulseSpacings)):
# seqs.append([X90(qubit), Id(qubit, pulseSpacings[k]), Y(qubit), Id(qubit,pulseSpacings[k]), \
# U90(qubit,phase=2*pi*periods/len(pulseSpacings)*k), MEAS(qubit)])
# # Tack on the calibration scalings
# seqs += create_cal_seqs((qubit,), calRepeats)
# fileNames = compile_to_hardware(seqs, 'Echo/Echo')
# print(fileNames)
# if showPlot:
# plot_pulse_files(fileNames)
for k in range(len(pulseSpacings)):
init(qubit)
X90(qubit)
# FIXME 9/28/16: Must name the length arg (issue #45)
Id(qubit, length=pulseSpacings[k])
Y(qubit)
Id(qubit, length=pulseSpacings[k])
U90(qubit, phase=2 * pi * periods / len(pulseSpacings) * k)
MEAS(qubit)
create_cal_seqs(qubit, calRepeats)
def test_loops(a: qreg, b: qreg):
x = QubitFactory("1")
# Next line causes an error - qbit reassignment
x = r
# Next line is also an error - no d defined
v1 = MEAS(d)
with concur:
while True:
v1 = MEAS(d)
# There's no qbit1 - another error
X90(qbit1)
if v1:
break
while True:
v2 = MEAS(b)
Y90(qbit2)
if v2:
break
with concur:
print('fred')
def loopy3(a: qreg, b: qreg):
for _ in range(2):
X90(a)
Utheta(b)
def process(control: qreg, target: qreg):
X90(control)
Y90(target)
def func_c(a: qreg, x: classical):
X90(a, kwarg1=x) + Y90(a, kwarg1=x)
def sequential(a: qreg, b: qreg):
X90(a)
Y90(b)
def func_b(a: qreg) -> pulse:
X90(a)
Y90(a)
def loopy2(a: qreg, b: qreg, c: qreg):
for q in [a, b, c]:
with concur:
X90(q)
def func_a(q: qreg) -> pulse:
for i in range(0, 3):
X90(q)
def func_c(a: qreg, x: classical):
Id(a) + X90(a, kwarg1=x)
def Hadamard(q: qreg):
Y90(q)
X90(q)
def third_level(a: qreg, b: qreg):
with concur:
X90(a)
Y90(b)
def t1(q_a: qreg, q_b: qreg):
with concur:
X(q_a) + X90(q_a) + Y90(q_a)
Y(q_b) + Y90(q_b) + X90(q_b)
