def clicks(self):
"""
Returns a datacube that contains the individual detector clicks for all measured samples in binary form.
"""
clicks = Datacube("detector clicks",dtype = uint8)
angles = self.bifurcationMapRotation()
clicks1 = self.trends()[0]*cos(angles[0])+self.trends()[1]*sin(angles[0]) > 0
clicks2 = self.trends()[2]*cos(angles[1])+self.trends()[3]*sin(angles[1]) > 0
def mapper(t):
(x1,x2) = t
if x1 and x2:
return 3
elif x1 and not x2:
return 1
elif x2 and not x1:
return 2
else:
return 0
clicks.createColumn("clicks",map(mapper,zip(clicks1,clicks2)))
return clicks
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 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 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 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)
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 measureT1(self,delays,data=None,t1Parameters=None, dataParameters=None):
"""
Measure a T1, will use what is in dictionnary if power/frequency/useCalibration/nLoops are not set
Fit and save the period in the Qubit dictionnary under T1
Return data and T1
"""
if dataParameters==None:
dataParameters=dict()
dataParameters['addToDataManager']=True
dataParameters['save']=True
print t1Parameters
if t1Parameters==None:
if self._params.has_key('t1Parameters'):
t1Parameters=self._params['t1Parameters']
else: raise Exception("Unable to find rabi parameters... Exiting... ")
useCalibration=t1Parameters['useCalibration']
frequency=t1Parameters['frequency']
if frequency=="f01":frequency=self.frequency01()
print frequency
power=t1Parameters['power']
nLoops=t1Parameters['nLoops']
duration=t1Parameters['duration']
if duration=="rabi":duration=self._params['piRabiTime']
if t1Parameters.has_key('remember'):
if t1Parameters['remember']: self._params['t1Parameters']=t1Parameters
if self._params.has_key('offsetDelay'):
offsetDelay=self._params['offsetDelay']
else: offsetDelay=20
if data==None:
data=Datacube("T1 Measurement")
if dataParameters['addToDataManager']:data.toDataManager()
if power !="stay":self._pulseGenerator._MWSource.setPower(power)
if power !="stay":self._pulseGenerator._MWSource.setPower(power)
for delay in delays:
self._pulseGenerator.clearPulse()
self._pulseGenerator.generatePulse(duration=duration, frequency=frequency, DelayFromZero=10000-delay-duration-offsetDelay,useCalibration=False)
self._pulseGenerator.sendPulse()
result=self._jba.measure(nLoops=nLoops,fast=True)[0]
data.set(**result)
data.set(delay=delay)
data.commit()
columnName="b%i"%self._jba.bit
[y0,dy,T1],yfit=fitT1(data['delay'],data[columnName])
data.createColumn("fit",yfit)
self._params['T1']=T1
return data,T1
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
#plot(xOn,refCurve(xOn-shift_on),'--')
plot(xOn,contrast)
axvline(xOn[argmax(fittedContrast)],ls = '-.')
if fitS02:
plot(xOn2,contrast2)
axvline(xOn2[argmax(fittedContrast2)],ls = '-.')
ylim(0,1)
from pyview.lib.datacube import Datacube
sDataFit = Datacube("s curve analysis")
sDataFit.createColumn("x",xOn)
sDataFit.createColumn("yOff",yOff)
sDataFit.createColumn("yOn",yOn)
sDataFit.createColumn("contrast10",contrast)
sDataFit.createColumn("yOnFit",yOnFit(xOn))
sDataFit.createColumn("contrastFit",yOnFit(xOn)-yOff)
sDataFit.createColumn("xRef",xRef)
sDataFit.createColumn("yRef",yRef)
if fitS02:
sDataFit.createColumn("x2",xOn2)
sDataFit.createColumn("yOn2",yOn2)
sDataFit.createColumn("contrast2",contrast2)
sDataFit.createColumn("yOn2Fit",yOn2Fit(xOn2))
sDataFit.createColumn("contrast2Fit",yOn2Fit(xOn2)-yOff2)
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
def _findAmplitude(self,frequency=None,shape=None,magnitudeButton=None,center=None,color=0,bounds=None,dataValues=None):
"""
Only used by function calibrate.
Measure and find the amplitude where the JBA is bi-evaluated, go to this point, and store this amplitude
"""
def fitLorentzian(fs,p1,f0=None):
fitfunc = lambda p, x: p[2]+p[0]/(1.0+pow((x-fs[argmax(p1)])/p[1],2.0))
errfunc = lambda p, x, y,ff: pow(numpy.linalg.norm(ff(p,x)-y),2.0)
ps = [(max(p1)-min(p1)),0.005,min(p1)]
if f0!=None:
if max(fs)>f0 and min(fs)<f0:ps[1]=f0
print "Initial guess:",ps
import numpy.linalg
import scipy
import scipy.optimize
p1s = scipy.optimize.fmin(errfunc, ps,args=(fs,p1,fitfunc))
rsquare = 1.0-numpy.cov(p1-fitfunc(p1s,fs))/numpy.cov(p1)
print p1s
return p1s.tolist()
if frequency==None:frequency=self._frequency
if shape==None:shape=self.shape
if magnitudeButton==None:magnitudeButton=self._magnitudeButton
self.setFrequency(frequency=frequency,shape=shape)
self.sendWaveform()
if magnitudeButton=='formAmplitude':
"""
values = voltage amplitude
"""
if center==None:
values=arange(0,0.8,0.01)
else:
values=arange(center-0.025,center+0.025,0.001)
elif magnitudeButton=='variableAttenuator':
"""
values = attenuator voltage
"""
if center==None:
values=arange(0,5,0.1)
else:
values=arange(center-0.2,center+0.2,0.01)
elif magnitudeButton=='microwaveSource':
"""
values = microwave Output power in dB
"""
self.setFrequency(frequency=frequency,shape=shape)
self.sendWaveform()
if center==None:
values=arange(0,20,0.20)
else:
values=arange(center-1,center+1,0.05)
else:
print "Error in the value of magnitudeButton"
if bounds!=None:
if center==None:
values=linspace(bounds[0],bounds[1],bounds[2])
else:
print ''
self.notify('iqP',0)
ps = []
maxcov = 0
maxVoltage = 0
self.variances = zeros((len(values),2))
self.variances[:,0] = values
self.data.clear()
try:
self.setAmplitude(magnitudeButton=magnitudeButton, amplitude=values[0])
time.sleep(0.5)
for i in range(0,len(values)):
if self.stopped():
self._stopped = False
raise Exception("Got stopped!")
v = values[i]
v=self.setAmplitude(magnitudeButton=magnitudeButton, amplitude=v)
trends=self.getComponents()
varsum =cov(trends[0])+cov(trends[1])
if not dataValues==None:
ch=Datacube()
dataValues.addChild(ch)
ch.createColumn('I',trends[0])
ch.createColumn('Q',trends[0])
dataValues.set(v=v,varsum=varsum)
dataValues.commit()
self.data.set(v = v)
self.data.set(varsum=varsum)
self.data.commit()
self.notify("variance",(self.data.column("v"),self.data.column("varsum"),((color,0,0))))
x=1.*i/len(values)
self.notify("iqP",(trends[0],trends[1],((x,0,1-x))))
self.notify("status","Variance at %g V: %g" % (v,varsum))
if DEBUG: print "Variance at v = %f : %f" % (v,varsum)
self.variances[i,1] = varsum
ps.append(varsum)
if varsum > maxcov:
maxcov = varsum
maxVoltage = values[i]
self.setAmplitude(magnitudeButton=magnitudeButton,amplitude=maxVoltage)
self._vMaxAmplitude=maxVoltage
self._sCurveParams=fitLorentzian(self.data['varsum'],self.data['v'])
except:
raise
finally:
return maxVoltage
def _findAmplitude(self,frequency=None,shape=None,magnitudeButton=None,center=None,color=0,bounds=None,dataValues=None,fitModel=True,nLoops=10):
"""
Only used by function calibrate.
Measure and find the amplitude where the JBA is bi-evaluated, go to this point, and store this amplitude
"""
def fitLorentzian(fs,p1,f0=None):
fitfunc = lambda p, x: p[2]+p[0]/(1.0+pow((x-fs[argmax(p1)])/p[1],2.0))
errfunc = lambda p, x, y,ff: pow(numpy.linalg.norm(ff(p,x)-y),2.0)
ps = [(max(p1)-min(p1)),0.005,min(p1)]
if f0!=None:
if max(fs)>f0 and min(fs)<f0:ps[1]=f0
print "Initial guess:",ps
import numpy.linalg
import scipy
import scipy.optimize
p1s = scipy.optimize.fmin(errfunc, ps,args=(fs,p1,fitfunc))
rsquare = 1.0-numpy.cov(p1-fitfunc(p1s,fs))/numpy.cov(p1)
print p1s
return p1s.tolist()
if frequency==None:frequency=self._frequency
if shape==None:shape=self.shape
if magnitudeButton==None:magnitudeButton=self._magnitudeButton
self.setFrequency(frequency=frequency,shape=shape)
self.sendWaveform()
if magnitudeButton=='formAmplitude':
"""
values = voltage amplitude
"""
if center==None:
values=arange(0,0.8,0.01)
else:
if bounds!=None:
values=linspace(center-0.025,center+0.025,bounds[2]/2)
else:
values=arange(center-0.025,center+0.025,0.001)
elif magnitudeButton=='variableAttenuator':
"""
values = attenuator voltage
"""
if center==None:
values=arange(0,5,0.1)
else:
values=arange(center-0.2,center+0.2,0.01)
elif magnitudeButton=='microwaveSource':
"""
values = microwave Output power in dB
"""
self.setFrequency(frequency=frequency,shape=shape)
self.sendWaveform()
if center==None:
values=arange(0,20,0.20)
else:
values=arange(center-1,center+1,0.05)
else:
print "Error in the value of magnitudeButton"
if bounds!=None:
if center==None:
values=linspace(bounds[0],bounds[1],bounds[2])
else:
print ''
if fitModel:separatrixList=[]
self.notify('iqP',0)
ps = []
maxcov = 0
maxVoltage = 0
self.variances = zeros((len(values),2))
self.variances[:,0] = values
self.data.clear()
try:
self.setAmplitude(magnitudeButton=magnitudeButton, amplitude=values[0])
time.sleep(0.5)
for i in range(0,len(values)):
if self.stopped():
self._stopped = False
raise Exception("Got stopped!")
v = values[i]
v=self.setAmplitude(magnitudeButton=magnitudeButton, amplitude=v)
trends=self.getComponents(nLoops=nLoops)
varsum =cov(trends[0])+cov(trends[1])
x=1.*i/len(values)
self.notify("iqP",(trends[0],trends[1],((x,0,1-x))))
if fitModel:
try:
fitResults=self.multiGaussianClusters(trends.transpose())
except:
raise
sep=self.separatrixBimodal(fitResults)
separatrixList.append(sep)
self.separatrixList=separatrixList
s=[sep[0]]
sepCenters=array([[p[0],p[1]] for p in s]).transpose()
c=sep[3]
centers=[[c[0][0],c[1][0]],[c[0][1],c[1][1]]]
self.notify("centersIQ",[sepCenters, centers])
if not dataValues==None:
ch=Datacube()
dataValues.addChild(ch)
ch.createColumn('I',trends[0])
ch.createColumn('Q',trends[1])
dataValues.set(v=v,varsum=varsum)
dataValues.commit()
self.data.set(v = v)
self.data.set(varsum=varsum)
self.data.commit()
self.notify("variance",(self.data.column("v"),self.data.column("varsum"),((color,0,0))))
self.notify("status","Variance at %g V: %g" % (v,varsum))
if DEBUG: print "Variance at v = %f : %f" % (v,varsum)
self.variances[i,1] = varsum
ps.append(varsum)
if varsum > maxcov:
maxcov = varsum
maxVoltage = values[i]
self.setAmplitude(magnitudeButton=magnitudeButton,amplitude=maxVoltage)
self._vMaxAmplitude=maxVoltage
except:
raise
finally:
# calculate separatrix
print "fitModel: ",fitModel
if fitModel:
self.separatrixList=separatrixList
sepCenters=[s[0] for s in self.separatrixList]
centers=[s[3] for s in self.separatrixList]
self.notify("centersIQ",[sepCenters, centers])
print "separatrixList: ",separatrixList
coefs,st=self.separatrixMulti(separatrixList,0.1,0.9)
I0=separatrixList[len(separatrixList)/2][0][0]
Q0=coefs[0]*I0+coefs[1]
angle=arctan(coefs[0])
self._setRotationAndOffset(I0,Q0,angle)
self.setAmplitude(amplitude=self.center-abs(self.width)/2)
p0=self.takePoint(nLoops=10)
self.setAmplitude(amplitude=self.center+abs(self.width)/2)
p1=self.takePoint(nLoops=010)
print "p0 = ",p0, " p1= ", p1
if p0>p1:
self._setRotationAndOffset(I0,Q0,angle+math.pi)
bounds=[]
else:
#calculate bounds
variances=self.data['varsum'].tolist()
voltages=self.data['v'].tolist()
yTarget=max(variances)*0.4+min(variances)*0.6
print yTarget
vmax=firstXCrossTargetYFromAnEnd(variances,voltages,yTarget=yTarget,direction='rightToLeft')[4]
vmin=firstXCrossTargetYFromAnEnd(variances,voltages,yTarget=yTarget,direction='leftToRight')[4]
vmin=vmin#-(vmax-vmin)*0.5
vmax=vmax#+(vmax-vmin)*0.5
if vmax==None or vmin==None:
center=extremum(x=voltages, y=variances, minOrMax="max")
vmin,vmax=[center*0.8,center*1.2]
self.center=(vmin+vmax)/2
self.width=abs(vmax-vmin)
bounds=[vmin,vmax,15.]
print "bounds = " + str(bounds)
return maxVoltage,bounds
