def rabi(qubit,durations,data = None,variable ="p1x",f_sb = -0.1,amplitude = 1.0,averaging = 20,delay = 0,callback = None): if data == None: data = Datacube() data.setParameters(instrumentManager.parameters()) 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: qubit.loadRabiPulse(length = duration,readout = qubit.parameters()["timing.readout"],f_sb = f_sb) if callback != None: callback(duration) acqiris.bifurcationMap(ntimes = averaging) data.set(duration = duration) data.set(**acqiris.Psw()) data.commit() finally: try: params = fitRabiFrequency(data,variable) qubit.parameters()["pulses.xy.t_pi"] = params[1]/2.0-params[4] qubit.parameters()["pulses.xy.drive_amplitude"] = amplitude qubit.parameters()["pulses.xy.f_sb"] = f_sb data.parameters()["rabiFit"] = params qubit.loadRabiPulse(phase = math.pi,readout = qubit.parameters()["timing.readout"],f_sb = f_sb) except: pass 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 measureRabi(self,tstart,tstop,tstep,power=None,name=None,data=None): newData=False if data==None: newData=True if name==None:name='rabi %s'%self.name() data=Datacube(name) dataManager.addDatacube(data) durations=numpy.arange(tstart,tstop,tstep) if power==None: power=self._rabiPower self._pulseGenerator._MWSource.turnOn() self._pulseGenerator._MWSource.setPower(power) self._pulseGenerator._MWSource.setFrequency(self._f01) try: for duration in durations: self._pulseGenerator.generatePulse(duration=duration,frequency=self._f01,DelayFromZero=register['repetitionPeriod']/2-duration-10,useCalibration=False) self._pulseGenerator.sendPulse() data.set(duration=duration) data.set(p=self._jba.takePoint()) data.commit() except: raise finally: data.setParameters(instrumentManager.parameters()) self._rabiPower=power if newData:data.savetxt() p,o2=fitRabiFrequency(data,yVariable = "p",xVariable = "duration") self._rabiDuration=p[1]/2 return data
def measureT1(self,tstart,tstop,tstep,accurate=False,name=None,data=None): newData=False if data==None: newData=True if name==None:name='T1 %s'%self.name() data=Datacube(name) dataManager.addDatacube(data) data.setParameters(instrumentManager.parameters()) self._pulseGenerator._MWSource.turnOn() self._pulseGenerator._MWSource.setPower(self._rabiPower) self._pulseGenerator._MWSource.setFrequency(self._f01) print tstart,tstop, tstep if accurate: delays=numpy.concatenate([numpy.arange(tstart,tstart+(tstop-tstart)*0.3,tstep),numpy.arange(tstart+(tstop-tstart)*0.9,tstop,max(1,int(tstep/2)))],axis=0) else: delays=numpy.arange(tstart,tstop,tstep) try: for delay in delays: self._pulseGenerator.generatePulse(duration=self._rabiDuration,frequency=self._f01,DelayFromZero=register['repetitionPeriod']/2-self._rabiDuration-delay,useCalibration=False) self._pulseGenerator.sendPulse() data.set(delay=delay) data.set(p=self._jba.takePoint()) data.commit() except: raise finally: data.setParameters(instrumentManager.parameters()) p=fitT1Parameters(data,variable = "p") if newData:data.savetxt() self._t1=p[2] return data
def measureSpectroscopy(self,fstart,fstop,fstep,power=0.,name=None,data=None): duration=2000 newData=False if data==None: newData=True if name==None:name='Spectro %s'%self.name() data=Datacube(name) dataManager.addDatacube(data) print fstart,fstop,fstep frequencies=numpy.arange(fstart,fstop,fstep) self._pulseGenerator._MWSource.turnOn() self._pulseGenerator._MWSource.setPower(power) self._pulseGenerator.generatePulse(duration=duration,frequency=fstart,DelayFromZero=register['repetitionPeriod']/2-duration-15,useCalibration=False) self._pulseGenerator.sendPulse() try: for f in frequencies: print f self._pulseGenerator._MWSource.setFrequency(f) data.set(f=f) data.set(**self._jba.measure()[1]) data.commit() except: raise finally: data.setParameters(instrumentManager.parameters()) if newData:data.savetxt() try: p,o2=fitQubitFrequency(data,variable = "b1")#,f0=self._f01) self._f01=p[1] finally: return data
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 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 getTrace(self,correctPhase = False,waitFullSweep = False,timeOut = 200): print "Getting trace..." trace = Datacube() if DEBUG: print "Getting trace..." handle = self.getHandle() handle.timeout = timeOut if waitFullSweep: # freqs = self.ask_for_values("HLD;TRS;WFS;fma;msb;OFV;") 2011/12 VS self.write("TRS;WFS;") freqs = self.ask_for_values("fma;msb;OFV;") data = self.ask_for_values("fma;msb;OFD;") freqs.pop(0) data.pop(0) mag = [] phase = [] #If y length is twice the x length, we got phase and magnitude. if len(data) == 2*len(freqs): for i in range(0,len(data)): if i%2 == 0: mag.append(data[i]) else: phase.append(data[i]) else: mag = data trace.createColumn("freq",freqs) trace.createColumn("mag",mag) attenuation = float(self.ask("SA1?")) power = float(self.ask("PWR?")) trace.column("mag")[:]+= attenuation params = dict() params["attenuation"] = attenuation params["power"] = power trace.setParameters(params) if len(phase) > 0: correctedPhase = [] if correctPhase: correctedPhase.append(phase[0]) oldPhi = phase[0] for phi in phase[1:]: if fabs(phi+360.0-oldPhi) < fabs(phi-oldPhi): newPhi = phi+360.0 elif fabs(phi-360.0-oldPhi) < fabs(phi-oldPhi): newPhi = phi-360.0 else: newPhi = phi correctedPhase.append(newPhi) oldPhi = newPhi else: correctedPhase = phase trace.createColumn("phase",correctedPhase) print "returning trace." return trace
def ramsey(delays,cube = None,ntimes = 20,length = 20): if cube == None: ramseyData = Datacube() else: ramseyData = cube ramseyData.setParameters(instruments.parameters()) for delay in delays: generateRamseyWaveform(length = length,delay = delay) acqiris.bifurcationMap(ntimes = ntimes) ramseyData.set(delay = delay,**acqiris.Psw()) ramseyData.commit() return rabiData
def T1(qubit,delays,data = None,averaging = 20,variable = "p1x"): if data == None: data = Datacube() data.setName("T1 - " + qubit.name()) data.setParameters(instrumentManager.parameters()) try: for delay in delays: qubit.loadRabiPulse(phase = math.pi,readout = qubit.parameters()["timing.readout"],delay = delay) acqiris.bifurcationMap(ntimes = averaging) data.set(delay = delay) data.set(**acqiris.Psw()) data.commit() finally: params = fitT1Parameters(data,variable) data.setName(data.name()+" - T1 = %g ns " % params[2]) qubit.parameters()["relaxation.t1"] = params[2] data.savetxt() return data
def measureSpectroscopy(qubit,frequencies,data = None,ntimes = 20,amplitude = 1,measureAtReadout = False,delay = 0,f_sb = 0,delayAtReadout = 1500,pulseLength = 500,gaussian=False): if data == None: data = Datacube() if measureAtReadout: qubit.loadRabiPulse(length = pulseLength,f_sb = f_sb,delay = delay,gaussian=gaussian) else: qubit.loadRabiPulse(length = pulseLength,f_sb = f_sb,delay = delay,gaussian=gaussian) qubit.turnOnDrive() data.setParameters(dict(data.parameters(),**instrumentManager.parameters())) try: for f in frequencies: qubit.setDriveFrequency(f+f_sb) qubit.setDriveAmplitude(I = amplitude,Q = amplitude) acqiris.bifurcationMap(ntimes = ntimes) data.set(f = f) data.set(**acqiris.Psw()) data.commit() except StopThread: return data
def setUp(self): """ We create all necessary directories and test datacubes for the IO tests. """ self.testCubes = dict() rc = Datacube() self.testCubes["real"] = rc rc.setName("Datacube test: Real data") rc.setParameters({"test":1,"array":[1,2,3,4],"hash":{"a":1,"b":2}}) for i in range(0,2): rc.set(x = i,y = i*i, z = i*i*i,r = random.random()) child = Datacube() child.setName("test {0:d}".format(i)) rc.addChild(child) rc.commit() for j in range(0,2): child.set(x = j,t = j*2-j*j,r = random.random()) child.commit() self.dataPath = os.path.normpath(os.path.dirname(__file__)+"/data") if not os.path.exists(self.dataPath): os.mkdir(self.dataPath) cx = Datacube(dtype = numpy.complex128) self.testCubes["complex"] = cx rc.setName("Datacube test: Complex data") rc.setParameters({"test":1,"array":[1,2,3,4],"hash":{"a":1,"b":2}}) for i in range(0,2): cx.set(x = i,y = i*i*1j+4, z = i*i*i*1j,r = 1j*random.random()) child = Datacube(dtype = numpy.complex128) child.setName("test {0:d}".format(i)) cx.addChild(child) cx.commit() for j in range(0,2): child.set(x = j,t = j*2-j*j*1j,r = 1j*random.random()) child.commit()
def getTrace(self,waitFullSweep = False,timeOut = 1600,fromMemory=False): """ Get a raw trace in the VNA, without correcting the data, except for internal attenuators. Get the memory instead of main trace if fromMemory=True. Restart a sweep and wait for its completion if fromMemory=False and waitFullSweep=True. FOR INTERNAL USE ONLY. USE INSTEAD getFreqMagPhase(waitFullSweep = False,fromMemory=False,timeOut=60,addedAttenuators=0,unwindPhase=False,subtractedSlope=None,deltaPhase=None,offset=None). """ trace = Datacube('Spectrum') handle = self.getHandle() handle.timeout = timeOut if waitFullSweep: print "Getting trace...", # freqs = self.ask_for_values("HLD;TRS;WFS;fma;msb;OFV;") 2011/12 VS self.write('TRS;WFS;') freqs = self.ask_for_values('fma;msb;OFV;') data = self.write('fma;msb;') if(fromMemory): data = self.ask_for_values('MEM;OFD;') self.write('DTM;') else: data = self.ask_for_values('OFD;') if waitFullSweep: print "done." freqs.pop(0) data.pop(0) mag = [] phase = [] #If y length is twice the x length, we got phase and magnitude. if len(data) == 2*len(freqs): for i in range(0,len(data)): if i%2 == 0: mag.append(data[i]) else: phase.append(data[i]) else: mag = data att=self.attenuation() trace.setParameters( {'attenuation':att,'power':self.totalPower()}) trace.createCol(name='freq',values=freqs) trace.createCol(name='mag',values=array(mag)+att) if len(phase)!=0: trace.createCol(name='phase',values=phase) return trace
def measureSpectroscopy(qubit,frequencies,data = None,ntimes = 20,amplitude = 0.1,measureAtReadout = False,delay = 0,f_sb = 0): if data == None: data = Datacube() if measureAtReadout: qubit.loadRabiPulse(length = 500,readout = qubit.parameters()["timing.readout"]+500,f_sb = f_sb,delay = delay) else: qubit.loadRabiPulse(length = 500,readout = qubit.parameters()["timing.readout"],f_sb = f_sb,delay = delay) qubit.turnOnDrive() data.setParameters(instrumentManager.parameters()) try: for f in frequencies: qubit.setDriveFrequency(f+f_sb) qubit.setDriveAmplitude(I = amplitude,Q = amplitude) acqiris.bifurcationMap(ntimes = ntimes) data.set(f = f) data.set(**acqiris.Psw()) data.commit() finally: return data
def measureSpectroscopy(qubit,frequencies,data = None,ntimes = 20,amplitude = 0.1,variable = "p1x"): if data == None: data = Datacube() data.setName("Spectroscopy - %s" % qubit.name()) qubit.loadRabiPulse(length = 500,readout = qubit.parameters()["timing.readout"],f_sb = 0) qubit.turnOnDrive() data.setParameters(instrumentManager.parameters()) try: for f in frequencies: qubit.setDriveFrequency(f) qubit.setDriveAmplitude(I = amplitude,Q = amplitude) acqiris.bifurcationMap(ntimes = ntimes) data.set(f = f) data.set(**acqiris.Psw()) data.commit() finally: (params,rsquare) = fitQubitFrequency(data,variable) qubit.parameters()["frequencies.f01"] = params[1] qubit.setDriveFrequency(params[1]) data.setName(data.name()+" - f01 = %g GHz" % params[1]) data.savetxt() return spectroData
def T1precis(qubit,delays,data = None,averaging = 20,variable = "p1x"): print "starting T1precis..." if data == None: data = Datacube() data.setName("T1 - " + qubit.name()) data.setParameters(instrumentManager.parameters()) data.parameters()["defaultPlot"]=[["delay",variable]] highTdelays=arange(2500,2600,5) try: for delay in highTdelays: qubit.loadRabiPulse(phase = math.pi,readout = qubit.parameters()["timing.readout"],delay = delay) acqiris.bifurcationMap(ntimes = averaging) data.set(delay=delay) data.set(**acqiris.Psw()) data.commit() highTvalue=data.ColumnMean(variable) highTValueFound=True print "Long time ps=",highTvalue except: highTValueFound=False raise try: for delay in delays: qubit.loadRabiPulse(phase = math.pi,readout = qubit.parameters()["timing.readout"],delay = delay) acqiris.bifurcationMap(ntimes = averaging) data.set(delay=delay) data.set(**acqiris.Psw()) data.commit() finally: if highTValueFound: print "calling fitT1Parametersprecis" params = fitT1Parametersprecis(data,variable,highTvalue) else: params = fitT1Parameters(data,variable) data.setName(data.name()+" - T1 = %g ns " % params[1]) qubit.parameters()["relaxation.t1"] = params[1] data.savetxt() return data
def T1(qubit,delays,data = None,averaging = 20,variable = "p1x",gaussian = True,saveData = True,state=1): if data == None: data = Datacube() data.setName("T1 - " + qubit.name()+" - state "+str(state)) data.setParameters(instrumentManager.parameters()) data.parameters()["defaultPlot"]=[["delay",variable]] try: for delay in delays: if state==2: loadPi012Pulse(qubit,delay=delay) else: qubit.loadRabiPulse(phase = math.pi,delay = delay,gaussian = gaussian) acqiris.bifurcationMap(ntimes = averaging) data.set(delay = delay) data.set(**acqiris.Psw()) data.commit() finally: params = fitT1Parameters(data,variable) data.setName(data.name()+" - T1 = %g ns " % params[2]) qubit.parameters()["relaxation.t1_%d" % state] = params[2] if saveData: data.savetxt() return data
from macros.qubit_functions import * from pyview.helpers.datamanager import DataManager dataManager = DataManager() from pyview.helpers.instrumentsmanager import Manager from instruments.qubit import * reload(sys.modules["instruments.qubit"]) from instruments.qubit import * instruments = Manager() def ramsey(qubit,durations,data = None,variable ="p1x",callback = None,angle = 0,phase = math.pi/2.0,averaging = 20,amplitude = 0,f_offset = 0,correctFrequency = False,saveData = True,transition = 01,use12Pulse = False): if data == None: data = Datacube() data.setParameters(instrumentManager.parameters()) data.parameters()["defaultPlot"]=[["duration",variable]] data.setName("Ramsey Sequence - %s" % qubit.name()) f_sb = qubit.parameters()["pulses.xy.f_sb"] if 'pulses.xy.f_shift' in qubit.parameters(): f_shift=qubit.parameters()["pulses.xy.f_shift"] else: f_shift=0 qubit.setDriveFrequency(qubit.parameters()["frequencies.f01"]+f_sb) 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:
def sCurves(qubit,jba,variable = "p1x",data = None,ntimes = 20,optimize = "v20"): """ Measures the s curves of the JBA. Assumes that the qubit is alread preset to a pi-pulse. """ def getVoltageBounds(v0,jba,variable,ntimes): v = v0 jba.setVoltage(v) acqiris.bifurcationMap(ntimes = ntimes) p = acqiris.Psw()[variable] while p > 0.03 and v < v0*2.0: v*=1.05 jba.setVoltage(v) acqiris.bifurcationMap() p = acqiris.Psw()[variable] vmax = v v = v0 jba.setVoltage(v) acqiris.bifurcationMap(ntimes = ntimes) p = acqiris.Psw()[variable] while p < 0.98 and v > v0/2.0: v/=1.05 jba.setVoltage(v) acqiris.bifurcationMap() p = acqiris.Psw()[variable] vmin = v return (vmin*0.95,vmax*1.2) try: v0 = jba.voltage() if data == None: sData = Datacube() else: sData = data sData.setName("S curves - %s" % qubit.name()) sData.setParameters(instrumentManager.parameters()) s0 = Datacube("S0") s1 = Datacube("S1") s2 = Datacube("S2") sData.addChild(s0) sData.addChild(s1) sData.addChild(s2) qubit.turnOffDrive() (vmin,vmax) = getVoltageBounds(v0,jba,variable,ntimes) measureSingleS(voltages = arange(vmin,vmax,0.005),data = s0,jba = jba,ntimes = ntimes) qubit.turnOnDrive() loadPi01Pulse(qubit) measureSingleS(voltages = arange(vmin,vmax,0.005),data = s1,jba = jba,ntimes = ntimes) failed12 = False try: loadPi012Pulse(qubit) measureSingleS(voltages = arange(vmin,vmax,0.005),data = s2,jba = jba,ntimes = ntimes) s1.createColumn("contrast20",s2.column(variable)-s0.column(variable)) s1.createColumn("contrast21",s2.column(variable)-s1.column(variable)) qubit.parameters()["readout.v20"] = s1.column("v")[argmax(s1.column("contrast20"))] qubit.parameters()["readout.v21"] = s1.column("v")[argmax(s1.column("contrast21"))] except: failed12 = True raise s1.createColumn("contrast10",s1.column(variable)-s0.column(variable)) qubit.parameters()["readout.v10"] = s1.column("v")[argmax(s1.column("contrast10"))] if optimize == "v20" and not failed12: imax = argmax(s1.column("contrast20")) qubit.parameters()["readout.p11"] = s2.column(variable)[imax] v0 = s1.column("v")[imax] elif optimize == "v21" and not failed12: imax = argmax(s1.column("contrast21")) v0 = s1.column("v")[imax] else: imax = argmax(s1.column("contrast10")) qubit.parameters()["readout.p11"] = s1.column(variable)[imax] v0 = s1.column("v")[imax] #To do: Add dialog to ask to which voltage (v10,v20,v21) in qubit.parameters()["readout.p00"] = 1.0-s0.column(variable)[imax] return (sData,v0) finally: jba.setVoltage(v0) data.savetxt()
def measureSCurves(qubit,jba,variable = "p1x",data = None,ntimes = 20): """ Measures the s curves of the JBA. Assumes that the qubit is alread preset to a pi-pulse. """ def getVoltageBounds(v0,jba,variable,ntimes): v = v0 jba.setVoltage(v) acqiris.bifurcationMap(ntimes = ntimes) p = acqiris.Psw()[variable] while p > 0.03 and v < v0*2.0: v*=1.05 jba.setVoltage(v) acqiris.bifurcationMap() p = acqiris.Psw()[variable] vmax = v v = v0 jba.setVoltage(v) acqiris.bifurcationMap(ntimes = ntimes) p = acqiris.Psw()[variable] while p < 0.98 and v > v0/2.0: v/=1.05 jba.setVoltage(v) acqiris.bifurcationMap() p = acqiris.Psw()[variable] vmin = v return (vmin*0.9,vmax*1.1) try: v0 = jba.voltage() if data == None: sData = Datacube() else: sData = data sData.setName("S curves - %s" % qubit.name()) sData.setParameters(instrumentManager.parameters()) sOff = Datacube("SOFF") sOn = Datacube("SON") sData.addChild(sOff) sData.addChild(sOn) qubit.turnOffDrive() (vmin,vmax) = getVoltageBounds(v0,jba,variable,ntimes) for v in arange(vmin,vmax,0.005): jba.setVoltage(v) acqiris.bifurcationMap(ntimes = ntimes) sOff.set(**(acqiris.Psw())) sOff.set(v = v) sOff.commit() qubit.turnOnDrive() for v in arange(vmin,vmax,0.005): jba.setVoltage(v) acqiris.bifurcationMap(ntimes = ntimes) sOn.set(**acqiris.Psw()) sOn.set(v = v) sOn.commit() sOn.createColumn("contrast",sOn.column(variable)-sOff.column(variable)) v0 = sOn.column("v")[argmax(sOn.column("contrast"))] maxContrast = max(sOn.column("contrast")) return (sData,maxContrast,v0) finally: jba.setVoltage(v0)