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 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 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 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 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 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 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,durations,data=None,rabiParameters=None, dataParameters=None):
"""
Measure a rabi, will use what is in dictionnary if power/frequency/useCalibration/nLoops are not set
Fit and save the period in the Qubit dictionnary under piRabiTime
Return the datacube and rabiPeriod
"""
if dataParameters==None:
dataParameters=dict()
dataParameters['addToDataManager']=True
dataParameters['save']=True
if rabiParameters==None:
if self._params.has_key('rabiParameters'):
rabiParameters=self._params['rabiParameters']
else: raise Exception("Unable to find rabi parameters... Exiting... ")
useCalibration=rabiParameters['useCalibration']
frequency=rabiParameters['frequency']
if frequency=="f01":frequency=self.frequency01()
power=rabiParameters['power']
nLoops=rabiParameters['nLoops']
if rabiParameters.has_key('remember'):
if rabiParameters['remember']: self._params['rabiParameters']=rabiParameters
if self._params.has_key('offsetDelay'):
offsetDelay=self._params['offsetDelay']
else: offsetDelay=20
if data==None:
data=Datacube("Rabi %s dBm"%power)
if dataParameters['addToDataManager']:data.toDataManager()
if power !="stay":self._pulseGenerator._MWSource.setPower(power)
self._pulseGenerator._MWSource.turnOn()
for duration in durations:
self.clearPulses()
self.generateRabiPulse(duration=duration, frequency=frequency, offsetDelay=offsetDelay,useCalibration=rabiParameters['useCalibration'])
result=self._jba.measure(nLoops=nLoops,fast=True)[0]
data.set(**result)
data.set(duration=duration)
data.commit()
#Fit
try:
columnName="b%i"%self._jba.bit
period= estimatePeriod(data['duration'],data[columnName])
[y0,dy,piRabi,t10],yfit=fitRabi(data['duration'],data[columnName],period=period)
data.createColumn("%sfit"%columnName,yfit)
except:
print 'fit error'
piRabi=0
if dataParameters['save']:data.savetxt()
self._params['piRabiTime']=piRabi
return data,piRabi
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,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 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 = 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 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 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 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
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
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=[]
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
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"]
i+=1
m = m [::-1]
figure(10)
clf()
hsv()
imshow(m,aspect = 'auto',interpolation = 'bilinear',extent = (curves.attributesOfChild(curves.children()[0])["lq"],curves.attributesOfChild(curves.children()[-1])["lq"],child["freq"][0],child["freq"][-1]))
ticklabel_format(style = 'plain',axis = 'y',useOffset = False)
if rsquare > 0.5:
qubit.parameters()["pulses.ramsey.t_pi"] = params[1]/2.0
data.setName(data.name()+" - f_r = %g MHz - T_2 = %g ns" % ((1.0/params[1])*1000,params[2]))
data.parameters()["ramseyFit"] = params
f_correct = 1.0/params[1]-abs(f_offset)
if correctFrequency and amplitude == 0 and f_correct < 0.05:
print "Correcting qubit frequency by %g MHz" % (f_correct*1000)
if 01 == transition or 02 == transition:
qubit.parameters()["frequencies.f01"]-=f_correct
elif 12 == transition:
qubit.parameters()["frequencies.f12"]-=f_correct
else:
print "Ramsey fit is not good, resetting parameters..."
qubit.parameters()["pulses.ramsey.t_pi"] = None
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:
def measureSpectroscopy(self,frequencies, data=None, spectroscopyParameters=None,dataParameters=None):
"""
Measure a spectroscopy
Fit
Return the datacube and centerFrequency
"""
if spectroscopyParameters==None:
if self._params.has_key(spectroscopyParameters):
spectroscopyParameters=self._params['spectroscopyParameters']
else:
raise Exception("No spectroscopy parameters found... Exiting...")
if dataParameters==None:
dataParameters=dict()
dataParameters['addToDataManager']=True
dataParameters['save']=True
if spectroscopyParameters.has_key('remember'):self._params['spectroscopyParameters']=spectroscopyParameters
useCalibration=spectroscopyParameters['useCalibration']
nLoops=spectroscopyParameters['nLoops']
duration=spectroscopyParameters['duration']
if spectroscopyParameters.has_key('power'): self._pulseGenerator._MWSource.setPower(spectroscopyParameters['power'])
amplitude = spectroscopyParameters['amplitude'] if spectroscopyParameters.has_key('amplitude') else 0
if data==None:
data=Datacube("Spectroscopy measurement")
if dataParameters['addToDataManager']:data.toDataManager()
if self._params.has_key('offsetDelay'):
offsetDelay=self._params['offsetDelay']
else: offsetDelay=20
first=True
for frequency in frequencies:
self._pulseGenerator._MWSource.setFrequency(frequency)
if first: # i.e. generate a rabi pulse on the AWG only the first time (no need to re-generate an AWG pulse every time)
self._pulseGenerator.pulseList=()
self.generateRabiPulse(duration=duration,amplitude=amplitude,offsetDelay=offsetDelay,useCalibration=useCalibration,frequency=frequency)
first=False
time.sleep(0.2)
data.set(frequency=frequency)
data.set(**self._jba.measure(nLoops=nLoops,fast=True)[0])
data.commit()
try:
columnName="b%i"%self._jba.bit
[dy,f0,df,y0],yfit=fitLorentzian(data['frequency'],data[columnName],1)
data.createColumn(columnName+"fit",yfit)
except:
print "fitting error"
[dy,f0,df,y0]=[0]*4
if dataParameters['save']:data.savetxt()
d0.setParameters(Manager().saveState('currentState'))
return data, f0
