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 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 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 caractiseQubit(self,data=None,frequencies=[8.5,9.5]):
if data==None:
data=Datacube('caracterisation %s'%self.name())
dataManager.addDatacube(data)
acqiris.setNLoops(1)
self._jba.calibrate(bounds=[2,3,25])
acqiris.setNLoops(10)
spectro=Datacube('spectro')
data.addChild(spectro)
self.measureSpectroscopy(fstart=frequencies[0],fstop=frequencies[1],fstep=0.002,power=-27.,data=spectro)
data.set(f01=self._f01)
rabi=Datacube('rabi')
data.addChild(rabi)
self.measureRabi(tstart=0,tstop=60,tstep=2.,data=rabi)
data.set(rabiPi=self._rabiDuration)
scurves=Datacube('sCurves')
data.addChild(scurves)
self.measureSCurves(data=scurves,ntimes=10)
t1=Datacube('t1')
data.addChild(t1)
self.measureT1(tstart=0,tstop=500,tstep=4,data=t1)
data.set(t1=self._t1)
frequencies=[self._f01-0.25,self._f01+0.05]
data.commit()
data.savetxt()
def measureSCurves(self,ntimes=None,data=None):
if data==None:
if name==None:name='sCurves %s'%self.name()
data=Datacube(name)
dataManager.addDatacube(data)
self._pulseGenerator._MWSource.setPower(self._rabiPower)
self._pulseGenerator._MWSource.setFrequency(self._f01)
self._pulseGenerator.generatePulse(duration=self._rabiDuration,frequency=self._f01,DelayFromZero=register['repetitionPeriod']/2-self._rabiDuration-10,useCalibration=False)
self._pulseGenerator.sendPulse()
off=Datacube('sOff')
data.addChild(off)
self._pulseGenerator._MWSource.turnOff()
self._jba.measureSCurve(data=off,ntimes=10)
on=Datacube('sOn')
data.addChild(on)
self._pulseGenerator._MWSource.turnOn()
self._jba.measureSCurve(data=on,ntimes=10)
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 caracteriseIQvsFvsP(self,frequencies,voltages,data=None):
if data==None:
data=Datacube("JBA mapping")
dataManager.addDatacube(data)
try:
previousShape=self.shape
self.shape=zeros((20000),dtype = numpy.complex128)
self.shape[10000:10010]=linspace(0,1,10)
self.shape[10010:12100]=1
self.shape[12100:12110]=linspace(1,0,10)
# return self.shape
import scipy
pvsv=Datacube("power")
data.addChild(pvsv)
for v in voltages:
self.setAmplitude(amplitude=v)
p=self.measureJBAPower(f='autodetect')
pvsv.set(v=v,bluePower=p)
pvsv.commit()
pv=scipy.interpolate.interp1d(pvsv.column("v"),pvsv.column("bluePower"))
data.savetxt()
for f in frequencies:
child=Datacube("f=%f"%f)
data.addChild(child)
self.setFrequency(f)
for v in voltages:
self.setAmplitude(amplitude=v)
time.sleep(0.5)
co=self.getThisMeasure()[1]
var=cov(co[0])+cov(co[1])
if var>0.01:
cod=Datacube("components at p=%f" %pv(v))
cod.createColumn('I',co[0])
cod.createColumn('Q',co[1])
cod.createColumn('bluePower',[pv(v)]*len(co[0]))
child.addChild(cod)
else:
####### ECRIRE QUELQUE CHOSE ICI
[I,Q]=[mean(co[0]),mean(co[1])]
child.set(f=f,v=v,I=I,Q=Q,sigma=var,bluePower=pv(v))
child.set(M=sqrt(I**2+Q**2))
child.set(phi=math.atan2(I,Q))
child.commit()
data.set(f=f,v=v,I=I,Q=Q,sigma=var,bluePower=pv(v))
data.set(M=sqrt(I**2+Q**2))
data.set(phi=math.atan2(I,Q))
data.commit()
data.savetxt()
except:
raise
finally:
data.savetxt()
self.shape=previousShape
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()
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()
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
dataManager.addDatacube(curves)
i = 0
curve = None
while i < len(lines):
elements = lines[i].split(",")
if re.search("l1=(\d+\.\d+)",lines[i],re.I):
if curve != None and len(curve) == 0:
curves.removeChild(curve)
print lines[i]
lq = float(re.search("l1=(\d+\.\d+)",lines[i],re.I).group(1))
print lq
i+=2
if i >= len(lines):
break
curve = Datacube("l1 = %g nH" % lq)
curves.addChild(curve,lq = lq)
curve.parameters()["defaultPlot"] = [("freq","mag")]
elif len(elements) == 2:
(freq,mag) = map(lambda x:float(x),lines[i].split(","))
curve.set(freq = freq,mag = mag)
curve.commit()
i+=1
curves.savetxt("sonnet_model")
##
import os
from numpy import *
m = zeros((len(curves.children()[0]),len(curves.children())))
i = 0
for child in curves.children():
print mean(child["mag"]),max(child["mag"])
m[:,i] = child["mag"]
def methods(self,instrument,methodNames):
return [getattr(instrument,methodName for methodName in methodNames]
def methodsFromAliases(self,localInstrumentName,methodAliases):
instr,methodsDict=self._subInstruments[localInstrumentName]
return self.methods(instr,[methodsDict[methodAlias] for methodAlias in methodAliases])
def checkAliasedMethodsExist(self,localInstrumentName,methodAliases=None):
if methodAliases==None: methodAliases=self._subInstruments[localInstrumentName][1].keys()
methods= self.methodsFromAliases(localInstrumentName,methodAliases)
indices = [i for i, x in enumerate(methods) if x == None]
if len(indices)!=O:
raise NameError('methods '+str([methodAliases[i] for i in indices])+' do not seem to exist')
def setBiasGen(self,instr,setBiasFuncName='setVoltage',getBiasFuncName='voltage'):
if instr!=None:
if isinstance(instr,str):
inst=getInstrument(instr)
else:
inst=instr
methods={'setBias':setBiasFuncName,'getBias':getBiasFuncName}
self._subInstruments['biasGen']=(inst,methods)
self.checkAliasedMethodsExist('biasGen')
def setPumpGen(self,instr,setFreqFuncName='setFrequency',getFreqFuncName='frequency',setPowFuncName='setPower',getPowFuncName='power'):
if instr!=None:
if isinstance(instr,str):
inst=getInstrument(pumpGen)
else:
inst=instr
methods={'setFreq':setFreqFuncName,'getFreq':getFreqFuncNam,'setPow':setPowFuncName,'getPow':getPowFuncName}
self._subInstruments['pumpGen']=(inst,methods)
self.checkAliasedMethodsExist('pumpGen')
def setTestVna(self,instr,\
setFreqFuncName='setCenterInGhz',getFreqFuncName='getCenterInGhz',\
setSpanFuncName='setSpanInGhz',getSpanFuncName='setSpanInGhz',\
setPowFuncName='setTotalPower',getPowFuncName='getTotalPower',\
getSpectrumFuncName='getFreqMagPhase',check=True\
):
if instr!=None:
if isinstance(instr,str):
inst=getInstrument(pumpGen)
else:
inst=instr
methods={'setFreq':setFreqFuncName,'getFreq':getSpanFuncNam,'setSpan':setSpanFuncName,'getSpan':getSpanFuncName,\
'setPow':setPowFuncName,'getPow':getPowFuncName,'getSpectrum':getSpectrumFuncName}
self._subInstruments['testVNA']=(inst,methods)
self.checkAliasedMethodsExist('testVNA')
def adaptFunc1(self,adaptiveLoop,deltafMax=span/10.,deltafMin=span/20.,stepMin=0.1,stepMax=1.):
fbValues=adaptiveLoop.feedBackValues()
if len(fbValues)>=2:
step=adaptiveLoop.getStep()
dir=1.0;
if step<0:
dir=-1.0
deltaF=abs(fbValues[-1]-fbValues[-2])
newStep=step
if deltaF > deltafMax:
newStep=max(abs(step/2.),stepMin)*dir
adaptiveLoop.setStep(newStep)
elif deltaF < deltafMin:
newStep=min(abs(step*2),stepMax)*dir
adaptiveLoop.setStep(newStep)
def calibrateFreq(self,biasStart=None,biasStop=None,biasStep=1,centerStart=None,span=None,):
if self._subInstruments['testVNA'].has_Key('biasGen')
setBias,getBias=self.methodsFromAliases('biasGen',['setBias','getBias'])
[setFreq,getFreq,setSpan,getSpan,setPow,getPow,getSpectrum]=self.methodsFromAliases('testVna',['setFreq','getFreq','setSpan','getSpan','setPow','getPow','getSpectrum'])
if biasStart!=None : setFreq(biasStart)
else :biasStart=getFreq()
if biasStop==None : biasStop=biasStart+10*biasStep
if centerStart!=None : setFreq(centerStart)
if span!=None : setSpan(span)
data=Datacube('parampFreqVsBias')
data.toDataManager()
xLoop=AdaptiveLoop(biasStart,step=biasStep,stop=biasStop,name=parampFreqVsBias,adaptFunc=self.adaptFunc1)
setFreq(fCenter)
for x in xLoop:
print "Bias= ", x
setBias(x,slewRate=0.5)
child1=getSpectrum(waitFullSweep = True)
child1.setName('bias'+str(x))
data.addChild(child1)
#Fit phase and determine center frequency f here
xLoop.newFeedbackValue(f)
data.set(bias=x,freq=f,commit=True,columnOrder=['bias','freq','peakdB'])
