def updateSettings(self, c = None):
try:
MeasSet = MeasurementSettings(self.reactor, self.measurementSettings, parent = self)
if MeasSet.exec_():
self.measurementSettings = MeasSet.getValues()
print self.measurementSettings
#Set pid settings
yield self.ls.pid_set(self.measurementSettings['heater output'],self.measurementSettings['p'],self.measurementSettings['i'],self.measurementSettings['d'])
#Set output settings
yield self.setOutputSettings()
#In case record time has changed, update plots to reflect that
self.updatePlots()
if self.measurementSettings['heater mode'] == 0:
self.label_setpoint.setText('Setpoint (K):')
self.lineEdit_setpoint.setText(formatNum(self.measurementSettings['setpoint']))
elif self.measurementSettings['heater mode'] == 1:
self.label_setpoint.setText('Output (%):')
self.lineEdit_setpoint.setText(formatNum(self.measurementSettings['out percent']))
else:
self.label_setpoint.setText('WTF?!?!')
except Exception as inst:
print inst, sys.exc_traceback.tb_lineno
def setHeaterMode(self, mode):
self.measurementSettings['heater mode'] = mode
if self.measurementSettings['heater mode'] == 0:
self.label_setpoint.setText('Setpoint (K):')
self.lineEdit_setpoint.setText(formatNum(self.measurementSettings['setpoint']))
elif self.measurementSettings['heater mode'] == 1:
self.label_setpoint.setText('Output (%):')
self.lineEdit_setpoint.setText(formatNum(self.measurementSettings['out percent']))
else:
self.label_setpoint.setText('WTF?!?!')
yield self.setOutputSettings()
def setSetpoint(self, val = None):
if val is None:
val = readNum(str(self.lineEdit_setpoint.text()), self, False)
if isinstance(val,float):
if self.measurementSettings['heater mode'] == 0:
self.measurementSettings['setpoint'] = val
yield self.ls.setpoint(self.measurementSettings['heater output'], self.measurementSettings['setpoint'])
elif self.measurementSettings['heater mode'] == 1:
self.measurementSettings['out percent'] = val
yield self.ls.gpib_write('MOUT%i,%f'%(self.measurementSettings['heater output'],self.measurementSettings['out percent']))
if self.measurementSettings['heater mode'] == 0:
self.lineEdit_setpoint.setText(formatNum(self.measurementSettings['setpoint']))
elif self.measurementSettings['heater mode'] == 1:
self.lineEdit_setpoint.setText(formatNum(self.measurementSettings['out percent']))
def updateTC(self, c = None):
new_Tc = str(self.lineEdit_timeConst.text())
val = readNum(new_Tc, self)
if isinstance(val, float):
yield self.hf.set_demod_time_constant(1,val)
self.timeConst = yield self.hf.get_demod_time_constant(1)
self.lineEdit_timeConst.setText(formatNum(self.timeConst))
def updateStepSize(self):
new_freqStep = str(self.lineEdit_deltaF.text())
val = readNum(new_freqStep, self, False)
if isinstance(val,float):
self.freqStep = val
self.points = int(np.abs(self.startFreq-self.stopFreq)/self.freqStep)
self.reinitSweep()
self.lineEdit_deltaF.setText(formatNum(self.freqStep))
def set_ZMaxVolts(self):
#val = readNum(str(self.lineEdit_ZMaxVolts.text()))
#if isinstance(val,float):
# self.tempData[9] = val
if self.tempData[9] is None:
self.lineEdit_ZMaxVolts.setText('')
else:
self.lineEdit_ZMaxVolts.setText(formatNum(self.tempData[9]))
def updateSelectFreq(self):
new_selectFreq = str(self.lineEdit_freqSelect.text())
val = readNum(new_selectFreq, self)
if isinstance(val,float):
self.selectFreq = val
self.freqSelectLine.setPos(self.selectFreq)
self.freqSelectLine2.setPos(self.selectFreq)
self.reinitSweep()
self.lineEdit_freqSelect.setText(formatNum(self.selectFreq, 4))
def __init__(self, settings, parent = None):
super(settingsWindow, self).__init__(parent)
self.setupUi(self)
self.plotSettings = settings
#Load the current values into the setting window UI
self.lineEdit_ScaleFactor.setText(formatNum(self.plotSettings['scanPlot_scalefactor'], 6))
self.lineEdit_Offset.setText(formatNum(self.plotSettings['scanPlot_offset'], 6))
self.checkBox_realUnit.setChecked(self.plotSettings['scanPlot_realPosition'])
#Connect UI elements for updating the settings
self.lineEdit_ScaleFactor.editingFinished.connect(lambda: self.updateParameter('scanPlot_scalefactor', self.lineEdit_ScaleFactor))
self.lineEdit_Offset.editingFinished.connect(lambda: self.updateParameter('scanPlot_offset', self.lineEdit_Offset))
self.checkBox_realUnit.stateChanged.connect(self.updateCheckBox)
#Accept the changes if the accept button is clicked
self.pushButton_accept.clicked.connect(self.accept)
def updateStopFreq(self):
new_stopFreq = str(self.lineEdit_MaxFreq.text())
val = readNum(new_stopFreq, self)
if isinstance(val,float):
self.stopFreq = val
self.maxFreqLine.setPos(self.stopFreq)
self.maxFreqLine2.setPos(self.stopFreq)
self.points = int(np.abs(self.startFreq-self.stopFreq)/self.freqStep)
self.reinitSweep()
self.lineEdit_MaxFreq.setText(formatNum(self.stopFreq, 4))
def loadSelectedCalibration(self, key):
data = self.calibrationDictionary[str(key)]
self.tempData = data
self.lineEdit_XCon.setText(formatNum(float(data[1]),3))
self.lineEdit_YCon.setText(formatNum(float(data[2]),3))
self.lineEdit_ZCon.setText(formatNum(float(data[3]),3))
self.lineEdit_XMax.setText(formatNum(float(data[4]),3))
self.lineEdit_YMax.setText(formatNum(float(data[5]),3))
self.lineEdit_ZMax.setText(formatNum(float(data[6]),3))
self.lineEdit_XMaxVolts.setText(formatNum(float(data[7]),3))
self.lineEdit_YMaxVolts.setText(formatNum(float(data[8]),3))
self.lineEdit_ZMaxVolts.setText(formatNum(float(data[9]),3))
def set_ZMax(self):
val = readNum(str(self.lineEdit_ZMax.text()), self)
if isinstance(val,float):
self.tempData[6] = val
if self.tempData[3] is not None and self.tempData[6] is not None:
self.tempData[9] = float(self.tempData[3])*float(self.tempData[6])
self.set_ZMaxVolts()
if self.tempData[6] is None:
self.lineEdit_ZMax.setText('')
else:
self.lineEdit_ZMax.setText(formatNum(self.tempData[6]))
def loadCurrValues(self):
if self.bandcontrol == 0:
self.radio_Manual.setChecked(True)
elif self.bandcontrol == 1:
self.radio_Fixed.setChecked(True)
else:
self.radio_Auto.setChecked(True)
if self.log:
self.checkBox_log.setChecked(True)
if self.overlap:
self.checkBox_overlap.setChecked(True)
self.lineEdit_settle_time.setText(formatNum(self.settle_time))
self.lineEdit_settle_acc.setText(formatNum(self.settle_acc))
self.lineEdit_avg_tc.setText(str(self.average_TC))
self.lineEdit_avg_sample.setText(str(self.average_sample))
self.lineEdit_bandwidth.setText(formatNum(self.bandwidth))
self.lineEdit_loopcount.setText(str(self.loopcount))
def Updateposition(self):
self.xposition = int(self.fill[0, 0]) * 2**7 + int(
self.fill[0, 1]) * 2**6 + int(self.fill[0, 2]) * 2**5 + int(
self.fill[0, 3]) * 2**4 + int(self.fill[1, 0]) * 2**3 + int(
self.fill[1, 1]) * 2**2 + int(
self.fill[1, 2]) * 2**1 + int(self.fill[1, 3]) * 2**0
#This convert the QR code to the integer it correspond to
valx = formatNum(
self.inttonum(self.xposition) -
float(decimal.Decimal(self.CenterX * 30) / decimal.Decimal(10**6)))
self.lineEdit_Xposition.setText(valx)
self.yposition = int(self.fill[2, 0]) * 2**7 + int(
self.fill[2, 1]) * 2**6 + int(self.fill[2, 2]) * 2**5 + int(
self.fill[2, 3]) * 2**4 + int(self.fill[3, 0]) * 2**3 + int(
self.fill[3, 1]) * 2**2 + int(
self.fill[3, 2]) * 2**1 + int(self.fill[3, 3]) * 2**0
valy = formatNum(
self.inttonum(self.yposition) -
float(decimal.Decimal(self.CenterY * 30) / decimal.Decimal(10**6)))
self.lineEdit_Yposition.setText(valy)
def set_YCon(self):
val = readNum(str(self.lineEdit_YCon.text()), self)
if isinstance(val,float):
self.tempData[2] = val
if self.tempData[2] is not None and self.tempData[5] is not None:
self.tempData[8] = float(self.tempData[2])*float(self.tempData[5])
self.set_YMaxVolts()
if self.tempData[2] is None:
self.lineEdit_YCon.setText('')
else:
self.lineEdit_YCon.setText(formatNum(self.tempData[2]))
def updateSensitivity(self, c = None):
try:
new_sens = str(self.lineEdit_sensitivity.text())
val = readNum(new_sens, self, False)
if isinstance(val,float):
yield self.hf.set_range(self.input, val)
range = yield self.hf.get_range(self.input)
self.sensitvity = range
self.lineEdit_sensitivity.setText(formatNum(self.sensitvity))
except Exception as inst:
print inst
def updateOutputAmplitude(self, c = None):
try:
new_Amp = str(self.lineEdit_Amplitude.text())
val = readNum(new_Amp, self)
if isinstance(val,float):
yield self.hf.set_output_range(self.output,val)
range = yield self.hf.get_output_range(self.output)
yield self.hf.set_output_amplitude(self.output,val/range)
self.exAmp = val
self.lineEdit_Amplitude.setText(formatNum(self.exAmp))
except Exception as inst:
print inst
def UpdateAutomaticPositioningAbsolutePosition(self, AxisNo):
dummystr = str(self.lineEdit_Absolute[AxisNo].text())
dummyval = readNum(dummystr, self)
if isinstance(dummyval, float):
if dummyval >= -5.0 * 10**-3 and dummyval <= 5.0 * 10**-3:
self.AbsolutePosition[AxisNo] = dummyval
elif dummyval < -5.0 * 10**-3:
self.AbsolutePosition[AxisNo] = -5.0 * 10**-3
elif dummyval > 5.0 * 10**-3:
self.AbsolutePosition[AxisNo] = 5.0 * 10**-3
self.lineEdit_Absolute[AxisNo].setText(
formatNum(self.AbsolutePosition[AxisNo], 6))
def loadParameters(self):
for i in range(3):
#Load parameters in the GUI that can be read
amp = yield self.anc350.get_amplitude(i)
freq = yield self.anc350.get_frequency(i)
self.lineEdit_Amplitude[i].setText(formatNum(amp))
self.lineEdit_Frequency[i].setText(formatNum(freq))
statusarray = yield self.anc350.get_axis_status(i)
if statusarray[1] == 1:
self.OutputEnabled[i] = True
else:
self.OutputEnabled[i] = False
self.checkBox_OutputEnabled[i].setChecked(self.OutputEnabled[i])
#Attocube doesn't provide the capability to read the following values from their hardware, so set these
#to our chosen default values
yield self.UpdateAutomaticPositioningRelativePosition(i)
yield self.UpdateAutomaticPositioningAbsolutePosition(i)
yield self.UpdateAmplitude(i)
yield self.UpdateFrequency(i)
yield self.UpdateTargetRange(i)
yield self.anc350.set_target_ground(i, self.TargetGround[i])
def UpdateAmplitude(self, AxisNo):
try:
dummystr = str(self.lineEdit_Amplitude[AxisNo].text())
dummyval = readNum(dummystr, self, False)
if isinstance(dummyval, float):
if dummyval >= 0 and dummyval <= 60:
self.manual_Amplitude[AxisNo] = dummyval
elif dummyval < 0:
self.manual_Amplitude[AxisNo] = 0
elif dummyval > 60:
self.manual_Amplitude[AxisNo] = 60
self.lineEdit_Amplitude[AxisNo].setText(
formatNum(self.manual_Amplitude[AxisNo], 6))
if hasattr(self, 'anc350'):
yield self.anc350.set_amplitude(AxisNo,
self.manual_Amplitude[AxisNo])
except Exception as inst:
print inst, sys.exc_traceback.tb_lineno
def UpdateFrequency(self, AxisNo):
try:
dummystr = str(self.lineEdit_Frequency[AxisNo].text())
dummyval = readNum(dummystr, self, False)
if isinstance(dummyval, float):
if dummyval >= 1 and dummyval <= 2000:
self.manual_Frequency[AxisNo] = int(dummyval)
elif dummyval < 1:
self.manual_Frequency[AxisNo] = 1
elif dummyval > 2000:
self.manual_Frequency[AxisNo] = 2000
self.lineEdit_Frequency[AxisNo].setText(
formatNum(self.manual_Frequency[AxisNo], 6))
if hasattr(self, 'anc350'):
yield self.anc350.set_frequency(AxisNo,
self.manual_Frequency[AxisNo])
except Exception as inst:
print inst, sys.exc_traceback.tb_lineno
def UpdateTargetRange(self, AxisNo):
try:
dummystr = str(self.lineEdit_TargetRange[AxisNo].text())
dummyval = readNum(dummystr, self)
if isinstance(dummyval, float):
if dummyval >= 1 * 10**-9 and dummyval <= 10**-3:
self.TargetRange[AxisNo] = dummyval
elif dummyval < 1 * 10**-9:
self.TargetRange[AxisNo] = 1 * 10**-9
elif dummyval > 10**-3:
self.TargetRange[AxisNo] = 10**-3
self.lineEdit_TargetRange[AxisNo].setText(
formatNum(self.TargetRange[AxisNo], 6))
if hasattr(self, 'anc350'):
yield self.anc350.set_target_range(AxisNo,
self.TargetRange[AxisNo])
except Exception as inst:
print inst, sys.exc_traceback.tb_lineno
def readCurrentSettings(self, c = None):
try:
range = yield self.ls.range_read(self.measurementSettings['heater output'])
pid = yield self.ls.pid_read(self.measurementSettings['heater output'])
pid = pid.split(',')
setpoint = yield self.ls.setpoint_read(self.measurementSettings['heater output'])
self.lineEdit_setpoint.setText(formatNum(float(setpoint)))
if range !=0:
self.measurementSettings['heater range'] = range
self.measurementSettings['p'] = float(pid[0])
self.measurementSettings['i'] = float(pid[1])
self.measurementSettings['d'] = float(pid[2])
self.measurementSettings['setpoint'] = float(setpoint)
except Exception as inst:
print inst, sys.exc_traceback.tb_lineno
def connectLabRAD(self, dict):
try:
self.cxn = dict['servers']['local']['cxn']
self.gen_dv = dict['servers']['local']['dv']
#Create another connection for the connection to data vault to prevent
#problems of multiple windows trying to write the data vault at the same
#time
from labrad.wrappers import connectAsync
self.cxn_tf = yield connectAsync(host = '127.0.0.1', password = '******')
self.dv = yield self.cxn_tf.data_vault
curr_folder = yield self.gen_dv.cd()
yield self.dv.cd(curr_folder)
self.hf = yield self.cxn_tf.hf2li_server
self.hf.select_device(dict['devices']['approach and TF']['hf2li'])
self.push_Servers.setStyleSheet("#push_Servers{" +
"background: rgb(0, 170, 0);border-radius: 4px;}")
try:
self.reinitSweep()
except Exception as inst:
print inst
try:
range = yield self.hf.get_output_range(self.output)
amp = yield self.hf.get_output_amplitude(self.output)
self.exAmp = amp*range
self.lineEdit_Amplitude.setText(formatNum(self.exAmp))
except Exception as inst:
print inst
try:
self.updateSensitivity()
except Exception as inst:
print inst
try:
self.updateTC()
except Exception as inst:
print inst
self.unlockInterface()
except Exception as inst:
self.push_Servers.setStyleSheet("#push_Servers{" +
"background: rgb(161, 0, 0);border-radius: 4px;}")
def updateParameter(self, key, lineEdit):
val = readNum(str(lineEdit.text()))
if isinstance(val, float):
self.plotSettings[key] = val
lineEdit.setText(formatNum(self.plotSettings[key], 6))
def setGate(self, gate):
self.gateSetpntLine.setText(formatNum(gate))
yield self.gotoGateFunc()
def setBias(self, bias):
self.biasSetpntLine.setText(formatNum(bias))
yield self.gotoBiasFunc()
def fitCurrData(self, c = None):
#ideas: scale voltage data up to avoid small values, makes it easier to fit. Then rescale back down.
#avoiding small numbers as much as possible is good seems to work fine right now, so not necessary.
#But if data fitting is bad in the future this can be a possible fix.
'''
self.startFreq = 32000
self.stopFreq = 33500
self.points = 10000
#self.startFreq = 30000
#self.stopFreq = 34000
#self.points = 10000
self.freq = np.linspace(self.startFreq, self.stopFreq, self.points)
#params = [27100, 8100, 2.9e-15, 1.2e-12]
params = [32838.1, 61670, 0.00670979, 3.7e-5]
param = [32838.1, 61670, 0.00670979, -3]
#params = [32838.1, 5000, 0.0067, 3.7e-5]
#param = [32838.1, 5000, 0.0067]
self.R = ampFunc(self.freq, *params) + 5e-6*(np.random.rand(self.points)-0.5)
self.phi = phaseFunc(self.freq, *param) + np.random.rand(self.points)-0.5
#removes previous data plot and replots it. Doesn't seem necessary
try:
self.ampPlot.removeItem(self.prevAmpPlot)
self.phasePlot.removeItem(self.prevPhasePlot)
except Exception as inst:
pass
self.prevAmpPlot = self.ampPlot.plot(self.freq,self.R)
self.prevPhasePlot = self.phasePlot.plot(self.freq,self.phi)
'''
try:
max = np.amax(self.R)
f0_guess = self.freq[np.argmax(self.R)]
self.ampFitParams, pcov = curve_fit(ampFunc, self.freq, self.R, p0 = [f0_guess, 5000, 0.1, max])
perr = np.sqrt(np.diag(pcov))
if self.showFit:
try:
self.ampPlot.removeItem(self.prevAmpFit)
except:
pass
self.prevAmpFit = self.ampPlot.plot(self.freq,ampFunc(self.freq, *self.ampFitParams))
self.lineEdit_peakF.setText(formatNum(self.ampFitParams[0]))
self.lineEdit_peakFSig.setText(formatNum(perr[0]))
self.lineEdit_QFactor.setText(formatNum(self.ampFitParams[1]))
avg = 0
for i in range(0,10):
avg = avg + self.phi[i]
avg = avg/10
self.phaseFitParams, pcov = curve_fit(phaseFunc, self.freq, self.phi, p0 = [self.ampFitParams[0], self.ampFitParams[1], self.ampFitParams[2], avg-90])
perr = np.sqrt(np.diag(pcov))
if self.showFit:
try:
self.phasePlot.removeItem(self.prevPhaseFit)
except:
pass
self.prevPhaseFit = self.phasePlot.plot(self.freq,phaseFunc(self.freq, *self.phaseFitParams))
self.lineEdit_PhasePeakF.setText(formatNum(self.phaseFitParams[0]))
self.lineEdit_PhasePeakFSig.setText(formatNum(perr[0]))
self.lineEdit_PhaseQFactor.setText(formatNum(self.phaseFitParams[1]))
#Maybe iterate fits/starting parameters?
except Exception as inst:
print "Fitting threw the following error: ", inst
#wait for plots to udpate before saving data screenshot
yield self.sleep(0.25)
#If a fit is done, resave the data to show the results
self.saveDataToSessionFolder()
def updateSettleTime(self):
new_settle_time = str(self.lineEdit_settle_time.text())
val = readNum(new_settle_time, self)
if isinstance(val, float):
self.settle_time = val
self.lineEdit_settle_time.setText(formatNum(self.settle_time))
def updateBandwidth(self):
new_bandwidth = str(self.lineEdit_bandwidth.text())
val = readNum(new_bandwidth, self)
if isinstance(val, float):
self.bandwidth = val
self.lineEdit_bandwidth.setText(formatNum(self.bandwidth))
def updateSettleAcc(self):
new_settle_acc = str(self.lineEdit_settle_acc.text())
val = readNum(new_settle_acc, self)
if isinstance(val, float):
self.settle_acc = val
self.lineEdit_settle_acc.setText(formatNum(self.settle_acc))
