def rabi(qubit,durations,data = None,variable ="p1x",f_sb = -0.1,amplitude = 1.0,averaging = 20,delay = 0,use12Pulse = False,callback = None,angle = 0,compositePulse = False,gaussian = True,flank = 3,saveData = True):
if data == None:
data = Datacube()
data.setParameters(instrumentManager.parameters())
data.parameters()["defaultPlot"]=[["duration",variable]]
data.setName("Rabi Sequence - %s" % qubit.name())
qubit.setDriveFrequency(qubit.parameters()["frequencies.f01"]+f_sb)
qubit.setDriveAmplitude(I = amplitude,Q = amplitude)
qubit.turnOnDrive()
try:
for duration in durations:
if compositePulse:
seq = PulseSequence()
seq.addPulse(qubit.generateRabiPulse(angle = angle,length = duration/2.0,f_sb = f_sb,sidebandDelay = seq.position(),gaussian = gaussian))
seq.addWait(0)
seq.addPulse(qubit.generateRabiPulse(angle = angle,length = duration/2.0,f_sb = f_sb,sidebandDelay = seq.position(),gaussian = gaussian))
qubit.loadWaveform(seq.getWaveform(endAt = qubit.parameters()["timing.readout"]-delay),readout = qubit.parameters()["timing.readout"])
else:
seq = PulseSequence()
seq.addPulse(qubit.generateRabiPulse(angle = angle,length = duration,f_sb = f_sb,sidebandDelay = seq.position(),gaussian = gaussian))
if use12Pulse:
f_carrier = qubit.parameters()["frequencies.f01"]+f_sb
f_sb_12 = -(qubit.parameters()["frequencies.f12"]-f_carrier)
t_pi_12 = qubit.parameters()["pulses.xy.t_pi12"]
seq.addPulse(qubit.generateRabiPulse(angle = angle,length = t_pi_12,f_sb = f_sb_12,sidebandDelay = seq.position()))
qubit.loadWaveform(seq.getWaveform())#endAt = qubit.parameters()["timing.readout"]-delay),readout = qubit.parameters()["timing.readout"])
if callback != None:
callback(duration)
acqiris.bifurcationMap(ntimes = averaging)
data.set(duration = duration)
data.set(**acqiris.Psw())
data.commit()
except:
import traceback
traceback.print_exc()
finally:
(params,rsquare) = fitRabiFrequency(data,variable,withOffset = True)
if rsquare > 0.5:
qubit.parameters()["pulses.xy.t_pi"] = float(params[1]/2.0)
qubit.parameters()["pulses.xy.drive_amplitude"] = float(amplitude)
qubit.parameters()["pulses.xy.f_sb"] = float(f_sb)
data.parameters()["rabiFit"] = params
qubit.loadRabiPulse(flank = flank,angle = angle,phase = math.pi,readout = qubit.parameters()["timing.readout"],f_sb = f_sb)
else:
print "Rabi fit is not good, resetting parameters..."
qubit.parameters()["pulses.xy.t_pi"] = None
qubit.parameters()["pulses.xy.drive_amplitude"] = None
qubit.parameters()["pulses.xy.f_sb"] = None
if saveData:
data.savetxt()
return data
def phaseError(data,qubit,amplifyingPulses = 0, averaging = 40,phases = list(arange(0,math.pi*2.0,math.pi/10.0)),hot = False,flank = 5,delay = 0,updateNormalization = False,saveData = True):
from instruments.qubit import PulseSequence
data.setName("XPhi Sequence - %s" % qubit.name())
data.setParameters(instrumentManager.parameters())
data.parameters()["defaultPlot"] = [("phi","psw_normalized"),("phi","psw_normalized_fit")]
if "pulses.xy.useDrag" in qubit.parameters() and qubit.parameters()["pulses.xy.useDrag"]:
data.setName(data.name()+" - DRAG")
f_sb = qubit.parameters()["pulses.xy.f_sb"]
qubit.setDriveFrequency(qubit.parameters()["frequencies.f01"]+f_sb)
qubit.setDriveAmplitude(I = qubit.parameters()["pulses.xy.drive_amplitude"],Q = qubit.parameters()["pulses.xy.drive_amplitude"])
data.setName(data.name()+" - %d amplifying pulses" % amplifyingPulses)
failed = False
try:
for phi in phases:
seq = PulseSequence()
seq.addPulse(qubit.generateRabiPulse(phase = math.pi/2.0,angle = 0.0,f_sb = f_sb,sidebandDelay = seq.position()))
for i in range(0,amplifyingPulses):
seq.addWait(10)
seq.addPulse(qubit.generateRabiPulse(phase = math.pi/2.0,angle = 0.0,f_sb = f_sb,sidebandDelay = seq.position()))
seq.addWait(10)
seq.addPulse(qubit.generateRabiPulse(phase = math.pi/2.0,angle = math.pi,f_sb = f_sb,sidebandDelay = seq.position()))
seq.addWait(delay)
seq.addPulse(qubit.generateRabiPulse(phase = math.pi/2.0,angle = phi,f_sb = f_sb,sidebandDelay = seq.position()))
waveform = seq.getWaveform(endAt = qubit.parameters()["timing.readout"])
if hot:
figure("waveform")
cla()
plot(real(waveform[-seq.position():]))
plot(imag(waveform[-seq.position():]))
qubit.loadWaveform(waveform,readout = qubit.parameters()["timing.readout"])
data.set(phi = phi*180.0/math.pi)
data.set(psw_normalized = qubit.Psw(normalize = True,ntimes = averaging))
data.set(**acqiris.Psw())
data.commit()
except StopThread:
pass
except:
failed = True
finally:
if failed:
raise
fitfunc = lambda p, x: p[2]+p[0]*(1.0+scipy.cos(-p[1]+x/180.0*math.pi))/2.0
errfunc = lambda p, x, y,ff: numpy.linalg.norm((ff(p,x)-y))
ps = [max(data.column("psw_normalized"))-min(data.column("psw_normalized")),mean(data.column("psw_normalized")),0]
p1 = data.column("psw_normalized")
p1s = scipy.optimize.fmin(errfunc, ps,args=(data.column("phi"),p1,fitfunc))
rsquare = 1.0-numpy.cov(p1-fitfunc(p1s,data.column("phi")))/numpy.cov(p1)
data.createColumn("psw_normalized_fit",fitfunc(p1s,data.column("phi")))
data.setDescription(data.description()+("\nPhase lag:%g deg" % (p1s[1]*180.0/math.pi)))
data.setName(data.name() + (" - phi = %g deg" % (p1s[1]*180.0/math.pi)))
if saveData:
data.savetxt()
return (p1s[1]*180.0/math.pi)
t_pi_12 = qubit.parameters()["pulses.xy.t_pi12"]
try:
for duration in durations:
seq = PulseSequence()
l = len(qubit.generateRabiPulse(phase = phase))
zLen = len(qubit.generateZPulse(length = duration))
if amplitude != 0:
zSeq = PulseSequence()
zSeq.addPulse(baseForm)
zSeq.setPosition(0)
zSeq.addPulse(qubit.generateZPulse(length = duration,delay = qubit.parameters()["timing.readout"]-zLen-l)*amplitude)
qubit.loadFluxlineWaveform(zSeq.getWaveform(),compensateResponse = False)
if transition == 01 or 02 == transition:
seq.addPulse(qubit.generateRabiPulse(angle = angle,phase = phase,f_sb = f_sb-f_offset,sidebandDelay = seq.position()))
seq.addWait(zLen)
seq.addPulse(qubit.generateRabiPulse(angle = angle,phase = phase,f_sb = f_sb-f_offset,sidebandDelay = seq.position()))
elif transition == 12:
seq.addPulse(qubit.generateRabiPulse(angle = angle,phase = math.pi,f_sb = f_sb,sidebandDelay = seq.position()))
seq.addPulse(qubit.generateRabiPulse(angle = angle,length = t_pi_12/2.0*phase/math.pi*2.0,f_sb = f_sb_12-f_offset,sidebandDelay = seq.position()))
seq.addWait(zLen)
seq.addPulse(qubit.generateRabiPulse(angle = angle,length = t_pi_12/2.0*phase/math.pi*2.0,f_sb = f_sb_12-f_offset,sidebandDelay = seq.position()))
seq.addPulse(qubit.generateRabiPulse(angle = angle,phase = math.pi,f_sb = f_sb,sidebandDelay = seq.position()))
if use12Pulse:
seq.addPulse(qubit.generateRabiPulse(angle = angle,phase = t_pi_12,f_sb = f_sb_12,sidebandDelay = seq.position()))
qubit.loadWaveform(seq.getWaveform(endAt = qubit.parameters()["timing.readout"]),readout = qubit.parameters()["timing.readout"])
if callback != None:
callback(duration)
acqiris.bifurcationMap(ntimes = averaging)
def measureSwapSequence(
swapDuration=0,
pulseHeight=0,
delayBeforeTomography=0,
measurements=["zz"],
averaging=100,
state=[[0, 0], [math.pi, 0]],
piLength=0,
tomographyLength=0,
tomographyDelay=0,
xyRotation=0,
measurementRotations=None,
use12Pulse=False,
alpha=0,
beta=0,
zrot=0,
):
f_sb1 = qubit1.parameters()["pulses.xy.f_sb"]
f_sb2 = qubit2.parameters()["pulses.xy.f_sb"]
from instruments.qubit import PulseSequence
# print "Length of tomgography pulse: %g" % tomographyLength
qb1BaseFlux = qubit1.fluxlineBaseWaveform()
qb2BaseFlux = qubit2.fluxlineBaseWaveform()
qb1FluxSeq = PulseSequence()
qb1FluxSeq.addPulse(qb1BaseFlux)
qb2FluxSeq = PulseSequence()
qb2FluxSeq.addPulse(qb2BaseFlux)
if use12Pulse:
tomographyLength += pi12Length
ro1 = qubit1.parameters()["timing.readout"]
ro2 = qubit2.parameters()["timing.readout"]
readout = max(ro1, ro2)
swapPulse = qubit1.generateZPulse(length=swapDuration, gaussian=False) * pulseHeight
zRot = qubit1.generateZPulse(length=zrot, gaussian=False)
zLen = len(swapPulse) + delayBeforeTomography + len(zRot)
qb1FluxSeq.addPulse(swapPulse, delay=ro1 - zLen - tomographyLength, position=0)
qb1FluxSeq.addPulse(zRot * alpha, delay=ro1 - zLen - tomographyLength + len(swapPulse), position=0)
qb2FluxSeq.addPulse(zRot * beta, delay=ro1 - zLen - tomographyLength + len(swapPulse), position=0)
qubit1.loadFluxlineWaveform(
qb1FluxSeq.getWaveform(),
factor=qubit1.parameters()["flux.compensationFactor"],
compensateResponse=qubit1.parameters()["flux.compensateResponse"],
)
qubit2.loadFluxlineWaveform(
qb2FluxSeq.getWaveform(),
factor=qubit2.parameters()["flux.compensationFactor"],
compensateResponse=qubit2.parameters()["flux.compensateResponse"],
)
npsw = dict()
if measurementRotations == None:
for m in measurements:
x = m[0]
y = m[1]
# print "Measuring along %s%s" % (x,y)
qb2Seq = PulseSequence()
qb1Seq = PulseSequence()
qb1Seq.addPulse(
qubit1.generateRabiPulse(
phase=state[0][0], angle=state[0][1], f_sb=f_sb1, delay=readout - zLen - piLength - tomographyLength
),
position=0,
)
qb2Seq.addPulse(
qubit2.generateRabiPulse(
phase=state[1][0], angle=state[1][1], f_sb=f_sb2, delay=readout - zLen - piLength - tomographyLength
),
position=0,
)
phasex = xyRotation
phasey = 0
if x[0] == "m":
phasex += math.pi
if y[0] == "m":
phasey += math.pi
if x == "x" or x == "mx":
# We add a Pi/2 rotation around Y to measure along X
qb1Seq.addPulse(
qubit1.generateRabiPulse(
angle=-math.pi / 2.0 + phasex,
phase=math.pi / 2.0,
delay=readout - tomographyLength + tomographyDelay,
f_sb=f_sb1,
),
position=0,
)
elif x == "y" or x == "my":
# We add a -Pi/2 rotation around X to measure along Y
qb1Seq.addPulse(
qubit1.generateRabiPulse(
angle=phasex,
phase=math.pi / 2.0,
delay=readout - tomographyLength + tomographyDelay,
f_sb=f_sb1,
),
position=0,
)
elif x == "mz":
qb1Seq.addPulse(
qubit1.generateRabiPulse(
angle=0, phase=math.pi, delay=readout - tomographyLength + tomographyDelay, f_sb=f_sb1
),
position=0,
)
else:
qb1Seq.addWait(tomographyLength)
if y == "x" or y == "mx":
# We add a Pi/2 rotation around Y to measure along X
qb2Seq.addPulse(
qubit2.generateRabiPulse(
angle=-math.pi / 2.0 + phasey,
phase=math.pi / 2.0,
delay=readout - tomographyLength + tomographyDelay,
f_sb=f_sb2,
),
position=0,
)
elif y == "y" or y == "my":
# We add a -Pi/2 rotation around X to measure along Y
qb2Seq.addPulse(
qubit2.generateRabiPulse(
angle=phasey,
phase=math.pi / 2.0,
delay=readout - tomographyLength + tomographyDelay,
f_sb=f_sb2,
),
position=0,
)
elif y == "mz":
qb2Seq.addPulse(
qubit2.generateRabiPulse(
angle=0, phase=math.pi, delay=readout - tomographyLength + tomographyDelay, f_sb=f_sb2
),
position=0,
)
else:
qb2Seq.addWait(tomographyLength)
if use12Pulse:
qb1Seq.addPulse(
qubit1.generateRabiPulse(
length=qubit1.parameters()["pulses.xy.t_pi12"],
delay=readout - pi12Length,
f_sb=qubit1.parameters()["pulses.xy.f_sb12"],
),
position=0,
)
qb2Seq.addPulse(
qubit2.generateRabiPulse(
length=qubit2.parameters()["pulses.xy.t_pi12"],
delay=readout - pi12Length,
f_sb=qubit2.parameters()["pulses.xy.f_sb12"],
),
position=0,
)
qubit1.loadWaveform(qb1Seq.getWaveform(), readout=readout)
qubit2.loadWaveform(qb2Seq.getWaveform(), readout=readout)
time.sleep(1)
acqiris.bifurcationMap(ntimes=averaging)
psw = acqiris.Psw()
for key in psw.keys():
npsw[x + y + key] = psw[key]
else:
"""
We define explicitely the rotation angles and phases for each qubit...
"""
(angle1, phase1, angle2, phase2) = measurementRotations
qb2Seq = PulseSequence()
qb1Seq = PulseSequence()
qb1Seq.addPulse(
qubit1.generateRabiPulse(
phase=state[0][0], angle=state[0][1], f_sb=f_sb1, delay=readout - zLen - piLength - tomographyLength
),
position=0,
)
qb2Seq.addPulse(
qubit2.generateRabiPulse(
phase=state[1][0], angle=state[1][1], f_sb=f_sb2, delay=readout - zLen - piLength - tomographyLength
),
position=0,
)
qb1Seq.addPulse(
qubit1.generateRabiPulse(
angle=angle1, phase=phase1, delay=readout - tomographyLength + tomographyDelay, f_sb=f_sb1
),
position=0,
)
qb2Seq.addPulse(
qubit2.generateRabiPulse(
angle=angle2, phase=phase2, delay=readout - tomographyLength + tomographyDelay, f_sb=f_sb2
),
position=0,
)
if use12Pulse:
qb1Seq.addPulse(
qubit1.generateRabiPulse(
length=qubit1.parameters()["pulses.xy.t_pi12"],
delay=readout - pi12Length,
f_sb=qubit1.parameters()["pulses.xy.f_sb12"],
),
position=0,
)
qb2Seq.addPulse(
qubit2.generateRabiPulse(
length=qubit2.parameters()["pulses.xy.t_pi12"],
delay=readout - pi12Length,
f_sb=qubit2.parameters()["pulses.xy.f_sb12"],
),
position=0,
)
qubit1.loadWaveform(qb1Seq.getWaveform(), readout=readout)
qubit2.loadWaveform(qb2Seq.getWaveform(), readout=readout)
time.sleep(1)
acqiris.bifurcationMap(ntimes=averaging)
npsw = acqiris.Psw()
return npsw
def measureTomography(
driveSequences, fluxSequences, delay=5, use12Pulse=False, xyRotation=0, averaging=80, onlyZZ=False
):
f_sb1 = qubit1.parameters()["pulses.xy.f_sb"]
f_sb2 = qubit2.parameters()["pulses.xy.f_sb"]
measurements = generateCombinations(["x", "y", "z"], lambda x, y: x + y, 2)
from instruments.qubit import PulseSequence
piLength = max(
len(qubit1.generateRabiPulse(phase=math.pi, f_sb=f_sb1)),
len(qubit2.generateRabiPulse(phase=math.pi, f_sb=f_sb2)),
)
tomographyLength = ceil(
max(
len(qubit1.generateRabiPulse(angle=-math.pi / 2.0, phase=math.pi / 2.0, f_sb=f_sb1)),
len(qubit2.generateRabiPulse(angle=-math.pi / 2.0, phase=math.pi / 2.0, f_sb=f_sb2)),
)
)
if use12Pulse:
tomographyLength += pi12Length
if onlyZZ:
if use12Pulse:
tomographyLength = pi12Length
else:
tomographyLength = 0
measurements = ["zz"]
readout = qubit1.readoutDelay()
seqs = [driveSequences[0], driveSequences[1], fluxSequences[0], fluxSequences[1]]
seqLength = max(map(lambda x: len(x), seqs))
for i in range(0, len(seqs)):
seqs[i].addWait(seqLength - len(seqs[i]))
start = readout - tomographyLength
npsw = dict()
qb1BaseFlux = qubit1.fluxlineBaseWaveform()
qb2BaseFlux = qubit2.fluxlineBaseWaveform()
qb1FluxSeq = PulseSequence()
qb1FluxSeq.addPulse(qb1BaseFlux)
qb2FluxSeq = PulseSequence()
qb2FluxSeq.addPulse(qb2BaseFlux)
qb1FluxSeq.addPulse(fluxSequences[0].getWaveform(), position=start - seqLength)
qb2FluxSeq.addPulse(fluxSequences[1].getWaveform(), position=start - seqLength)
qubit1.loadFluxlineWaveform(
qb1FluxSeq.getWaveform(),
factor=qubit1.parameters()["flux.compensationFactor"],
compensateResponse=qubit1.parameters()["flux.compensateResponse"],
)
qubit2.loadFluxlineWaveform(
qb2FluxSeq.getWaveform(),
factor=qubit2.parameters()["flux.compensationFactor"],
compensateResponse=qubit2.parameters()["flux.compensateResponse"],
)
for m in measurements:
x = m[0]
y = m[1]
qb2Seq = PulseSequence()
qb1Seq = PulseSequence()
qb1Seq.addPulse(driveSequences[0].getWaveform(), position=0)
qb2Seq.addPulse(driveSequences[1].getWaveform(), position=0)
phasex = xyRotation
phasey = 0
if x[0] == "m":
phasex += math.pi
if y[0] == "m":
phasey += math.pi
if x == "x" or x == "mx":
# We add a Pi/2 rotation around Y to measure along X
qb1Seq.addPulse(
qubit1.generateRabiPulse(
angle=-math.pi / 2.0 + phasex, phase=math.pi / 2.0, f_sb=f_sb1, delay=seqLength
),
position=0,
)
elif x == "y" or x == "my":
# We add a -Pi/2 rotation around X to measure along Y
qb1Seq.addPulse(
qubit1.generateRabiPulse(angle=phasex, phase=math.pi / 2.0, f_sb=f_sb1, delay=seqLength), position=0
)
elif x == "mz":
qb1Seq.addPulse(qubit1.generateRabiPulse(angle=0, phase=math.pi, f_sb=f_sb1, delay=seqLength), position=0)
if y == "x" or y == "mx":
# We add a Pi/2 rotation around Y to measure along X
qb2Seq.addPulse(
qubit2.generateRabiPulse(
angle=-math.pi / 2.0 + phasey, phase=math.pi / 2.0, f_sb=f_sb2, delay=seqLength
),
position=0,
)
elif y == "y" or y == "my":
# We add a -Pi/2 rotation around X to measure along Y
qb2Seq.addPulse(
qubit2.generateRabiPulse(angle=phasey, phase=math.pi / 2.0, f_sb=f_sb2, delay=seqLength), position=0
)
elif y == "mz":
qb2Seq.addPulse(qubit2.generateRabiPulse(angle=0, phase=math.pi, f_sb=f_sb2, delay=seqLength), position=0)
if use12Pulse:
qb1Seq.addPulse(
qubit1.generateRabiPulse(
length=qubit1.parameters()["pulses.xy.t_pi12"],
delay=seqLength + tomographyLength - pi12Length,
f_sb=qubit1.parameters()["pulses.xy.f_sb12"],
),
position=0,
)
qb2Seq.addPulse(
qubit2.generateRabiPulse(
length=qubit2.parameters()["pulses.xy.t_pi12"],
delay=seqLength + tomographyLength - pi12Length,
f_sb=qubit2.parameters()["pulses.xy.f_sb12"],
),
position=0,
)
maxLen = seqLength + tomographyLength
qb1Seq.addWait(maxLen - len(qb1Seq))
qb2Seq.addWait(maxLen - len(qb2Seq))
qubit1.loadWaveform(qb1Seq.getWaveform(endAt=readout), readout=readout)
qubit2.loadWaveform(qb2Seq.getWaveform(endAt=readout), readout=readout)
time.sleep(1)
acqiris.bifurcationMap(ntimes=averaging)
psw = acqiris.Psw()
for key in psw.keys():
npsw[x + y + key] = psw[key]
return npsw
targetState = tensor(gs, gs)
rotation = tensor(roty(math.pi / 2.0), roty(math.pi / 2.0))
targetRho = adjoint(targetState) * targetState
targetRho = rotation * targetRho * adjoint(rotation)
rhoBeforeSwap = targetRho.copy()
driveSequence1.addPulse(qubit1.generateRabiPulse(f_sb=f_sb1, phase=math.pi / 2.0, angle=math.pi / 2.0))
driveSequence2.addPulse(qubit2.generateRabiPulse(f_sb=f_sb2, phase=math.pi / 2.0, angle=math.pi / 2.0))
maxLen = max(len(driveSequence1), len(driveSequence2))
driveSequence1.addWait(maxLen - len(driveSequence1))
driveSequence2.addWait(maxLen - len(driveSequence2))
if step >= 2:
# We apply the tag operator...
fluxSequence1.addPulse(zPulse * fluxAnticrossing, position=driveSequence1.position())
fluxSequence2.addWait(fluxSequence1.position() - fluxSequence2.position())
fluxSequence1.addPulse(qubit1.generateZPulse(length=6, gaussian=False) * alpha)
fluxSequence2.addPulse(qubit2.generateZPulse(length=6, gaussian=False) * beta)
fluxSequence1.addWait(3)
fluxSequence2.addWait(3)
