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