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)