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 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 findAnticrossing(voltageRead, voltageWrite, searchRange1, searchRange2, cube=None): if cube == None: cube = Datacube() spectro = Datacube() spectro.setName("Qubit 1 Spectroscopy") cube.addChild(spectro) jba.calibrate() params = getQubitFrequency(mwg, initialRange, variable, spectro)
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 spectroscopy(qubit,frequencies,data = None,ntimes = 20,amplitude = 0.1,variable = "p1x",measureAtReadout = False,delay = 0,f_sb = 0,measure20 = True): if data == None: data = Datacube() if measureAtReadout: data.setName("Spectroscopy at Readout - %s" % qubit.name()) else: data.setName("Spectroscopy - %s" % qubit.name()) measureSpectroscopy(qubit = qubit,frequencies = frequencies,data = data,amplitude = amplitude,measureAtReadout = measureAtReadout,delay = delay,f_sb = f_sb) (params,rsquare) = fitQubitFrequency(data,variable) if measureAtReadout: qubit.parameters()["frequencies.readout.f01"] = params[1] else: qubit.parameters()["frequencies.f01"] = params[1] qubit.setDriveFrequency(params[1]) data.setName(data.name()+ " - f01 = %g GHz" % params[1]) if not measureAtReadout: if measure20: data02 = Datacube("Spectroscopy of (0->2)_2 transition") data.addChild(data02) frequencies02 = arange(params[1]-0.2,params[1]-0.05,0.001) measureSpectroscopy(qubit = qubit,frequencies = frequencies02,data = data02,amplitude = amplitude*10.0,measureAtReadout = measureAtReadout,delay = delay,f_sb = f_sb) (params02,rsquare02) = fitQubitFrequency(data02,variable) qubit.parameters()["frequencies.f02"] = params02[1]*2.0 data.setName(data.name()+" - f02_2 = %g GHz" % params02[1]) data.savetxt() return data
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 spectroscopy(qubit,frequencies,data = None,ntimes = 20,amplitude = 0.1,variable = "p1x",measureAtReadout = False,delay = 0,f_sb = 0,measure20 = True,fitFrequency = True,factor20 = 10.0,delayAtReadout = 1500,saveData = True,pulseLength = 500,gaussian=True): f_drive = qubit.driveFrequency() try: if data == None: data = Datacube() if measureAtReadout: data.setName("Spectroscopy at Readout - %s" % qubit.name()) else: data.setName("Spectroscopy - %s" % qubit.name()) data.parameters()["defaultPlot"]=[["f",variable]] measureSpectroscopy(qubit = qubit,frequencies = frequencies,data = data,amplitude = amplitude,measureAtReadout = measureAtReadout,delay = delay,f_sb = f_sb,delayAtReadout = delayAtReadout,pulseLength = pulseLength,gaussian=gaussian) if fitFrequency: (params,rsquare) = fitQubitFrequency(data,variable) if measureAtReadout: varname01 = "frequencies.readout.f01" else: varname01 = "frequencies.f01" if rsquare > 0.6: print params[1] qubit.parameters()[varname01] = params[1] data.setName(data.name()+ " - f01 = %g GHz" % qubit.parameters()[varname01]) else: print "No peak found..." data.savetxt() return data if measure20: data02 = Datacube("Spectroscopy of (0->2)_2 transition") data.addChild(data02) frequencies02 = arange(params[1]-0.18,params[1]-0.05,0.001) data02.parameters()["defaultPlot"]=[["f",variable]] measureSpectroscopy(qubit = qubit,frequencies = frequencies02,data = data02,amplitude = amplitude*factor20,measureAtReadout = measureAtReadout,delay = delay,f_sb = f_sb,delayAtReadout = delayAtReadout,pulseLength = pulseLength,gaussian=gaussian) (params02,rsquare02) = fitQubitFrequency(data02,variable) if rsquare02 > 0.5 and params[0] > 0.2: if measureAtReadout: varname02 = "frequencies.readout.f02" varname12 = "frequencies.readout.f12" else: varname02 = "frequencies.f02" varname12 = "frequencies.f12" qubit.parameters()[varname02] = params02[1]*2.0 qubit.parameters()[varname12] = params02[1]*2.0-qubit.parameters()[varname01] data.setName(data.name()+" - f02_2 = %g GHz" % (qubit.parameters()[varname02]/2)) if saveData: data.savetxt() return data finally: try: qubit.setDriveFrequency(f_drive) except: pass
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
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 measureSCurve(self,voltages = None,nLoops = 5,microwaveOff = True,data=None,fspPower=False,corelations=False,**extraInDatacube): self.notify("status","Measuring S curve...") def getVoltageBounds(v0,jba,variable,ntimes): return (0.5,5) v = v0 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = nLoops) p = jba._acqiris.Psw()[variable] while p > 0.03 and v < v0*2.0: v*=1.05 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = nLoops) p = jba._acqiris.Psw()[variable] vmax = v v = v0 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = nLoops) p = jba._acqiris.Psw()[variable] while p < 0.98 and v > v0/2.0: v/=1.05 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = nLoops) p = jba._acqiris.Psw()[variable] vmin = v return (vmin*0.95,vmax*1.2) if fspPower: self._pulseGenerator._mixer._fsp.setFrequency(self._frequency) if data==None: data = Datacube("%s S Curve - f=%f" %(self.name(),self._frequency)) dataManager = DataManager() dataManager.addDatacube(data) else: data.setName("%s S Curve - f=%f" %(self.name(),self._frequency)) if voltages==None: bounds=[self.center-self.width*1,self.center+self.width*1] # voltages=linspace(bounds[0],bounds[1],200) voltages=SmartLoop(bounds[0],(bounds[1]-bounds[0])/50, bounds[1], name="Scurve voltages") print "entering in loop" try: for v in voltages: print "voltage :",v self.setAmplitude(v) data.set(v = v) print "measuring" d=self.measure(nLoops=nLoops) print "got point" #d=self.getThisMeasure() #data.set(**d[1]) data.set(**d[-1]) print "in datacube" #data.set(**extraInDatacube) print "extra in datacube" if fspPower: time.sleep(1) data.set(fspPower=self._pulseGenerator._mixer._fsp.getValueAtMarker()) #self.notify("histograms",d[2][self.bit][0]) #self.notify("iqdata",(d[2][self.bit][0],d[2][self.bit][1])) ##self.notify("iqP",(d[0][:,0],d[0][:,1],((0,0,0)))) print "commiting" data.commit() print "commited" #self.notify("sCurve",(data.column("v"),data.column("b%i"%self.bit))) print "first loop over" #data.sortBy('v') #data.sortBy("b%i"%self.bit) #p=data["b%i"%self.bit] #v=data['v'] #p=p[p>0] #v=v[p>0] ##p=p[p<1] #v=v[p<1] #self.sInterpolateVP=scipy.interpolate.interp1d(p,v) #data.sortBy('v') print "first loop over" except: raise finally: data.savetxt() self.notify("status","S curve complete.") self.setAmplitude(self._vMaxAmplitude) return data
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 measureSCurve(self,voltages = None,ntimes = 10,microwaveOff = True,data=None,fspPower=False,corelations=False,**extraInDatacube): self.notify("status","Measuring S curve...") def getVoltageBounds(v0,jba,variable,ntimes): return (0.5,5) v = v0 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = ntimes) p = jba._acqiris.Psw()[variable] while p > 0.03 and v < v0*2.0: v*=1.05 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = ntimes) p = jba._acqiris.Psw()[variable] vmax = v v = v0 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = ntimes) p = jba._acqiris.Psw()[variable] while p < 0.98 and v > v0/2.0: v/=1.05 jba.setVoltage(v) jba._acqiris.bifurcationMap(ntimes = ntimes) p = jba._acqiris.Psw()[variable] vmin = v return (vmin*0.95,vmax*1.2) if fspPower: self._pulseGenerator._mixer._fsp.setFrequency(self._frequency) if data==None: data = Datacube("%s S Curve - f=%f" %(self.name(),self._frequency)) dataManager = DataManager() dataManager.addDatacube(data) else: data.setName("%s S Curve - f=%f" %(self.name(),self._frequency)) if voltages==None: bounds=[self._vMaxAmplitude-2*max(self._vMaxAmplitude/5,abs(self._sCurveParams[0])),self._vMaxAmplitude+2*max(self._vMaxAmplitude/5,abs(self._sCurveParams[0]))] voltages=linspace(bounds[0],bounds[1],200) try: for v in voltages: self.setAmplitude(v) data.set(v = v) d=self.measure(nLoops=ntimes) #d=self.getThisMeasure() data.set(**d[1]) if corelations: data.set(**d[4]) data.set(**extraInDatacube) if fspPower: time.sleep(1) data.set(fspPower=self._pulseGenerator._mixer._fsp.getValueAtMarker()) #self.notify("histograms",d[2][self.bit][0]) #self.notify("iqdata",(d[2][self.bit][0],d[2][self.bit][1])) ##self.notify("iqP",(d[0][:,0],d[0][:,1],((0,0,0)))) data.commit() #self.notify("sCurve",(data.column("v"),data.column("b%i"%self.bit))) data.createColumn("p-0.5",abs(data["b%i"%self.bit]-0.5)) data.sortBy("p-0.5") self._p50fromS=data['v'][0] data.sortBy('v') #data.sortBy("b%i"%self.bit) #p=data["b%i"%self.bit] #v=data['v'] #p=p[p>0] #v=v[p>0] ##p=p[p<1] #v=v[p<1] #self.sInterpolateVP=scipy.interpolate.interp1d(p,v) #data.sortBy('v') except: raise finally: data.savetxt() self.notify("status","S curve complete.") self.setAmplitude(self._vMaxAmplitude) return data
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: f_offset/=2.0 if transition == 12 or use12Pulse:
def parameterSurvey(qubit,jba,values,generator,data = None,ntimes = 20,durations = arange(0,50,2),freqs = list(arange(5.0,6.5,0.002))+list(arange(7.0,8.3,0.002)),autoRange = False,spectroAmp = 0.1,rabiAmp = 1.0,f_sb = -0.1,variable = "p1x",fastMeasure=False,use12Pulse=False): """ Measure the characteristic properties of the qubit (T1, Rabi period, transition frequency, readout contrast) for a list of different parameters. "params" contains a list of parameters, which are iterated over and passed to the function "generator" at each iteration. Example: values = [0.0,1.0,2.0] def generator(x): #Set the amplitude of AFG1 to the given parameter value afg1.setAmplitude(x) """ if data == None: data = Datacube() data.setName("Parameter Survey - %s" % qubit.name()) for v in values: generator(v) try: jba.calibrate() except: continue vData = Datacube("flux = %g V" % v) data.addChild(vData) data.set(flux = v) spectroData = Datacube() vData.addChild(spectroData) #Measure a spectroscopy spectroscopy(qubit = qubit,frequencies = freqs,variable = variable,data = spectroData,ntimes = 20,amplitude = spectroAmp,measureAtReadout = False,measure20=use12Pulse) if qubit.parameters()["frequencies.f01"] == None: data.commit() continue if autoRange: freqs = list(arange(qubit.parameters()["frequencies.f01"]-0.2,qubit.parameters()["frequencies.f01"]+0.2,0.002)) data.set(f01 = qubit.parameters()["frequencies.f01"],f02 = qubit.parameters()["frequencies.f02"]) #Measure a Rabi oscillation rabiData = Datacube() vData.addChild(rabiData) f01 = qubit1.parameters()["frequencies.f01"] f_sb = -0.1-(f01-round(f01,2)) qubit.parameters()["pulses.xy.f_sb"]=float(f_sb) rabi(qubit = qubit,durations = rabiDurations,variable = variable,data = rabiData,amplitude = rabiAmp,f_sb = f_sb,averaging = 20) if qubit.parameters()["pulses.xy.t_pi"] == None: data.commit() continue data.set(t_pi = qubit.parameters()["pulses.xy.t_pi"]) if use12Pulse: #Measure a Rabi 12 oscillation qubit.parameters()["pulses.xy.drive_amplitude"]=rabiAmp rabi12Data = Datacube() vData.addChild(rabi12Data) rabi12(qubit = qubit,durations = rabiDurations,variable = variable,data = rabi12Data,averaging = 20) if qubit.parameters()["pulses.xy.t_pi12"] == None: data.commit() continue data.set(t_pi12 = qubit.parameters()["pulses.xy.t_pi12"]) #Measure S curves sData = Datacube() vData.addChild(sData) sCurves(qubit = qubit,jba = jba,variable = variable,data = sData,optimize = "v10",s2=use12Pulse) data.set(contrast10 = qubit.parameters()["readout.contrast10"]) if not fastMeasure: #Measure T1 t1Data = Datacube() vData.addChild(t1Data) delays = list(arange(0,200,10))+list(arange(200,2000,50)) T1(qubit = qubit,delays = delays,variable = variable,data = t1Data, averaging=20) data.set(T1 = qubit.parameters()["relaxation.t1"]) #Measure T2 ramseyData = Datacube() vData.addChild(ramseyData) durations = arange(0,200,3.0) ramsey(qubit = qubit,durations = durations,variable = variable,data = ramseyData,averaging = 20,amplitude = 0.0,f_offset = 0.03,correctFrequency = False) data.set(T2 = ramseyData.parameters()["ramseyFit"][2]) data.set(Tphi = 1.0/(1.0/ramseyData.parameters()["ramseyFit"][2]-1.0/2./qubit.parameters()["relaxation.t1"])) data.commit() data.savetxt() return data
class IqOptimization(Reloadable): """ Optimizes the parameters of an IQ mixer. """ def __init__(self,mwg,fsp,awg,channels = [1,2]): Reloadable.__init__(self) self._mwg = mwg self._fsp = fsp self._awg = awg self._awgChannels = channels self.initCalibrationData() def initCalibrationData(self): """ Initialize the datacubes that contain the IQ calibration data. """ self._offsetCalibrationData = Datacube() self._offsetCalibrationData.setName("IQ mixer calibration - Offset Calibration Data") self._powerCalibrationData = Datacube() self._powerCalibrationData.setName("IQ mixer calibration - Power Calibration Data") self._sidebandCalibrationData = Datacube() self._sidebandCalibrationData.setName("IQ mixer calibration - Sideband Mixing Calibration Data") def sidebandCalibrationData(self): return self._sidebandCalibrationData def setSidebandCalibrationData(self,data): self._sidebandCalibrationData = data def offsetCalibrationData(self): """ Return the datacube containing the offset calibration data. """ return self._offsetCalibrationData def setOffsetCalibrationData(self,data): self._offsetCalibrationData = data self.updateOffsetCalibrationInterpolation() def updateOffsetCalibrationInterpolation(self): if len(self._offsetCalibrationData.column("frequency"))>1: frequencies = self._offsetCalibrationData.column("frequency") self._iOffsetInterpolation = scipy.interpolate.interp1d(frequencies,self._offsetCalibrationData.column("lowI")) self._qOffsetInterpolation = scipy.interpolate.interp1d(frequencies,self._offsetCalibrationData.column("lowQ")) else: self._iOffsetInterpolation=lambda x:self._offsetCalibrationData.column("lowI")[0] self._qOffsetInterpolation=lambda x:self._offsetCalibrationData.column("lowQ")[0] def powerCalibrationData(self): """ Return the datacube containing the power calibration data. """ return self._powerCalibrationData def setPowerCalibrationData(self,data): self._powerCalibrationData = data def teardown(self): """ Restore the original configuration. """ self._fsp.loadConfig("IQCalibration") self._awg.loadSetup("iq_calibration.awg") self._mwg.restoreState(self._mwgState) def setup(self,averaging = 10,reference = -50): """ Configure the AWG and the FSP for the IQ mixer calibration. """ self._fsp.storeConfig("IQCalibration") self._awg.saveSetup("iq_calibration.awg") self._mwgState = self._mwg.saveState("iq calibration") self._fsp.write("SENSE1:FREQUENCY:SPAN 0 MHz") period = int(1.0/self._awg.repetitionRate()*1e9) self._fsp.write("SWE:TIME 2 ms") self._rbw = 1000 self._fsp.write("SENSE1:BAND:RES %f Hz" % self._rbw) self._fsp.write("SENSE1:BAND:VIDEO AUTO") self._fsp.write("TRIG:SOURCE EXT") self._fsp.write("TRIG:HOLDOFF 0.02 s") self._fsp.write("TRIG:LEVEL 0.5 V") self._fsp.write("TRIG:SLOP POS") self._fsp.write("SENSE1:AVERAGE:COUNT %d" % averaging) self._fsp.write("SENSE1:AVERAGE:STAT1 ON") self._fsp.write("DISP:TRACE1:Y:RLEVEL %f" % reference) self.setupWaveforms() def setupWaveforms(self): self._awg.write("AWGC:RMOD CONT") period = int(1.0/self._awg.repetitionRate()*1e9) print period waveformOffset = zeros((period)) waveformActive = zeros((period))+1.0 waveformPassive = zeros((period))-1.0 self._markers = zeros((period),dtype = uint8) self._markers[1:len(self._markers)/2] = 255 self._awg.createRawWaveform("IQ_Offset_Calibration",waveformOffset,self._markers,"REAL") self._awg.createRawWaveform("IQ_Power_Calibration_active",waveformActive,self._markers,"REAL") self._awg.createRawWaveform("IQ_Power_Calibration_passive",waveformPassive,self._markers,"REAL") length = int(1.0/self._awg.repetitionRate()*1e9) waveform = self.generateSidebandWaveform(f_sb = 0, c = 0,phi = 0,length = length) self._awg.createRawWaveform("IQ_Sideband_Calibration_I",waveform,self._markers,"REAL") self._awg.createRawWaveform("IQ_Sideband_Calibration_Q",waveform,self._markers,"REAL") def loadSidebandWaveforms(self): self._awg.setWaveform(1,"IQ_Sideband_Calibration_I") self._awg.setWaveform(2,"IQ_Sideband_Calibration_Q") self._awg.setWaveform(3,"IQ_Sideband_Calibration_I") self._awg.setWaveform(4,"IQ_Sideband_Calibration_Q") def loadSidebandCalibrationWaveform(self,f_sb = 0,c = 0,phi = 0): length = int(1.0/self._awg.repetitionRate()*1e9) waveform = self.generateSidebandWaveform(f_sb = f_sb, c = c,phi = phi,length = length) self._awg.createRawWaveform("IQ_Sideband_Calibration_I",real(waveform)*0.5,self._markers,"REAL") self._awg.createRawWaveform("IQ_Sideband_Calibration_Q",imag(waveform)*0.5,self._markers,"REAL") return waveform def sidebandParameters(self,f_c,f_sb): if self.sidebandCalibrationData().column("f_c") == None: return (0,0) min_index = argmin(abs(self.sidebandCalibrationData().column("f_c")-f_c)) f_c = self.sidebandCalibrationData()["f_c"][min_index] if min_index == None: return (0,0) calibrationData = self.sidebandCalibrationData().children(f_c = f_c)[0] rows = calibrationData.search(f_sb = f_sb) if rows != []: c = calibrationData.column("c")[rows[0]] phi = calibrationData.column("phi")[rows[0]] else: phiInterpolation = scipy.interpolate.interp1d(calibrationData.column("f_sb"),calibrationData.column("phi")) cInterpolation = scipy.interpolate.interp1d(calibrationData.column("f_sb"),calibrationData.column("c")) c = cInterpolation(f_sb) phi = phiInterpolation(f_sb) return (c,phi) def calibrationParameters(self, f_c, f_sb): (iO,qO)=(self.iOffset(f_c),self.qOffset(f_c)) (c,phi) = self.sidebandParameters(f_c,f_sb) return (iO, qO, c, phi) def generateCalibratedSidebandWaveform(self,f_c,f_sb = 0,length = 100,delay = 0): (c,phi) = self.sidebandParameters(f_c,f_sb) # print "Generating a sideband waveform at f_c = %g GHz at f_sb = %g GHZ, c = %g, phi = %g deg" % (f_c,f_sb,c,phi*180.0/math.pi) return self.generateSidebandWaveform(f_sb,length = length,delay = delay,c = c,phi = phi)*0.8 def generateSidebandWaveform(self,f_sb = 0,c = 0,phi = 0,length = 100,delay = 0,normalize = True): """ Generates a sideband waveform using a sideband frequency "f_sb", an amplitude correction "c" and a phase correction "phi" """ if length == 0: return array([]) waveformIQ = zeros((max(1,length)),dtype = complex128) times = arange(0,length,1) cr = c*exp(1j*phi) waveformIQ = exp(-1.j*f_sb*2.0*math.pi*(times+float(delay)))+cr*exp(1.j*f_sb*2.0*math.pi*(times+float(delay))) return waveformIQ def calibrateIQPower(self,amplitude = 3.0): """ Calibrate the IQ mixer output power. """ try: self.setup(averaging = 100,reference = 0) params = dict() params["power"] = self._mwg.power() params["amplitude"] = amplitude params["channels"] = self._awgChannels params["mwg"] = self._mwg.name() params["awg"] = self._awg.name() params["fsp"] = self._fsp.name() self.powerCalibrationData().setParameters(params) freqs = self.offsetCalibrationData().column("frequency") Is = self.offsetCalibrationData().column("lowI") Qs = self.offsetCalibrationData().column("lowQ") for i in range(0,len(freqs)): f = freqs[i] amp = max(0,min(4.5,4.5-2.0*max(Is[i],Qs[i]))) self._mwg.setFrequency(f) self._awg.setLow(self._awgChannels[0],Is[i]) self._awg.setLow(self._awgChannels[1],Qs[i]) self._awg.setHigh(self._awgChannels[0],Is[i]+ amp) self._awg.setHigh(self._awgChannels[1],Qs[i]+amp) self._fsp.write("SENSE1:FREQUENCY:CENTER %f GHZ" % f) for channels in [[self._awgChannels[0],self._awgChannels[1],"I"],[self._awgChannels[1],self._awgChannels[0],"Q"]]: name = channels[2] self._awg.setWaveform(channels[0],"IQ_Power_Calibration_passive") self._awg.setWaveform(channels[1],"IQ_Power_Calibration_passive") time.sleep(0.5) trace = self._fsp.getSingleTrace() zero = mean(trace[1]) self._awg.setWaveform(channels[0],"IQ_Power_Calibration_active") time.sleep(0.5) trace = self._fsp.getSingleTrace() level = mean(trace[1]) diff = level - zero #This is the linear output coefficient: coefficient =(pow(10.0,level/10.0)-pow(10.0,zero/10.0))/pow(amp,2.0) self._powerCalibrationData.set(frequency = f) params = {"power"+name : sqrt(exp(log(10.0)*diff/10.0)),"powerDBM"+name : diff, "zero"+name : zero,"level"+name : level,"coeff"+name : coefficient} self._powerCalibrationData.set(**params) self._powerCalibrationData.commit() finally: self.teardown() def calibrateIQOffset(self,frequencyRange = None): """ Calibrate the IQ mixer DC offset. """ if frequencyRange==None: frequencyRange=[self._mwg.frequency()] try: self.setup() params = dict() params["power"] = self._mwg.power() params["channels"] = self._awgChannels params["mwg"] = self._mwg.name() params["awg"] = self._awg.name() params["fsp"] = self._fsp.name() self.offsetCalibrationData().setParameters(params) self._mwg.turnOn() for channel in [1,2,3,4]: self._awg.setWaveform(channel,"IQ_Offset_Calibration") for frequency in frequencyRange: self._mwg.setFrequency(frequency) (voltages,minimum) = self.optimizeIQMixerPowell() minimum = self.measurePower(voltages) print "Optimum value of %g dBm at offset %g V, %g V" % (minimum,voltages[0],voltages[1]) rows = self._offsetCalibrationData.search(frequency = frequency) if rows != []: self._offsetCalibrationData.removeRows(rows) self._offsetCalibrationData.set(frequency = frequency,lowI = voltages[0],lowQ = voltages[1],minimum = minimum) self._offsetCalibrationData.commit() self._offsetCalibrationData.sortBy("frequency") self._offsetCalibrationData.savetxt() except StopThread: pass except: traceback.print_exc() finally: self.teardown() self.updateOffsetCalibrationInterpolation() return self._offsetCalibrationData.filename() def calibrateSidebandMixing(self,frequencyRange = None,sidebandRange = arange(-0.5,0.51,0.1)): """ Calibrate the IQ mixer sideband generation. """ if frequencyRange==None: frequencyRange=[self._mwg.frequency()] try: self.setup() params = dict() params["power"] = self._mwg.power() params["channels"] = self._awgChannels params["mwg"] = self._mwg.name() params["awg"] = self._awg.name() params["fsp"] = self._fsp.name() self.sidebandCalibrationData().setParameters(params) self._mwg.turnOn() channels = self._awgChannels self.loadSidebandWaveforms() for f_c in frequencyRange: #We round the center frequency to an accuracy of 1 MHz f_c = round(f_c,3) self._mwg.setFrequency(f_c) self._awg.setAmplitude(channels[0],4.5) self._awg.setAmplitude(channels[1],4.5) self._awg.setOffset(channels[0],self.iOffset(f_c)) self._awg.setOffset(channels[1],self.qOffset(f_c)) data = Datacube("f_c = %g GHz" % f_c) rowsToDelete = [] try: for i in range(0,len(self._sidebandCalibrationData.column("f_c"))): if abs(self._sidebandCalibrationData.column("f_c")[i]-f_c) < 0.1: rowsToDelete.append(i) except: pass self._sidebandCalibrationData.removeRows(rowsToDelete) self._sidebandCalibrationData.addChild(data, f_c=f_c) self._sidebandCalibrationData.set(f_c = f_c) self._sidebandCalibrationData.commit() for f_sb in sidebandRange: print "f_c = %g GHz, f_sb = %g GHz" % (f_c,f_sb) self._fsp.write("SENSE1:FREQUENCY:CENTER %f GHZ" % (f_c+f_sb)) result = scipy.optimize.fmin_powell(lambda x,*args: self.measureSidebandPower(x,*args),[0,0],args = [f_sb],full_output = 1,xtol = 0.00001,ftol = 1e-4,maxiter = 2) params = result[0] value = result[1] print "f_c = %g GHz, f_sb = %g GHz, c = %g, phi = %g rad" % (f_c,f_sb,params[0],params[1]) self.loadSidebandCalibrationWaveform(f_sb = f_sb,c = params[0],phi = params[1]) for i in [-3,-2,-1,0,1,2,3]: self._fsp.write("SENSE1:FREQUENCY:CENTER %f GHZ" % (f_c+f_sb*i)) if i < 0: suppl = "m" else: suppl = "" data.set(**{"p_sb%s%d" % (suppl,abs(i)) : self.measureAveragePower()}) data.set(f_c = f_c,f_sb = f_sb,c = params[0],phi = params[1]) data.commit() self._sidebandCalibrationData.sortBy("f_c") self._sidebandCalibrationData.savetxt() finally: self.teardown() return self._sidebandCalibrationData.filename() def iOffset(self,f): return self._iOffsetInterpolation(f) def qOffset(self,f): return self._qOffsetInterpolation(f) def setDriveFrequency(self,f): self._mwg.setFrequency(f) self._awg.setOffset(self._awgChannels[0],self.iOffset(f)) self._awg.setOffset(self._awgChannels[1],self.qOffset(f)) def optimizeIQMixerPowell(self): """ Use Powell's biconjugate gradient method to minimize the power leak in the IQ mixer. """ f = self._mwg.frequency() self._mwg.turnOn() self._fsp.write("SENSE1:FREQUENCY:CENTER %f GHZ" % f) result = scipy.optimize.fmin_powell(lambda x: self.measurePower(x),[0.,0.],full_output = 1,xtol = 0.0001,ftol = 1e-2,maxiter =500,maxfun =1000, disp=True, retall=True) return (result[0],result) def measureSidebandPower(self,x,f_sb): c = x[0] if c > 0.5 or c < -0.5: return 100 phi = fmod(x[1],math.pi*2) self.loadSidebandCalibrationWaveform(f_sb = f_sb,c = c,phi = phi) power = self.measureAveragePower() print "Sideband power at f_sb = %g GHz,c = %g, phi = %g : %g dBm" % (f_sb,c,phi,power) return power def measureAveragePower(self): trace = self._fsp.getSingleTrace() if trace == None: return 0 minimum = mean(trace[1]) return minimum def measurePower(self,lows): """ Measure the leaking power of the IQ mixer at a given point. Used by optimizeIQMixerPowell. """ for i in [0,1]: if math.fabs(lows[i]) > 2.0: return 100.0 self._awg.setOffset(self._awgChannels[i],lows[i]) minimum = self.measureAveragePower() print "Measuring power at %g,%g : %g" % (lows[0],lows[1],minimum) linpower = math.pow(10.0,minimum/10.0)/10.0 return minimum
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)
def sCurves(jba,qubit = None,variable = "p1x",data = None,ntimes = 20,s2=False,optimize = "v10",step = 0.01,measureErrors = False,saveData = True,voltageBounds = None,**kwargs): """ 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.1 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.1 jba.setVoltage(v) acqiris.bifurcationMap() p = acqiris.Psw()[variable] vmin = v return (vmin*0.95,vmax*1.1) hasFinished = False try: data.setParameters(instrumentManager.parameters()) v0 = jba.voltage() if data == None: sData = Datacube() else: sData = data if sData.name() == "datacube": if not qubit == None: sData.setName("S curves - %s" % qubit.name()) s0 = Datacube("S0") s1 = Datacube("S1") sData.addChild(s0) sData.addChild(s1) s0.parameters()["defaultPlot"]=[["v",variable]] s1.parameters()["defaultPlot"]=[["v",variable]] s1.parameters()["defaultPlot"].append(["v","contrast10"]) else: sData.setName("S curve - %s" % jba.name()) sData.parameters()["defaultPlot"]=[["v",variable]] error=False if not qubit == None: qubit.turnOnDrive() qubit.loadRabiPulse(length = 0) if voltageBounds == None: (vmin,vmax) = getVoltageBounds(v0,jba,variable,ntimes) else: (vmin,vmax) = voltageBound print vmin,vmax if qubit == None: measureSingleS(voltages = arange(vmin,vmax,step),data = sData,jba = jba,ntimes = ntimes) return else: measureSingleS(voltages = arange(vmin,vmax,step),data = s0,jba = jba,ntimes = ntimes) qubit.loadRabiPulse(phase = math.pi,**kwargs) measureSingleS(voltages = arange(vmin,vmax,step),data = s1,jba = jba,ntimes = ntimes) failed12 = False if s2: try: s2 = Datacube("S2") s2.parameters()["defaultPlot"]=[["v",variable]] sData.addChild(s2) loadPi012Pulse(qubit) measureSingleS(voltages = arange(vmin,vmax,step),data = s2,jba = jba,ntimes = ntimes) s1.createColumn("contrast20",s2.column(variable)-s0.column(variable)) s1.createColumn("contrast21",s2.column(variable)-s1.column(variable)) s1.parameters()["defaultPlot"].extend([["v","contrast20"],["v","contrast21"]]) qubit.parameters()["readout.v20"] = float(s1.column("v")[argmax(s1.column("contrast20"))]) qubit.parameters()["readout.v21"] = float(s1.column("v")[argmax(s1.column("contrast21"))]) qubit.parameters()["readout.contrast20"] = float(s1.column("contrast20")[argmax(s1.column("contrast20"))]) qubit.parameters()["readout.contrast21"] = float(s1.column("contrast21")[argmax(s1.column("contrast21"))]) data.setName(data.name()+" - v20 = %g" % qubit.parameters()["readout.contrast20"]) data.setName(data.name()+" - v21 = %g" % qubit.parameters()["readout.contrast21"]) except: failed12 = True raise else: failed12=True s1.createColumn("contrast10",s1.column(variable)-s0.column(variable)) s1.parameters()["defaultPlot"].append(["v",variable]) qubit.parameters()["readout.v10"] = float(s1.column("v")[argmax(s1.column("contrast10"))]) qubit.parameters()["readout.contrast10"] = float(s1.column("contrast10")[argmax(s1.column("contrast10"))]) data.setName(data.name()+" - v10 = %g" % qubit.parameters()["readout.contrast10"]) if optimize == "v21" or optimize == 'v20': qubit.parameters()["readout.use12"] = True else: qubit.parameters()["readout.use12"] = False if optimize == "v20" and not failed12: imax = argmax(s1.column("contrast20")) 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")) v0 = s1.column("v")[imax] hasFinished = True return (sData,v0) finally: jba.setVoltage(v0) if hasFinished: if optimize == 'v20': loadPi012Pulse(qubit) else: qubit.loadRabiPulse(phase = math.pi) if measureErrors: qubit.turnOnDrive() qubit.loadRabiPulse(phase=0) acqiris.bifurcationMap(ntimes = 1000) qubit.parameters()["readout.p00"] = float(1.0-acqiris.Psw()[variable]) if optimize == 'v10': qubit.loadRabiPulse(phase=math.pi) else: loadPi012Pulse(qubit) acqiris.bifurcationMap(ntimes = 1000) qubit.parameters()["readout.p11"] = float(acqiris.Psw()[variable]) if saveData: data.savetxt()
class Instr(Instrument): def saveState(self,name): d=dict() d['frequencies']=self._frequencies return d def restoreState(self,state): self._frequencies=state['frequencies'] def addFrequency(self, f,name, useCorrection=False,bit=0): """ Add a new frequency to the analyser """ self._frequencies[name]=[f,True,bit] return True def startAnalyseFrequency(self,name): self._frequencies[name][1]=True def stopAnalyseFrequency(self,name): self._frequencies[name][1]=False def measureAll(self): return self._acqiris.frequenciesAnalyse(frequencies=self._frequencies.values) def analyse(self,nLoops=1,fast=False): """ Acquire and analyse the frequencies previously sent and returns (components and probabilities) """ maxBit=0 for v in self._frequencies.values(): if v[2]>maxBit and v[1]: maxBit=v[2] return self._acqiris.frequenciesAnalyse(frequencies=self._frequencies.values(),nLoops=nLoops,maxBit=maxBit,fast=fast) def measureBifurcationProbabilities(self): """ Acquire, analyse the frequencies, convert it in clicks, and calculate averages values """ (av,co,fr)=self.analyse() r=self._acqiris.multiplexedBifurcationMapAdd(co,fr) p=self._acqiris.convertToProbabilities(r) def clear(self): """ Clear the list of frequencies to be analysed and the calibration paramaters associated """ self._Ilist=[] self._Qlist=[] self._philist=[] self._frequencies=dict() def calibrateAmplitudeAndOffset(self,f): """ Only used when this pulse Analyser has to be used as real analyser, not when using it to see bifurcation """ rowData=Datacube() for phi in arange(0,2*math.pi,math.pi/30): print "calibration : phi = %f deg" % (phi/math.pi*180) self._pulseGenerator.clearPulse() self.clear() self._pulseGenerator.generatePulse(duration=20000, frequency=f, amplitude=0.6, DelayFromZero=0,useCalibration=True, phase=phi) self.addFrequency(f=f,useCorrection=False) self._pulseGenerator.sendPulse() time.sleep(0.5) (av, co, fr)= self.analyse() rowData.set(I=av[0,0], Q=av[1,0],phi=phi) rowData.commit() #I0=2/ptp(rowData['I']) #Q0=2/ptp(rowData['Q']) (I,Q,phi,dphi)=scipy.optimize.fmin_powell(lambda (I,Q,phi0,dphi): sum((I*rowData['I'] - sin(rowData['phi']+phi0+dphi))**2)+sum((Q*rowData['Q'] - cos(rowData['phi']+phi0))**2),(1,1,0,0)) print (I,Q,phi,dphi) f_c=self._MWSource.frequency() df=f-f_c index=self._calibration.search(f_sb=df,f_c=f_c) if index!=None: self._calibration.removeRow(index) self._calibration.set(I=I,Q=Q,phi=dphi,f_c=f_c,f_sb=df) self._calibration.commit() self._calibration.savetxt() register['%s Cal'% self._name]=self._calibration.filename() return rowData def parameters(self): """ Returns intrument parameters """ return self._params def initCal(self): """ Re-init the calibration when using this instrument as real analyser """ self._calibration=Datacube() self._calibration.setName('analyser IQ mixer Calibration') self._calibration.savetxt() register['%s Cal'% self._name]=self._name.filename() def initialize(self, name, acqiris, acqirisChannels, MWSource,pulse_generator): """ Initialize the instrument """ instrumentManager=Manager() self._name=name self._acqiris=instrumentManager.getInstrument(acqiris) # self._acqiris("moduleDLL2.setChannels("+str(acqirisChannels[0])+","+str(acqirisChannels[1])+")") self._acqiris.setChannels(acqirisChannels[0],acqirisChannels[1]) self._MWSource=instrumentManager.getInstrument(MWSource) self._pulseGenerator=instrumentManager.getInstrument(pulse_generator) self._params=dict() self._params["acqiris"]=acqiris self._params["MWSource"]=MWSource self._frequencies=dict() try: self._calibration=Datacube() self._calibration.setName('analyser IQ mixer Calibration') self._calibration.loadtxt(register.parameters()['%s Cal'% self._name]) except: pass self._Ilist=[] self._Qlist=[] self._philist=[]
class Instr(Instrument): def addFrequency(self, f,useCorrection=False): """ Add a new frequency to the analyser """ f_c=self._MWSource.frequency() df=f-f_c toReturn=True if useCorrection: if self._calibration.search(f_sb=df,f_c=f_c)==['']: print 'Point not calibrated, calibration in progress.... (NOOOOO !! need to find a switch to calibrate ...)' # self.calibrateAmplitudeAndOffset(f=f) print 'calibration over' toReturn=False index=self._calibration.search(f_sb=df,f_c=f_c) I=self._calibration['I'][index] Q=self._calibration['Q'][index] phi=self._calibration['phi'][index] else: I=1 Q=1 phi=0. self._frequencies=append(self._frequencies,abs(df)) self._Ilist=append(self._Ilist,I) self._Qlist=append(self._Qlist,Q) self._philist=append(self._philist,phi) return toReturn def analyse(self): """ Acquire and analyse the frequencies previously sent and returns (waveforms, components, and frequencies analysed) """ (wa,av,co,fr)=self._acqiris.frequenciesAnalysis(frequencies=self._frequencies, Ilist=self._Ilist, Qlist=self._Qlist, philist=self._philist) return (av, co, fr) def measureBifurcationProbabilities(self): """ Acquire, analyse the frequencies, convert it in clicks, and calculate averages values """ (av,co,fr)=self.analyse() r=self._acqiris.multiplexedBifurcationMapAdd(co,fr) p=self._acqiris.convertToProbabilities(r) def clear(self): """ Clear the list of frequencies to be analysed and the calibration paramaters associated """ self._Ilist=[] self._Qlist=[] self._philist=[] self._frequencies=[] def calibrateAmplitudeAndOffset(self,f): """ Only used when this pulse Analyser has to be used as real analyser, not when using it to see bifurcation """ rowData=Datacube() for phi in arange(0,2*math.pi,math.pi/30): print "calibration : phi = %f deg" % (phi/math.pi*180) self._pulse_generator.clearPulse() self.clear() self._pulse_generator.generatePulse(duration=20000, frequency=f, amplitude=0.6, DelayFromZero=0,useCalibration=True, phase=phi) self.addFrequency(f=f,useCorrection=False) self._pulse_generator.sendPulse() time.sleep(0.5) (av, co, fr)= self.analyse() rowData.set(I=av[0,0], Q=av[1,0],phi=phi) rowData.commit() #I0=2/ptp(rowData['I']) #Q0=2/ptp(rowData['Q']) (I,Q,phi,dphi)=scipy.optimize.fmin_powell(lambda (I,Q,phi0,dphi): sum((I*rowData['I'] - sin(rowData['phi']+phi0+dphi))**2)+sum((Q*rowData['Q'] - cos(rowData['phi']+phi0))**2),(1,1,0,0)) print (I,Q,phi,dphi) f_c=self._MWSource.frequency() df=f-f_c index=self._calibration.search(f_sb=df,f_c=f_c) if index!=None: self._calibration.removeRow(index) self._calibration.set(I=I,Q=Q,phi=dphi,f_c=f_c,f_sb=df) self._calibration.commit() self._calibration.savetxt() register['%s Cal'% self._name]=self._calibration.filename() return rowData def parameters(self): """ Returns intrument parameters """ return self._params def initCal(self): """ Re-init the calibration when using this instrument as real analyser """ self._calibration=Datacube() self._calibration.setName('analyser IQ mixer Calibration') self._calibration.savetxt() register['%s Cal'% self._name]=self._name.filename() def initialize(self, name, acqiris, MWSource,pulse_generator): """ Initialize the instrument """ instrumentManager=Manager() self._name=name self._acqiris=instrumentManager.getInstrument(acqiris) self._MWSource=instrumentManager.getInstrument(MWSource) self._pulse_generator=instrumentManager.getInstrument(pulse_generator) self._params=dict() self._params["acqiris"]=acqiris self._params["MWSource"]=MWSource self._frequencies=zeros(0) try: self._calibration=Datacube() self._calibration.setName('analyser IQ mixer Calibration') self._calibration.loadtxt(register.parameters()['%s Cal'% self._name]) except: pass self._Ilist=[] self._Qlist=[] self._philist=[]