def rabi12(qubit,durations,data = None,variable ="p1x",averaging = 20,delay = 0,callback = None,saveData = True):
from instruments.qubit import PulseSequence
if data == None:
data = Datacube()
data.setParameters(instrumentManager.parameters())
data.setName("Rabi Sequence 12 - %s" % qubit.name())
amplitude = qubit.parameters()["pulses.xy.drive_amplitude"]
f_sb = qubit.parameters()["pulses.xy.f_sb"]
f_carrier = qubit.parameters()["frequencies.f01"]+f_sb
f_sb_12 = -(qubit.parameters()["frequencies.f12"]-f_carrier)
print f_sb_12
qubit.setDriveFrequency(f_carrier)
qubit.setDriveAmplitude(I = amplitude,Q = amplitude)
failed = False
data.parameters()["defaultPlot"] = [["duration",variable],["duration","%s_fit" % variable]]
try:
for duration in durations:
seq = PulseSequence()
seq.addPulse(qubit.generateRabiPulse(phase = math.pi,f_sb = f_sb))
seq.addPulse(qubit.generateRabiPulse(length = duration,f_sb = f_sb_12))
seq.addPulse(qubit.generateRabiPulse(phase = math.pi,f_sb = f_sb))
qubit.loadWaveform(seq.getWaveform(endAt = qubit.parameters()["timing.readout"]),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 StopThread:
pass
except:
print "Failed!"
failed = True
import traceback
traceback.print_exc()
finally:
if len(data) == 0:
return
if failed:
raise
(params,rsquare) = fitRabi12Frequency(data,variable)
qubit.parameters()["pulses.xy.t_pi12"] = params[1]/2.0
qubit.parameters()["pulses.xy.drive_amplitude12"] = amplitude
qubit.parameters()["pulses.xy.f_sb12"] = f_sb_12
data.parameters()["rabiFit12"] = params
if saveData:
data.savetxt()
return data
def rabi02(qubit,durations,data = None,variable ="p1x",f_sb = -0.1,amplitude = 1.0,averaging = 20,delay = 0,callback = None):
from instruments.qubit import PulseSequence
if data == None:
data = Datacube()
data.setParameters(instrumentManager.parameters())
data.setName("Rabi Sequence 02 - %s" % qubit.name())
f_sb_12 = f_sb-qubit.parameters()["frequencies.f02"]+qubit.parameters()["frequencies.f01"]*2
qubit.setDriveFrequency(qubit.parameters()["frequencies.f01"]+f_sb)
qubit.setDriveAmplitude(I = amplitude,Q = amplitude)
pi12Length = len(qubit.generateRabiPulse(phase = qubit.parameters()["pulses.xy.t_pi12"],f_sb = f_sb))
try:
for duration in durations:
pulseLength = len(qubit.generateRabiPulse(length = duration,f_sb = f_sb_12))
seq = PulseSequence()
seq.addPulse(qubit.generateRabiPulse(length = duration,delay = qubit.parameters()["timing.readout"]-pulseLength-pi12Length,f_sb = f_sb))
seq.addPulse(qubit.generateRabiPulse(length = qubit.parameters()["pulses.xy.t_pi12"],delay = qubit.parameters()["timing.readout"]-pi12Length,f_sb = f_sb_12))
qubit.loadWaveform(seq.getWaveform(),readout = qubit.parameters()["timing.readout"])
if callback != None:
callback(duration)
acqiris.bifurcationMap(ntimes = averaging)
data.set(duration = duration)
data.set(**acqiris.Psw())
data.commit()
finally:
data.savetxt()
return data
def loadPi012Pulse(qubit,phase = math.pi,delay=0): from instruments.qubit import PulseSequence seq = PulseSequence() len1 = len(qubit.generateRabiPulse(length = qubit.parameters()["pulses.xy.t_pi12"])) len2 = len(qubit.generateRabiPulse(phase = phase)) seq.addPulse(qubit.generateRabiPulse(phase = phase,f_sb = qubit.parameters()["pulses.xy.f_sb"],delay = qubit.parameters()["timing.readout"]-len2-len1-delay),position = 0) seq.addPulse(qubit.generateRabiPulse(length = qubit.parameters()["pulses.xy.t_pi12"],f_sb = qubit.parameters()["pulses.xy.f_sb12"],delay = qubit.parameters()["timing.readout"]-len1-delay),position = 0) qubit.loadWaveform(seq.getWaveform(),readout = qubit.parameters()["timing.readout"])
def loadPi012Pulse(qubit): from instruments.qubit import PulseSequence seq = PulseSequence() f_sb = qubit.parameters()["pulses.xy.f_sb"] f_sb_12 = f_sb-qubit.parameters()["frequencies.f02"]+qubit.parameters()["frequencies.f01"]*2 piLength = len(qubit.generateRabiPulse(phase = math.pi,f_sb = f_sb)) pulseLength = len(qubit.generateRabiPulse(length = qubit.parameters()["pulses.xy.t_pi12"],f_sb = f_sb_12)) seq.addPulse(qubit.generateRabiPulse(phase = math.pi,delay = qubit.parameters()["timing.readout"]-pulseLength-piLength,f_sb = f_sb)) seq.addPulse(qubit.generateRabiPulse(length = qubit.parameters()["pulses.xy.t_pi12"],delay = qubit.parameters()["timing.readout"]-pulseLength,f_sb = f_sb_12)) qubit.loadWaveform(seq.getWaveform(),readout = qubit.parameters()["timing.readout"])
##Record s curves:
qubit1.loadFluxlineBaseWaveform(parkFlux =1.56*0,manipulationFlux = 0.73,readoutFlux = 0.73,readout = ro,compensationFactor = 0.8,readoutDelay = 0)
qubit2.loadFluxlineBaseWaveform(parkFlux =1.56*0,manipulationFlux = 1.12,readoutFlux = 1.12,readout = ro,compensationFactor = 1.2,readoutDelay = 0)
##Testing of fluxline without qubits
loadBaseWaveform(qubit1,afg1,jba1,parkFlux =0,manipulationFlux = 0.0,readoutFlux = 0.0,readout = ro,compensationFactor = 0.8)
loadBaseWaveform(qubit2,afg2,jba2,parkFlux =0,manipulationFlux = 0.0,readoutFlux = 0.0,readout = ro,compensationFactor = 0.8)
##
from instruments.qubit import PulseSequence
instrumentManager.reloadInstrument("awg")
instrumentManager.reloadInstrument("awg2")
qubit1.reloadClass()
qubit2.reloadClass()
f1Seq = PulseSequence()
f1Seq.addPulse(qubit1.fluxlineBaseWaveform()*0.6)
waveform = zeros(qubit1.parameters()["timing.readout"])
waveform[qubit1.parameters()["timing.readout"]-20:qubit1.parameters()["timing.readout"]]+=0.2
f1Seq.addPulse(waveform,position = 0)
qubit1.loadFluxlineWaveform(f1Seq.getWaveform(),compensateResponse = False)
qubit1.loadRabiPulse(length = 20,delay = -10,f_sb = 0.00)
qubit2.loadRabiPulse(length = 20,delay = -10,f_sb = 0)
##
figure("waveform")
cla()
print (1*((1 << 14) - 1)) & 0xFFFF
print numpy.array((numpy.array(qubit1.driveWaveform())+1.0)/2.0*((1 << 14)-1),dtype = int16)& 0xFFFF
plot(numpy.array((numpy.array(qubit1.driveWaveform())+1.0)/2.0*((1 << 14)-1),dtype = int16))
##
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)
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
f_sb-=f_shift
qubit.setDriveAmplitude(I = qubit.parameters()["pulses.xy.drive_amplitude"],Q = qubit.parameters()["pulses.xy.drive_amplitude"])
qubit.turnOnDrive()
if amplitude != 0:
qubit.pushState()
baseForm = qubit.fluxlineWaveform()
if 02 == transition:
f_offset/=2.0
if transition == 12 or use12Pulse:
f_carrier = qubit.parameters()["frequencies.f01"]+f_sb
f_sb_12 = -(qubit.parameters()["frequencies.f12"]-f_carrier)
f_sb_12 = qubit.parameters()["pulses.xy.f_sb12"]
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()))
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
gamma = -0.031
delta = -0.019
qubit1.setDriveRotation(70.0 / 180.0 * math.pi)
qubit2.setDriveRotation(0 / 180.0 * math.pi)
use12Pulse = True
onlyZZ = False
try:
for state in [0, 1, 2, 3]:
for step in [1, 2, 3, 4, 5]:
fluxSequence1 = PulseSequence()
fluxSequence2 = PulseSequence()
driveSequence1 = PulseSequence()
driveSequence2 = PulseSequence()
data = Datacube("State = %d - Step = %d" % (state, step))
grover.addChild(data, state=state, step=step)
data.setParameters(instrumentManager.parameters())
if step >= 1:
# We initialize the system in the state 1/2(|0>+-i|1>)(|0>+-i|1>)
targetState = tensor(gs, gs)
