def output_method(control_dict, mag_dict, lockin_dict):
display = control_dict['Display']
amp = lockinAmp(lockin_dict['Mode'], lockin_dict['Sensitivity'],
lockin_dict['Signal Voltage'], lockin_dict['Frequency'])
d = control_dict['H Output Direction'].get() # direction output variable
t = mag_dict['Output Time (s)'].get() # output time
output = mag_dict['%s Field (Oe)' % d].get() # output value
interval = control_dict['%s/DAC (Oe/V)' % d] # conversion integral
# confirms output is number
if output.lstrip('-').replace('.', '', 1).isdigit():
# if output below threshold value, then have lockin amp output for t seconds
if float(output) / float(interval) < float(
control_dict['%s DAC Limit' % d]):
amp.dacOutput((float(output) / float(interval)),
control_dict['%s DAC Channel' % d])
time.sleep(float(t))
amp.dacOutput(0, control_dict['%s DAC Channel' % d])
display.insert('end', '%s output for %s second(s)' % (d, t))
display.see(END)
else:
messagebox.showwarning(
'Output Too Large',
'Output value beyond amp voltage threshold')
display.insert('end', 'Output value too large!')
display.see(END)
else:
messagebox.showwarning(
'Invalid Entry',
'Output or conversion factor not recognized as a number.')
def quit_method(display, lockin_dict):
global root
q = messagebox.askquestion('Quit', 'Are you sure you want to quit?')
if q == 'yes':
amp = lockinAmp(lockin_dict['Mode'], lockin_dict['Sensitivity'],
lockin_dict['Signal Voltage'],
lockin_dict['Frequency'])
amp.dacOutput(0, 1)
amp.dacOutput(0, 2)
amp.dacOutput(0, 3)
amp.dacOutput(0, 4)
keith_2400 = Keithley2400('f') # Initiate K2400
keith_2400.minimize()
time.sleep(0.1)
keith_2400.fourWireOff()
keith_2400.outputOff()
display.insert('end', "All fields set to zero.")
display.see(END)
time.sleep(.1)
root.quit()
else:
pass
def measure_loop():
global scan_field_output, measured_values, freq_lbl
measured_values = []
freq_lbl = ['']
# builds list from step and max value
scan_field_output = make_list(mag_dict['Hx Field (Oe)'].get(), mag_dict['Hx Step (Oe)'].get())
# list is built to be negatvie to positive, but measurement needs to be pos to neg
scan_field_output.reverse()
# list of frequencies to measure at
freq_output = make_list(signal_dict['Frequency (GHz)'].get(), signal_dict['Frequency Step (GHz)'].get())
# ensures output voltages will not exceed amp thresholds
if max(scan_field_output) / float(control_dict['Hx/DAC (Oe/V)']) < float(control_dict['Hx DAC Limit']) and float(signal_dict['Frequency (GHz)'].get()) < 20:
# initialize machines
amp = lockinAmp(lockin_dict['Mode'].get(), lockin_dict['Sensitivity'].get(), float(lockin_dict['Signal Voltage (V)'].get()), int(lockin_dict['Frequency (Hz)'].get()))
sig_gen = HP8341()
sig_gen.setPower(float(signal_dict['Power (dBm)'].get())) # set signal gen to power level
for freq_val in freq_output:
sig_gen.setFrequency(freq_val) # set frequency
freq_lbl[0] = freq_val
# intializes the measurement data list
measured_values = []
# measurement loops - measure pos and neg current at give scan value and take avg abs val (ohms)
for counter, scan_val in enumerate(scan_field_output):
if counter == 0:
diff = abs(scan_val)
else:
diff = abs(scan_val - scan_field_output[counter-1])
amp.dacOutput((scan_val / float(control_dict['Hx/DAC (Oe/V)'])), control_dict['Hx DAC Channel'])
time.sleep(charging(diff))
tmp = 1000 * float(round(amp.readX(lockin_dict['Average'].get()), 4)) # take average from Lockin measurements
measured_values.append(tmp)
display.insert('end', 'Applied Hx Field Value: %s (Oe) Measured Resistance: %s (Ohm)' %(scan_val, tmp))
display.see(END)
# save data
save_method(scan_field_output, measured_values, display, control_dict['Directory'], control_dict['File Name'].get(), lockin_dict, signal_dict)
# turn everything off at end of loop
amp.dacOutput(0, control_dict['Hx DAC Channel'])
display.insert('end',"Measurement finished")
display.see(END)
else:
messagebox.showwarning('Output Too Large', 'Amp Voltage or Signal Frequency Too Large!')
display.insert('end', 'Output value too large!')
display.see(END)
def event():
t = 0
a = 0.0
amp = lockinAmp(func, sense, signal, freq)
step = (double(_output) / i) / n
while t < n:
amp.dacOutput(a, DAC)
tmp = 1000 * double(amp.readX(average)) #in units of mV
result.append(tmp)
values_y.append(tmp)
values_x.append(a * i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t += 1
a += step
listbox_l.see(END)
while t < 3 * n:
amp.dacOutput(a, DAC)
tmp = 1000 * double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a * i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t += 1
a -= step
listbox_l.see(END)
while t <= 4 * n:
amp.dacOutput(a, DAC)
tmp = 1000 * double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a * i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t += 1
a += step
listbox_l.see(END)
#scat=ax.scatter(values_x, values_y, s=50, alpha=0.5)
#canvas.draw()
keith.outputOff()
listbox_l.insert('end', "Measurement finished")
listbox_l.see(END)
def outputMethod(_output):
if _output.replace('.','').replace('-','').isdigit() :
#print(entry_output.get())
amp = lockinAmp()
msg = amp.dacOutput(double(_output))
listbox_l.insert('end', "Output has been set to %s" %str(_output))
listbox_l.see(END)
else:
listbox_l.insert('end', "\""+_output+"\" is not a valid ouput value.")
listbox_l.see(END)
def quitMethod():
amp = lockinAmp(func, sense, signal, freq)
amp.dacOutput(0, 1)
amp.dacOutput(0, 2)
amp.dacOutput(0, 3)
amp.dacOutput(0, 4)
listbox_l.insert('end', "All fields set to zero.")
listbox_l.see(END)
time.sleep(1)
global root
root.quit()
def measure_loop():
global scan_field_output, measured_values, sens_lbl
measured_values = []
sens_lbl = ['']
# builds list from step and max value
scan_field_output = make_list(mag_dict['Hz Field (Oe)'].get(), mag_dict['Hz Step (Oe)'].get())
# take inverse list and add it on, creating the full list values to measure at
inverse = reversed(scan_field_output[0:-1])
scan_field_output += inverse
# ensures output voltages will not exceed amp thresholds
if max(scan_field_output) / float(control_dict['Hz/DAC (Oe/V)']) < float(control_dict['Hz DAC Limit']):
# initialize machines
amp = lockinAmp(lockin_dict['Mode'], lockin_dict['Sensitivity'], lockin_dict['Signal Voltage (V)'], lockin_dict['Frequency (Hz)'])
# intializes the measurement data list
measured_values = []
# measurement loops - measure pos and neg current at give scan value and take avg abs val (ohms)
for counter, scan_val in enumerate(scan_field_output):
if counter == 0:
diff = abs(scan_val)
else:
diff = abs(scan_val - scan_field_output[counter-1])
amp.dacOutput((scan_val / float(control_dict['Hz/DAC (Oe/V)'])), control_dict['Hz DAC Channel'])
time.sleep(charging(diff))
tmp = imageMethodFAST(x1, y1, x2, y2) # get image luminosity
measured_values.append(tmp)
display.insert('end', 'Applied Hz Field Value: %s (Oe) MOKE Signal: %s (A.U.)' %(scan_val, tmp))
display.see(END)
# save data
save_method(scan_field_output, measured_values, display, control_dict['Directory'], control_dict['File Name'].get())
# turn everything off at end of loop
amp.dacOutput(0, control_dict['Hz DAC Channel'])
display.insert('end',"Measurement finished")
display.see(END)
else:
messagebox.showwarning('Output Too Large', 'Output value beyond amp voltage threshold')
display.insert('end', 'Output value too large!')
display.see(END)
def outputMethod(_interval, _output, _signal, _frequency):
i=float(_interval)
signal=float(_signal)
freq=int(_frequency)
amp = lockinAmp(func, sense, signal, freq)
if _output.replace('.','').replace('-','').isdigit() :
#print(entry_output.get())
amp.dacOutput((double(_output)/i), DAC)
listbox_l.insert('end', "Single output field: "+_output+" Oe.")
listbox_l.see(END)
else:
listbox_l.insert('end', "\""+_output+"\" is not a valid ouput value.")
listbox_l.see(END)
def outputMethod(_interval, _output):
global freq, signal
i=float(_interval)
amp = lockinAmp(func, sense, signal, freq)
if _output.replace('.','').replace('-','').isdigit() and (float(_output)/float(_interval)) < 1 :
#print(entry_output.get())
amp.dacOutput((double(_output)/i), DAC)
listbox_l.insert('end', "Single output Hx field: "+_output+" Oe.")
listbox_l.see(END)
else:
listbox_l.insert('end', "\""+_output+"\" is not a valid Hx output value.")
listbox_l.see(END)
def quitMethod():
amp = lockinAmp(func, sense, signal, freq)
amp.dacOutput(0, 1)
amp.dacOutput(0, 2)
amp.dacOutput(0, 3)
amp.dacOutput(0, 4)
keith=Keithley2400(f)
keith.setCurrent(0)
keith.outputOff()
listbox_l.insert('end', "All fields set to zero.")
listbox_l.see(END)
global root
root.quit()
def quit_method(display, lockin_dict):
global root
q = messagebox.askquestion('Quit', 'Are you sure you want to quit?')
if q == 'yes':
amp = lockinAmp(lockin_dict['Mode'], lockin_dict['Sensitivity'], lockin_dict['Signal Voltage (V)'], lockin_dict['Frequency (Hz)'])
amp.dacOutput(0, 1)
amp.dacOutput(0, 2)
amp.dacOutput(0, 3)
amp.dacOutput(0, 4)
display.insert('end', "All fields set to zero.")
display.see(END)
time.sleep(.1)
root.quit()
else:
pass
def quit_method():
global root
q = messagebox.askquestion('Quit', 'Are you sure you want to quit?')
if q == 'yes':
amp = lockinAmp(func, sense, signal, freq)
amp.dacOutput(0, 1)
amp.dacOutput(0, 2)
amp.dacOutput(0, 3)
amp.dacOutput(0, 4)
display.insert('end', "All fields set to zero.")
display.see(END)
time.sleep(.1)
root.quit()
else:
pass
def measureUpdate(i,lim):
global qx, qy
t=0
a=0.0 #initial amplitude
while t <= lim :
#print ("%s" %time.ctime(time.time()*1000-t0))
#print ("%.2f" %float(time.time()*1000-t0))
amp = lockinAmp()
tmp=1000*double(amp.readX(average))
qy.put(tmp)
qx.put(a)
#print(tmp[1])
#time.sleep(i/1000)
t+=i
#print(tmp[1])
qy.put('Q')
qx.put('Q')
def output_method(Hdirection, magnet):
amp = lockinAmp(func, sense, signal, freq)
time = fetch_entry('Output Time (s)', magnet)
output = fetch_entry('H%s Field (Oe)' % Hdirection, magnet)
interval = fetch_entry('H%s (Oe)/DAC (V)' % Hdirection, magnet)
if Hdirection == 'z':
dac = DACz
limit = 1.0
else:
dac = DACx
limit = 12.0
print(output)
print(interval)
# if output and interval are valid and below threshold then output for time seconds on specified dac channel
if output.lstrip('-').replace(
'.', '', 1).isdigit() and interval.lstrip('-').replace(
'.', '', 1).isdigit():
if (float(output) / float(interval)) < limit:
amp.dacOutput((float(output) / float(interval)), dac)
time.sleep(int(time))
amp.dacOutput(0, dac)
display.insert(
'end', 'Output in the %s director for %s second(s)' %
(Hdirection, time))
display.see(END)
else:
messagebox.showwarning(
'Output Too Large',
'Output value beyond amp voltage threshold')
display.insert('end', 'Output value too large!')
display.see(END)
else:
messagebox.showwarning(
'Invalid Entry',
'Output or conversion factor not recognized as a number.')
def event():
Hx_start = float(_Hx) # Max Hx field value
Hx_end = float(_Hx) * (-1) # Min Hx field value
Hx_step = float(_dHx) # step in Hx field
keith = Keithley2400(f) #Initiate K2400
amp = lockinAmp(func, sense, signal, freq) #Initiate Lock-in
while Hx_start >= Hx_end:
amp.dacOutput((Hx_start / ix), DACx)
current_start = float(
_current) # Max current set by Keithley 2400
current_end = float(_current) * (
-1) # Min current set by Keithley 2400
current_step = float(_step) # step in current
while current_start >= current_end:
ax.clear()
ax.grid(True)
ax.set_title("Realtime Hall voltage vs H Plot")
ax.set_xlabel("Applied Field (Oe)")
ax.set_ylabel("Lock-In X (mV)")
listbox_l.insert(
'end',
"Now measuring with Hx = %f (Oe) and Idc = %f (mA) " %
(Hx_start, current_start))
listbox_l.see(END)
#Prepare data entries
global values_x, values_y, result
values_y = []
values_x = []
result = []
#Setup K2400 for current output and resistance measurement
keith.setCurrent(current_start)
keith.outputOn()
index = 1
data = []
while index <= 5: #Average of five measurements
data = data + keith.measureOnce()
index += 1
print("Measured current: %f mA" % (1000 * data[2]))
print("Measured voltage: %f V" % data[1])
print("Measured resistance: %f Ohm" % (data[1] / data[2]))
save = (data[1] / data[2])
#Setup lock-in for dac (Hz field) output
t = 0
a = 0.0
step = (double(_output) / i) / n
while t < n:
amp.dacOutput(a, DAC)
tmp = 1000 * double(amp.readX(average)) #in units of mV
result.append(tmp)
values_y.append(tmp)
values_x.append(a * i)
ax.plot(values_x,
values_y,
'b-o',
ms=dot_size,
mew=dot_edge,
alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t += 1
a += step
listbox_l.see(END)
while t < 3 * n:
amp.dacOutput(a, DAC)
tmp = 1000 * double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a * i)
ax.plot(values_x,
values_y,
'b-o',
ms=dot_size,
mew=dot_edge,
alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t += 1
a -= step
listbox_l.see(END)
while t <= 4 * n:
amp.dacOutput(a, DAC)
tmp = 1000 * double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a * i)
ax.plot(values_x,
values_y,
'b-o',
ms=dot_size,
mew=dot_edge,
alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t += 1
a += step
listbox_l.see(END)
#Setup timestamp
stamp = datetime.now().strftime('%Y-%m-%d-%H%M%S')
listbox_l.insert('end', str(stamp))
file = open(
str(directory) + "/" + str(_sample) + "_" + str(save) +
"Ohm_" + str(Hx_start) + "Oe_" + str(current_start) +
"mA_" + str(stamp), "w")
file.write("" + str(_sample) + "\n")
file.write("Initial resistance: " + str(save) + "(Ohm)\n")
file.write("Applied in-plane field: " + str(Hx_start) +
"(Oe)\n")
file.write("Applied current: " + str(current_start) +
"(mA)\n\n")
file.write("Number" + " " + "Field(Oe)" + " " + "Voltage(mV)" +
"\n")
cnt = 1
#output all data
for a in range(len(values_y)):
file.write(
str(cnt) + " " + str(values_x[a]) + " " +
str(values_y[a]) + "\n")
cnt += 1
file.closed
listbox_l.insert('end', "The Measurement data is saved.")
listbox_l.see(END)
keith.outputOff()
current_start = current_start - current_step
time.sleep(1) #Sleep between each scan
Hx_start = Hx_start - Hx_step
amp.dacOutput(0, DACx)
amp.dacOutput(0, DAC)
listbox_l.insert('end', "Measurement finished")
listbox_l.see(END)
def event():
Hx_start=float(_Hx)
Hx_end=float(_Hx)*(-1)
Hx_step=float(_dHx)
keith=Keithley2400('CURR') #Initiate K2400
amp = lockinAmp(func, sense, signal, freq) #Initiate Lock-in
while Hx_start>=Hx_end:
amp.dacOutput((Hx_start/ix), DACx)
current_max=float(_current)
current_min=float(_current)*(-1)
current_step=float(_step)
#while current_start>=current_end:
ax.clear()
ax.grid(True)
ax.set_title("Realtime Resistance vs I Plot")
ax.set_xlabel("Applied Pulsed Current (mA)")
ax.set_ylabel("Keithley 2400 Resistance (Ohm)")
listbox_l.insert('end',"Now measuring with Hx = %f (Oe)" %Hx_start)
listbox_l.see(END)
#Prepare data entries
global values_x, values_y, result
values_y=[]
values_x=[]
result=[]
#Setup K2400 for current output and resistance measurement
keith.setCurrent(0.1) #Use 0.1mA to measure DC resistance
keith.outputOn()
index=1
data=[]
while index<=5: #Average of five measurements
data=data+keith.measureOnce()
index+=1
print("Measured current: %f mA" %(1000*data[2]))
print("Measured voltage: %f V" %data[1])
print("Measured resistance: %f Ohm" %(data[1]/data[2]))
#Setup Keithley for Idc sweep
current=0.01
trigger_delay=float(_rest_length)
source_delay=float(_pulse_length)
while current < current_max :
keith.pulse(current,current_max, trigger_delay, source_delay)
data=keith.measureOnce()
tmp=double(data[1]/data[2]) #Resistance from K2400
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
#ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
ax.plot(values_x, values_y,'b-o', ms=dot_size, mew=dot_edge, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current+=current_step
listbox_l.see(END)
while current > -current_max:
keith.pulse(current,current_max, trigger_delay, source_delay)
data=keith.measureOnce()
tmp=double(data[1]/data[2]) #Resistance from K2400
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
#ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
ax.plot(values_x, values_y,'b-o', ms=dot_size, mew=dot_edge, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current-=current_step
listbox_l.see(END)
while current <= 0 :
keith.pulse(current, current_max, trigger_delay, source_delay)
data=keith.measureOnce()
tmp=double(data[1]/data[2]) #Resistance from K2400
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
#ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
ax.plot(values_x, values_y,'b-o', ms=dot_size, mew=dot_edge, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current+=current_step
listbox_l.see(END)
stamp = datetime.now().strftime('%Y-%m-%d-%H%M%S')
listbox_l.insert('end', str(stamp))
file = open(str(directory)+"/MR_STT_pulsed_switching_"+str(_sample)+"_"+str(Hx_start)+"Oe_"+str(source_delay)+"s_"+str(stamp), "w")
file.write(str(_sample)+"\n")
file.write("Applied in-plane field: "+str(Hx_start)+"(Oe)\n\n")
file.write("Number"+" "+"Current(mA)"+" "+"Resistance(Ohm)"+"\n")
cnt=1
#output all data
for a in range(len(values_y)):
file.write(str(cnt)+" "+str(values_x[a])+" "+str(values_y[a])+"\n")
cnt +=1
file.closed
listbox_l.insert('end', "The Measurement data is saved.")
listbox_l.see(END)
keith.outputOff()
time.sleep(1) #Sleep between each scan
Hx_start=Hx_start-Hx_step
amp.dacOutput(0, DACx)
amp.dacOutput(0, DAC)
listbox_l.insert('end',"Measurement finished")
listbox_l.see(END)
def measure_method(magnet, keith, plot_title, x_axis_label, y_axis_label):
# make sure delay and averages are ints
if fetch_entry('Delay (s)', keith).lstrip('-').replace('.', '',
1).isdigit():
delay = float(fetch_entry('Delay (s)', keith))
else:
messagebox.showwarning(
'Invalid Entry',
'Delay value not found to be a number, automatically set to 1')
delay = 1
if fetch_entry('Averages', keith).lstrip('-').replace('.', '',
1).isdigit():
avg = float(fetch_entry('Averages', keith))
else:
messagebox.showwarning(
'Invalid Entry',
'Delay value not found to be a number, automatically set to 1')
avg = 1
# set the scan and fixed applied field directions
if H_dir_loop == 'Hz':
scan = 'Hz'
scan_dac = DACz
scan_interval = float(fetch_entry('Hz (Oe)/DAC (V)', magnet))
scan_limit = 1
fix = 'Hx'
fix_dac = DACx
fix_interval = float(fetch_entry('Hx (Oe)/DAC (V)', magnet))
fix_limit = 12
else:
scan = 'Hx'
scan_dac = DACx
scan_interval = float(fetch_entry('Hx (Oe)/DAC (V)', magnet))
scan_limit = 12
fix = 'Hz'
fix_dac = DACz
fix_interval = float(fetch_entry('Hz (Oe)/DAC (V)', magnet))
fix_limit = 1
# create the lists of field values, scan loop is modified to include full loop
if field_loop == 'Step':
scan_field_output = make_list(
fetch_entry('%s Field (Oe)' % scan, magnet),
fetch_entry('%s Step (Oe)' % scan, magnet))
inverse = reversed(scan_field_output[0:-1])
for x in inverse:
scan_field_output.append(x)
fix_field_output = make_list(
fetch_entry('%s Field (Oe)' % fix, magnet),
fetch_entry('%s Step (Oe)' % fix, magnet))
else:
scan_field_output = convert_to_list(
fetch_entry('%s Field (Oe)' % scan, magnet))
inverse = reversed(scan_field_output[0:-1])
for x in inverse:
scan_field_output.append(x)
fix_field_output = convert_to_list(
fetch_entry('%s Field (Oe)' % fix, magnet))
# create the list of current values
if current_loop == 'Step':
current_output = make_list(fetch_entry('Current (mA)', keith),
fetch_entry('Current Step (mA)', keith))
else:
current_output = convert_to_list(fetch_entry('Current (mA)', keith))
keith_2400 = Keithley2400('f') #Initiate K2400
keith_2000 = Keithley('f') #Initiate K2000
amp = lockinAmp(func, sense, signal, freq) #Initiate Lock-in
def event():
# if in bounds run scan
for fix_val in fix_field_output:
amp.dacOutput(fix_val / fix_interval, fix_dac)
for current_val in current_output:
#Setup K2400 for current output and initial resistance measurements
keith_2400.fourWireOff()
keith_2400.setCurrent(current_val)
keith_2400.outputOn()
index = 1
data = []
while index <= 5: #Average of five measurements
data = data + keith_2400.measureOnce()
index += 1
display.insert('end',
"Measured current: %f mA" % (1000 * data[2]))
display.insert('end', "Measured voltage: %f V" % data[1])
display.insert(
'end', "Measured resistance: %f Ohm" % (data[1] / data[2]))
display.see(END)
resistance = data[1] / data[2]
# intializes the measurement data list
measured_values = []
# reset the plot to be clear for graphing
plot_set(plot_title, x_axis_label, y_axis_label)
display.insert('end',
'Measurement at %s (mA)' % str(current_val))
display.insert('end', 'Measurement at %s (Oe)' % str(fix_val))
display.see(END)
# loop over all scan values
for scan_val in scan_field_output:
amp.dacOutput(scan_val / scan_interval, scan_dac)
# allows amp output to power fully up at high values
if len(measured_values) < 5:
time.sleep(0.5)
data = keith_2000.measureMulti(avg)
tmp = float(
1000 * data /
current_val) # Voltage from K2000 / Current from K2400
measured_values.append(tmp)
ax.plot(scan_field_output[0:len(measured_values)],
measured_values,
'b-o',
ms=10,
mew=0.5,
alpha=0.5)
dataplot.draw()
display.insert(
'end',
'Applied %s Field Value: %s (Oe) Measured Resistance: %s (Ohm)'
% (scan, scan_val, round(tmp, 4)))
display.see(END)
# save data
save_method(fix_val, current_val, scan_field_output,
measured_values)
# sleep between cycles
time.sleep(delay)
# turn everything off at end of loop
amp.dacOutput(0, fix_dac)
amp.dacOutput(0, scan_dac)
keith_2400.fourWireOff()
keith_2400.outputOn()
display.insert('end', "Measurement finished")
display.see(END)
#check to make sure all output values are in bounds.
if max(fix_field_output) / fix_interval < fix_limit and max(
scan_field_output) / scan_interval < scan_limit:
th = threading.Thread(target=event)
th.start()
else:
messagebox.showwarning('Output Too Large',
'Output value beyond amp voltage threshold')
display.insert('end', 'Output value too large!')
display.see(END)
def event():
Hx_start = float(_Hx)
Hx_end = float(_Hx) * (-1)
Hx_step = float(_dHx)
keith = Keithley2400(f) #Initiate K2400
keith2000 = Keithley(f) #Initiate K2000
amp = lockinAmp(func, sense, signal, freq) #Initiate Lock-in
while Hx_start >= Hx_end:
amp.dacOutput((Hx_start / ix), DACx)
current_max = float(_current)
current_min = float(_current) * (-1)
current_step = float(_step)
#while current_start>=current_end:
ax.clear()
ax.grid(True)
ax.set_title("Realtime Resistance vs I Plot")
ax.set_xlabel("Applied Current (mA)")
ax.set_ylabel("Hall Resistance (Ohm)")
listbox_l.insert('end',
"Now measuring with Hx = %f (Oe)" % Hx_start)
listbox_l.see(END)
#Prepare data entries
global values_x, values_y, result
values_y = []
values_x = []
result = []
#Setup K2400 for current output and resistance measurement
keith.fourWireOff()
keith.setCurrent(0.1) #Use 0.1mA to measure DC resistance
keith.outputOn()
index = 1
data = []
while index <= 5: #Average of five measurements
data = data + keith.measureOnce()
index += 1
print("Measured current: %f mA" % (1000 * data[2]))
print("Measured voltage: %f V" % data[1])
print("Measured resistance: %f Ohm" % (data[1] / data[2]))
keith.outputOff()
#Setup Keithley for Idc sweep
current = 0 #starting current amplitude
current_sense = 0.01 #sensing current amplitude 0.1mA
#Pulse train parameters
write_pulse_width = 0.05
read_pulse_width = 0.05
write_read_pause = 0.05
period = 0.05
keith.outputOn()
while current < current_max:
#keith.outputOn()
keith.setCurrent(current) # Set switching current
time.sleep(write_pulse_width)
keith.setCurrent(0) # Reduce current amplitude to zero
#keith.outputOff()
time.sleep(write_read_pause)
#keith.outputOn()
keith.setCurrent(current_sense) # Set sensing current to 0.1mA
time.sleep(read_pulse_width)
data = keith2000.measureOnce()
keith.setCurrent(0) # Reduce current amplitude to zero
#keith.outputOff()
tmp = double(1000 * data[1] /
current_sense) # Voltage from K2000 / 0.1mA
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
#ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
ax.plot(values_x,
values_y,
'b-o',
ms=dot_size,
mew=dot_edge,
alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current += current_step
listbox_l.see(END)
time.sleep(period)
while current > current_min:
#keith.outputOn()
keith.setCurrent(current) # Set switching current
time.sleep(write_pulse_width)
keith.setCurrent(0) # Reduce current amplitude to zero
#keith.outputOff()
time.sleep(write_read_pause)
#keith.outputOn()
keith.setCurrent(current_sense) # Set sensing current to 0.1mA
time.sleep(read_pulse_width)
data = keith2000.measureOnce()
keith.setCurrent(0) # Reduce current amplitude to zero
#keith.outputOff()
tmp = double(1000 * data[1] /
current_sense) # Voltage from K2000 / 0.1mA
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
#ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
ax.plot(values_x,
values_y,
'b-o',
ms=dot_size,
mew=dot_edge,
alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current -= current_step
listbox_l.see(END)
time.sleep(period)
while current <= 0:
#keith.outputOn()
keith.setCurrent(current) # Set switching current
time.sleep(write_pulse_width)
keith.setCurrent(0) # Reduce current amplitude to zero
#keith.outputOff()
time.sleep(write_read_pause)
#keith.outputOn()
keith.setCurrent(current_sense) # Set sensing current to 0.1mA
time.sleep(read_pulse_width)
data = keith2000.measureOnce()
keith.setCurrent(0) # Reduce current amplitude to zero
#keith.outputOff()
tmp = double(1000 * data[1] /
current_sense) # Voltage from K2000 / 0.1mA
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
#ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
ax.plot(values_x,
values_y,
'b-o',
ms=dot_size,
mew=dot_edge,
alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current += current_step
listbox_l.see(END)
time.sleep(period)
#scat=ax.scatter(values_x, values_y, s=50, alpha=0.5)
#canvas.draw()
stamp = datetime.now().strftime('%Y-%m-%d-%H%M%S')
listbox_l.insert('end', str(stamp))
file = open(
str(directory) + "/MR_STT_switching_" + str(Hx_start) + "Oe_" +
str(stamp), "w")
file.write("Applied in-plane field: " + str(Hx_start) + "(Oe)\n\n")
file.write("Number" + " " + "Current(mA)" + " " +
"Resistance(Ohm)" + "\n")
cnt = 1
#output all data
for a in range(len(values_y)):
file.write(
str(cnt) + " " + str(values_x[a]) + " " +
str(values_y[a]) + "\n")
cnt += 1
file.closed
listbox_l.insert('end', "The Measurement data is saved.")
listbox_l.see(END)
#keith.outputOff()
time.sleep(1) #Sleep between each scan
Hx_start = Hx_start - Hx_step
amp.dacOutput(0, DACx)
amp.dacOutput(0, DAC)
keith.fourWireOff()
keith.outputOff()
listbox_l.insert('end', "Measurement finished")
listbox_l.see(END)
def event():
current_start=float(_current)
current_end=float(_current)*(-1)
current_step=float(_step)
keith=Keithley2400(f) #Initiate K2400
while current_start>=current_end:
ax.clear()
ax.grid(True)
ax.set_title("Realtime Hall voltage vs H Plot")
ax.set_xlabel("Applied Field (Oe)")
ax.set_ylabel("Lock-In X (mV)")
#Prepare data entries
global values_x, values_y, result
values_y=[]
values_x=[]
result=[]
#Setup K2400 for current output and resistance measurement
keith.setCurrent(current_start)
keith.outputOn()
index=1
data=[]
while index<=5: #Average of five measurements
data=data+keith.measureOnce()
index+=1
print("Measured current: %f mA" %(1000*data[2]))
print("Measured voltage: %f V" %data[1])
print("Measured resistance: %f Ohm" %(data[1]/data[2]))
#Setup lock-in for dac output
t=0
a=0.0
amp = lockinAmp(func, sense, signal, freq)
step = (double(_output)/i)/n
while t < n :
amp.dacOutput(a, DAC)
tmp=1000*double(amp.readX(average)) #in units of mV
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a+=step
listbox_l.see(END)
while t < 3*n :
amp.dacOutput(a, DAC)
tmp=1000*double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a-=step
listbox_l.see(END)
while t <= 4*n :
amp.dacOutput(a, DAC)
tmp=1000*double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a+=step
listbox_l.see(END)
#scat=ax.scatter(values_x, values_y, s=50, alpha=0.5)
#canvas.draw()
keith.outputOff()
current_start=current_start-current_step
time.sleep(1) #Sleep between each scan
listbox_l.insert('end',"Measurement finished")
listbox_l.see(END)
def measureMethod( _inteval, _number, _output, _average, _signal, _frequency):
global values_x, values_y, result
values_y=[]
values_x=[]
result=[]
i=float(_inteval)
n=int(_number)
average=int(_average)
signal=float(_signal)
freq=int(_frequency)
t=0
a=0.0
ax.clear()
ax.grid(True)
ax.set_title("Realtime Hall voltage vs H Plot")
ax.set_xlabel("Applied Field (Oe)")
ax.set_ylabel("Lock-In X (mV)")
#ax.axis([0, i*n, -10, 10])
#check if func is empty
if func == '':
listbox_l.insert('end',"Please select measurement mode.")
else:
amp = lockinAmp(func, sense, signal, freq)
step = (double(_output)/i)/n
while t < n :
amp.dacOutput(a, DAC)
tmp=1000*double(amp.readX(average)) #in units of mV
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a+=step
while t < 3*n :
amp.dacOutput(a, DAC)
tmp=1000*double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a-=step
while t <= 4*n :
amp.dacOutput(a, DAC)
tmp=1000*double(amp.readX(average))
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a+=step
listbox_l.insert('end',"Measurement finished")
listbox_l.see(END)
def measure_loop():
global scan_field_output, measured_values, curr_lbl, fix_lbl
# resets measured values to allow animate to properly render graph when starting a new measurement loop
measured_values = []
curr_lbl[0] = 0
fix_lbl[0] = 0
# set the scan and fixed applied field directions
if control_dict['H Scan Direction'].get() == 'Hz':
scan = 'Hz'
fix = 'Hx'; fix_lbl[1] = 'Hx'
else:
scan = 'Hx'
fix = 'Hz'; fix_lbl[1] = 'Hz'
# create the lists of field values, scan loop is modified to include full loop
if control_dict['Field Step'].get() == 'Step':
# builds list from step and max value
scan_field_output = make_list(mag_dict['%s Field (Oe)' % scan].get(), mag_dict['%s Step (Oe)' % scan].get())
# take inverse list and add it on, creating the full list values to measure at
inverse = reversed(scan_field_output[0:-1])
scan_field_output += inverse
fix_field_output = make_list(mag_dict['%s Field (Oe)' % fix].get(), mag_dict['%s Step (Oe)' % fix].get())
else:
# takes string and converts to list
scan_field_output = convert_to_list(mag_dict['%s Field (Oe)' % scan].get())
# take inverse list and add it on, creating the full list values to measure at
inverse = reversed(scan_field_output[0:-1])
scan_field_output += inverse
fix_field_output = convert_to_list(mag_dict['%s Field (Oe)' % fix].get())
# create the list of current values
if control_dict['I_app Step'].get() == 'Step':
current_output = make_list(keith_dict['Current (mA)'].get(), keith_dict['Current Step (mA)'].get())
else:
current_output = convert_to_list(keith_dict['Current (mA)'].get())
# ensures output voltages will not exceed amp thresholds
if max(fix_field_output) / float(control_dict['%s/DAC (Oe/V)' % fix]) < float(control_dict['%s DAC Limit' % fix]) \
and max(scan_field_output) / float(control_dict['%s/DAC (Oe/V)' % scan]) < float(control_dict['%s DAC Limit' % scan]):
# initialize machines
amp = lockinAmp(lockin_dict['Mode'], lockin_dict['Sensitivity'], lockin_dict['Signal Voltage'], lockin_dict['Frequency'])
keith_2400=Keithley2400('f') #Initiate K2400
keith_2000=Keithley('f') #Initiate K2000
# measurement loops - for fixed field value, measure at fixed current values, scan field and save
for fix_val in fix_field_output:
# fixed output strength and channel
amp.dacOutput((fix_val / float(control_dict['%s/DAC (Oe/V)' % fix])), control_dict['%s DAC Channel' % fix])
# sets legend value for current fixed field output
fix_lbl[0] = round(fix_val, 3)
for current_val in current_output:
# sets legend value for current applied current output
curr_lbl[0] = round(current_val, 3)
# setup K2400 here
keith_2400.fourWireOff()
keith_2400.setCurrent(round(current_val, 4))
print(current_val)
keith_2400.outputOn()
# take initial resistance measurement?
index=1
data=[]
while index<=5: #Average of five measurements
data=data+keith_2400.measureOnce()
index+=1
resistance = round(data[1]/data[2],4)
display.insert('end',"Measured current: %f mA" %(1000*data[2]))
display.insert('end',"Measured voltage: %f V" %data[1])
display.insert('end',"Measured resistance: %f Ohm" %(resistance))
display.see(END)
# intializes the measurement data list
measured_values = []
display.insert('end', 'Measurement at %s (mA)' % str(current_val))
display.insert('end', 'Measurement at %s (Oe)' % str(fix_val))
display.see(END)
# loop over all scan values
for counter, scan_val in enumerate(scan_field_output):
if counter == 0:
diff = abs(scan_val)
else:
diff = abs(scan_val - scan_field_output[counter-1])
amp.dacOutput(scan_val / float(control_dict['%s/DAC (Oe/V)' % scan]), control_dict['%s DAC Channel' % scan])
# sleep time set to allow electromagnets to get to strength
time.sleep(charging(diff))
data = keith_2000.measureMulti(int(keith_dict['Averages'].get()))
tmp = round(float(1000*data/current_val),4) # Voltage from K2000 / Current from K2400
measured_values.append(round(tmp, 4))
display.insert('end', 'Applied %s Field Value: %s (Oe) Measured Resistance: %s (Ohm)' %(scan, scan_val, round(tmp, 4)))
display.see(END)
# save data
save_method(control_dict['H Scan Direction'].get(), fix_val, current_val, \
scan_field_output, measured_values, display, control_dict['Directory'], control_dict['Measurement Type'].get(), control_dict['File Name'].get(), resistance)
# sleep between cycles
time.sleep(float(keith_dict['Delay (s)'].get()))
# turn everything off at end of loop
amp.dacOutput(0, control_dict['Hx DAC Channel'])
amp.dacOutput(0, control_dict['Hz DAC Channel'])
keith_2400.minimize()
time.sleep(0.1)
display.insert('end',"Measurement finished")
display.see(END)
else:
messagebox.showwarning('Output Too Large', 'Output value beyond amp voltage threshold')
display.insert('end', 'Output value too large!')
display.see(END)
def measure_loop():
global current_output, measured_values, fix_lbl, pulse_lbl
measured_values = []
fix_lbl[0] = 0
pulse_lbl[0] = 0
# create the lists of field values, scan loop is modified to include full loop
if control_dict['Field Step'].get() == 'Step':
# builds list from step and max value
fix_field_output = make_list(mag_dict['Hx Field (Oe)'].get(),
mag_dict['Hx Step (Oe)'].get())
else:
# takes string and converts to list
fix_field_output = convert_to_list(mag_dict['Hx Field (Oe)'].get())
# create the list of current values
if control_dict['I_app Step'].get() == 'Step':
current_output = make_list(keith_dict['Current (mA)'].get(),
keith_dict['Current Step (mA)'].get())
# take inverse list and add it on, creating the full list values to measure at
inverse = reversed(current_output[0:-1])
current_output += inverse
# sense list
pulse_output = make_list(keith_dict['Write Pulse Width (s)'].get(),
keith_dict['Write Pulse Step (s)'].get())
else:
current_output = convert_to_list(keith_dict['Current (mA)'].get())
# take inverse list and add it on, creating the full list values to measure at
inverse = reversed(current_output[0:-1])
current_output += inverse
# sense list
pulse_output = convert_to_list(
keith_dict['Write Pulse Width (s)'].get())
# ensures output voltages will not exceed amp thresholds
if max(fix_field_output) / float(
control_dict['Hx/DAC (Oe/V)']) < float(
control_dict['Hx DAC Limit']):
# initialize machines
amp = lockinAmp(lockin_dict['Mode'], lockin_dict['Sensitivity'],
lockin_dict['Signal Voltage'],
lockin_dict['Frequency'])
keith_2400 = Keithley2400('f') #Initiate K2400
keith_2000 = Keithley('f') #Initiate K2000
sense_val = float(keith_dict['Sensing Current (mA)'].get())
# measurement loops - measure pos and neg current at give scan value and take avg abs val (ohms)
for counter, fix_val in enumerate(fix_field_output):
fix_lbl[0] = round(fix_val, 3)
if counter == 0:
diff = abs(fix_val)
else:
diff = abs(fix_val - fix_field_output[counter - 1])
amp.dacOutput((fix_val / float(control_dict['Hx/DAC (Oe/V)'])),
control_dict['Hx DAC Channel'])
time.sleep(charging(diff))
for pulse_val in pulse_output:
pulse_lbl[0] = round(pulse_val, 3)
# setup K2400 here
keith_2400.fourWireOff()
keith_2400.setCurrent(sense_val)
keith_2400.outputOn()
# take initial resistance measurement?
index = 1
data = []
while index <= 5: #Average of five measurements
data = data + keith_2400.measureOnce()
index += 1
resistance = round(data[1] / data[2], 4)
display.insert(
'end', "Measured current: %f mA" % (1000 * data[2]))
display.insert('end', "Measured voltage: %f V" % data[1])
display.insert(
'end', "Measured resistance: %f Ohm" % (resistance))
display.see(END)
# intializes the measurement data list
measured_values = []
pos_values = []
neg_values = []
display.insert(
'end', 'Measurement using %s (s) write pulse width' %
str(pulse_val))
display.see(END)
for current_val in current_output:
# write pulse
keith_2400.setCurrent(round(current_val, 4))
time.sleep(
float(keith_dict['Write Pulse Width (s)'].get()))
keith_2400.setCurrent(0)
time.sleep(
float(keith_dict['Read Write Delay (s)'].get()))
# measurement at positive sensing current
keith_2400.setCurrent(round(sense_val, 4))
time.sleep(
float(keith_dict['Read Pulse Width (s)'].get()))
pos_data = keith_2000.measureMulti(
int(keith_dict['Averages'].get()))
time.sleep(float(keith_dict['Delay (s)'].get()))
# measurement at negative sensing current
keith_2400.setCurrent(round(-sense_val, 4))
time.sleep(
float(keith_dict['Read Pulse Width (s)'].get()))
neg_data = keith_2000.measureMulti(
int(keith_dict['Averages'].get()))
tmp = round(
float((abs(pos_data) - abs(neg_data)) * 1000 /
sense_val),
4) # voltage from K2000 / sense current
pos_values.append(abs(pos_data) * 1000 / sense_val)
neg_values.append(abs(neg_data) * 1000 / sense_val)
measured_values.append(tmp)
display.insert(
'end',
'Applied Pulse Strength: %s (mA) Measured Resistance: %s (Ohm)'
% (current_val, tmp))
display.see(END)
# save data
save_method(fix_val, pulse_val, current_output,
measured_values, display,
control_dict['Directory'],
control_dict['File Name'].get(), resistance,
pos_values, neg_values, sense_val)
# turn everything off at end of loop
amp.dacOutput(0, control_dict['Hx DAC Channel'])
keith_2400.minimize()
time.sleep(0.1)
display.insert('end', "Measurement finished")
display.see(END)
else:
messagebox.showwarning(
'Output Too Large',
'Output value beyond amp voltage threshold')
display.insert('end', 'Output value too large!')
display.see(END)
def event():
Hx_start = float(_Hx) # Max Hx field strength
Hx_end = float(_Hx) * (-1) # Min Hx field strength
Hx_step = float(_dHx) # step in Hx field per loop
keith = Keithley2400('CURR') #Initiate K2400
amp = lockinAmp(func, sense, signal, freq) #Initiate Lock-in
while Hx_start >= Hx_end:
amp.dacOutput((Hx_start / ix), DACx)
current_max = float(
_current) # max current applied by Keithley 2400
current_min = float(_current) * (
-1) # min current applied by Keithley 2400
current_step = float(_step) # current step per loop
ax.clear()
ax.grid(True)
ax.set_title("Realtime MOKE signal vs I Plot")
ax.set_xlabel("Applied Current (mA)")
ax.set_ylabel("MOKE signal (R+G+B)")
ax.set_title("Realtime Hall voltage vs I Plot")
ax.set_xlabel("Applied Current (mA)")
ax.set_ylabel("Lock-In X (mV)")
listbox_l.insert('end',
"Now measuring with Hx = %f (Oe)" % Hx_start)
listbox_l.see(END)
#Prepare data entries
global values_x, values_y, result
values_y = []
values_x = []
result = []
#Setup K2400 for current output and resistance measurement
keith.setCurrent(0.1) #Use 0.1mA to measure DC resistance
keith.outputOn()
index = 1
data = []
while index <= 5: #Average of five measurements
data = data + keith.measureOnce()
index += 1
print("Measured current: %f mA" % (1000 * data[2]))
print("Measured voltage: %f V" % data[1])
print("Measured resistance: %f Ohm" % (data[1] / data[2]))
save = (data[1] / data[2])
#Setup Keithley for Idc sweep
current = 0
trigger_delay = float(_rest_length)
source_delay = float(_pulse_length)
while current < current_max:
keith.pulse(current, current_max, trigger_delay, source_delay)
tmp = imageMethod(x1, y1, x2, y2) #get image lumi
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current += current_step
listbox_l.see(END)
while current > -current_max:
keith.pulse(current, current_max, trigger_delay, source_delay)
tmp = imageMethod(x1, y1, x2, y2) #get image lumi
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current -= current_step
listbox_l.see(END)
while current <= 0:
keith.pulse(current, current_max, trigger_delay, source_delay)
tmp = imageMethod(x1, y1, x2, y2) #get image lumi
result.append(tmp)
values_y.append(tmp)
values_x.append(current)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
current += current_step
listbox_l.see(END)
stamp = datetime.now().strftime('%Y-%m-%d-%H%M%S')
file = open(
str(directory) + "/" + str(_sample) + "_pulse_switching" +
str(Hx_start) + "Oe" + "_" + str(stamp), "w")
file.write(str(_sample) + "\n")
file.write("Initial resistance: " + str(save) + "(Ohm)\n")
file.write("Applied in-plane field: " + str(Hx_start) + "(Oe)\n\n")
file.write("Number" + " " + "Field(Oe)" + " " +
"MOKE signal(RGB)" + "\n")
cnt = 1
#output all data
for a in range(len(values_y)):
file.write(
str(cnt) + " " + str(values_x[a]) + " " +
str(values_y[a]) + "\n")
cnt += 1
file.closed
listbox_l.insert('end', "The Measurement data is saved.")
listbox_l.see(END)
keith.outputOff()
time.sleep(1) #Sleep between each scan
Hx_start = Hx_start - Hx_step
amp.dacOutput(0, DACx)
amp.dacOutput(0, DAC)
listbox_l.insert('end', "Measurement finished")
listbox_l.see(END)
def event():
Hx_start=float(_Hx)
Hx_end=float(_Hx)*(-1)
Hx_step=float(_dHx)
keith=Keithley2400(f) #Initiate K2400
amp = lockinAmp(func, sense, signal, freq) #Initiate Lock-in
while Hx_start>=Hx_end:
amp.dacOutput((Hx_start/ix), DACx)
current_start=float(_current)
current_end=float(_current)*(-1)
current_step=float(_step)
while current_start>=current_end:
ax.clear()
ax.grid(True)
ax.set_title("Realtime MOKE signal vs H Plot")
ax.set_xlabel("Applied Field (Oe)")
ax.set_ylabel("MOKE signal (R+G+B)")
listbox_l.insert('end',"Now measuring with Hx = %f (Oe) and Idc = %f (mA) " %(Hx_start,current_start))
listbox_l.see(END)
#Prepare data entries
global values_x, values_y, result
values_y=[]
values_x=[]
result=[]
#Setup K2400 for current output and resistance measurement
keith.setCurrent(current_start)
keith.outputOn()
index=1
data=[]
while index<=5: #Average of five measurements
data=data+keith.measureOnce()
index+=1
print("Measured current: %f mA" %(1000*data[2]))
print("Measured voltage: %f V" %data[1])
print("Measured resistance: %f Ohm" %(data[1]/data[2]))
#Setup lock-in for dac (Hz field) output
t=0
a=0.0
step = (double(_output)/i)/n
while t < n :
amp.dacOutput(a, DAC)
tmp=imageMethod(x1,y1,x2,y2) #get image lumi
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a+=step
listbox_l.see(END)
while t < 3*n :
amp.dacOutput(a, DAC)
tmp=imageMethod(x1,y1,x2,y2) #get image lumi
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a-=step
listbox_l.see(END)
while t <= 4*n :
amp.dacOutput(a, DAC)
tmp=imageMethod(x1,y1,x2,y2) #get image lumi
result.append(tmp)
values_y.append(tmp)
values_x.append(a*i)
ax.scatter(values_x[-1], values_y[-1], s=50, alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
t+=1
a+=step
listbox_l.see(END)
#scat=ax.scatter(values_x, values_y, s=50, alpha=0.5)
#canvas.draw()
file = open(str(directory)+"/sample_name_"+str(Hx_start)+"Oe_"+str(current_start)+"mA", "w")
file.write("Applied in-plane field: "+str(Hx_start)+"(Oe)\n")
file.write("Applied current: "+str(current_start)+"(mA)\n\n")
file.write("Number"+" "+"Field(Oe)"+" "+"Voltage(mV)"+"\n")
cnt=1
#output all data
for a in range(len(values_y)):
file.write(str(cnt)+" "+str(values_x[a])+" "+str(values_y[a])+"\n")
cnt +=1
file.closed
listbox_l.insert('end', "The Measurement data is saved.")
listbox_l.see(END)
keith.outputOff()
current_start=current_start-current_step
time.sleep(1) #Sleep between each scan
Hx_start=Hx_start-Hx_step
amp.dacOutput(0, DACx)
amp.dacOutput(0, DAC)
listbox_l.insert('end',"Measurement finished")
listbox_l.see(END)
def event():
Hx_start = float(_Hx_init) # Initial Hx field strength
Hx_step = float(_dHx) # Hx step for loop
keith = Keithley2400() #Initiate K2400
amp = lockinAmp(func, sense, signal, freq) #Initiate Lock-in
#Prepare data entries
global values_x, values_y, result, dot_size, dot_edge
values_y = []
values_x = []
result = []
dot_size = 10 #Set a default data dot size
dot_edge = 0.5 #Set a default data dot edge width
while Hx_start <= Hx_end:
amp.dacOutput((Hx_start / ix), DACx)
volt_sensitivity = float(
_volt_sensitivity
) # sensitivity requirement to count as successful switching event
ax.clear()
ax.grid(True)
ax.set_title("Switching Probability vs Applied Field Plot")
ax.set_xlabel("Applied Field (Oe)")
ax.set_ylabel("Switching Probability (HV %)")
listbox_l.insert('end',
"Now measuring with Hx = %f (Oe)" % Hx_start)
listbox_l.see(END)
index = 1
data = []
#Setup Keithley for Voltage Pulse
voltage = 0
voltage_max = 3
#initialize while loop, set count to compare
n = 0
total = 0
trigger_delay = float(_rest_length)
source_delay = float(_pulse_length)
while n < number:
#RUN setZfield
amp.dacOutput((Hz / i), DAC)
time.sleep(1)
amp.dacOutput(0, DAC)
time.sleep(
2
) #necessary to allow reset field to clear before measurement is taken
#voltage running in X direction
take1 = 1000 * double(amp.readX(average))
#RUN setAppliedField
amp.dacOutput((Hx_start / ix), DACx)
#RUN triggerPulse
keith.vpulse(2, voltage_max, trigger_delay, source_delay)
#reset AppliedField
amp.dacOutput(0, DACx)
#voltage running in X direction
take2 = 1000 * double(amp.readX(average))
#RUN compareSwitch
if compareSwitch(take1, take2, volt_sensitivity) == True:
total += 1
n += 1
tmp = (total / n) * 100
result.append(tmp)
values_y.append(tmp)
values_x.append(Hx_start)
ax.plot(values_x,
values_y,
'b-o',
ms=dot_size,
mew=dot_edge,
alpha=0.5)
canvas.draw()
listbox_l.insert('end', tmp)
listbox_l.see(END)
keith.outputOff()
time.sleep(1) #Sleep between each scan
Hx_start = Hx_start + Hx_step
amp.dacOutput(0, DACx)
amp.dacOutput(0, DAC)
listbox_l.insert('end', "Measurement finished")
listbox_l.see(END)
file = open(str(directory)+"/"+str(_sample)+str(Hx_end)+"Oe"+str(_pulse_amp)+\
"dB"+str(_pulse_duration)+"ns", "w")
file.write("" + str(_sample))
file.write("Pulse Generator set to: " + str(_pulse_amp) + "(dB)" +
str(_pulse_duration) + "(ns)\n")
file.write("The voltage sensitivity was set to " +
str(_volt_sensitivity) + "(mV)\n")
file.write("Applied in-plane field: " + str(Hx_end) + "(Oe)\n\n")
file.write("Number" + " " + "Field(Oe)" + " " + "Voltage(mV)" + "\n")
cnt = 1
#output all data
for a in range(len(values_y)):
file.write(
str(cnt) + " " + str(values_x[a]) + " " + str(values_y[a]) +
"\n")
cnt += 1
file.closed
listbox_l.insert('end', "The Measurement data is saved.")
listbox_l.see(END)
def measure_loop():
global current_output, measured_values, fix_lbl, pulse_lbl
measured_values = []
fix_lbl[0] = 0
pulse_lbl[0] = 0
# set the scan and fixed applied field directions
fix = control_dict['H Scan Direction'].get()
# create the lists of field values, scan loop is modified to include full loop
if control_dict['Field Step'].get() == 'Step':
fix_field_output = make_list(mag_dict['%s Field (Oe)' % fix].get(), mag_dict['%s Step (Oe)' % fix].get())
else:
fix_field_output = convert_to_list(mag_dict['%s Field (Oe)' % fix].get())
# create the list of current values
if control_dict['I_app Step'].get() == 'Step':
current_output = make_list(keith_dict['Current (mA)'].get(), keith_dict['Current Step (mA)'].get())
inverse = reversed(current_output[0:-1])
current_output += inverse
pulse_width = make_list(keith_dict['Write Pulse Width (s)'].get(), keith_dict['Write Pulse Step (s)'].get())
else:
current_output = convert_to_list(keith_dict['Current (mA)'].get())
inverse = reversed(current_output[0:-1])
current_output += inverse
pulse_width = convert_to_list(keith_dict['Write Pulse Width (s)'])
# ensures output voltages will not exceed amp thresholds
if max(fix_field_output) / float(control_dict['%s/DAC (Oe/V)' % fix]) < float(control_dict['%s DAC Limit' % fix]):
# initialize machines
amp = lockinAmp(lockin_dict['Mode'], lockin_dict['Sensitivity'], lockin_dict['Signal Voltage'], lockin_dict['Frequency'])
keith_2400=Keithley2400('f') #Initiate K2400
keith_2000=Keithley('f') #Initiate K2000
# measurement loops - for fixed field value, scan current values and measure and save
for counter, fix_val in enumerate(fix_field_output):
fix_lbl[0] = round(fix_val, 3)
if counter == 0:
diff = abs(fix_val)
else:
diff = abs(fix_val - fix_field_output[counter-1])
amp.dacOutput((fix_val / float(control_dict['%s/DAC (Oe/V)' % fix])), control_dict['%s DAC Channel' % fix])
time.sleep(charging(diff))
for pulse in pulse_width:
pulse_lbl[0] = round(pulse, 3)
# setup K2400 here
keith_2400.fourWireOff()
keith_2400.setCurrent(float(keith_dict['Sensing Current (mA)'].get()))
keith_2400.outputOn()
# take initial resistance measurement?
index=1
data=[]
while index<=5: #Average of five measurements
data=data+keith_2400.measureOnce()
index+=1
resistance = round(data[1]/data[2], 3)
display.insert('end',"Measured current: %f mA" %(1000*data[2]))
display.insert('end',"Measured voltage: %f V" %data[1])
display.insert('end',"Measured resistance: %f Ohm" %(resistance))
display.see(END)
# intializes the measurement data list
measured_values = []
display.insert('end', 'Measurement with %s (s) write pulse width' % str(pulse))
display.see(END)
for current_val in current_output:
keith_2400.setCurrent(round(current_val,4))
time.sleep(pulse)
keith_2400.setCurrent(0)
time.sleep(float(keith_dict['Delay (s)'].get()))
keith_2400.setCurrent(float(keith_dict['Sensing Current (mA)'].get()))
time.sleep(float(keith_dict['Read Pulse Width (s)'].get()))
data=keith_2000.measureMulti(int(keith_dict['Averages'].get()))
tmp = round(float(1000 * data / float(keith_dict['Sensing Current (mA)'].get())), 4)
measured_values.append(tmp)
display.insert('end', 'Applied Pulse Strength: %s (mA) Measured Resistance: %s (Ohm)' %(round(current_val,4), tmp))
display.see(END)
# save data
save_method(control_dict['H Scan Direction'].get(), fix_val, pulse, \
current_output, measured_values, display, control_dict['Directory'], control_dict['File Name'].get(), resistance)
# turn everything off at end of loop
amp.dacOutput(0, control_dict['%s DAC Channel' % fix])
keith_2400.minimize()
time.sleep(0.1)
display.insert('end',"Measurement finished")
display.see(END)
else:
messagebox.showwarning('Output Too Large', 'Output value beyond amp voltage threshold')
display.insert('end', 'Output value too large!')
display.see(END)
