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