diff --git a/hp4155/ADU for double gate devices-test/double_gate_ADU.py b/hp4155/ADU for double gate devices-test/double_gate_ADU.py
index 8f445058ce95a2149a7bd269503f6a47905e9663..f598a0cda01d24a1b9bb122f2288fea98a6f5ac1 100644
--- a/hp4155/ADU for double gate devices-test/double_gate_ADU.py
+++ b/hp4155/ADU for double gate devices-test/double_gate_ADU.py
@@ -7,6 +7,7 @@ from interface import *
from help import *
from measurements import *
import configparser
+import quick
# Create the grids
#create the information grid
@@ -60,12 +61,13 @@ tab.titles = titles
display(tab)
button = widgets.Button(description ='Start Measurement')
+quick_button = widgets.Button(description = 'Quick Measurement')
output = widgets.Output()
export_ini_button = widgets.Button(description = 'Export as ini')
import_ini_button = widgets.Button(description='Import from ini')
-all_widgets =[transfer_gates,output_gates,button,transfer_check,integration_transfer,output_check,integration_output,gatediode_check,integration_gatediode,terminal,export_ini_button,import_ini_button]
+all_widgets =[transfer_gates,output_gates,button,transfer_check,integration_transfer,output_check,integration_output,gatediode_check,integration_gatediode,terminal,export_ini_button,import_ini_button,quick_button]
add_widgets_to_list(sample,all_widgets)
add_widgets_to_list(smu_map,all_widgets)
@@ -77,7 +79,7 @@ add_widgets_to_list(Vtg_output,all_widgets)
add_widgets_to_list(Vbg_output,all_widgets)
add_widgets_to_list(Vg_gatediode,all_widgets)
-line = widgets.HBox([button,import_ini_button,export_ini_button])
+line = widgets.HBox([button,quick_button,import_ini_button,export_ini_button])
display(line,output)
device = hp4155a.HP4155a('GPIB0::17::INSTR')
@@ -447,7 +449,374 @@ def on_start_clicked(b):
information_box("Measurement finished!")
enable_widgets(all_widgets)
-
+
+
+def on_quick_clicked(b):
+ with output:
+ clear_output()
+ #disable all widgets
+ disable_widgets(all_widgets)
+
+ #additional code to check smu configuration fast without modifing a lot of code
+ try:
+ check_configuration(smu_map)
+ except Exception as e:
+ error_box(e)
+ enable_widgets(all_widgets)
+ return
+
+ Setup(device) #setup the device
+
+ #for all measurements the same (copy the interface with values for parameter setting)
+ map = smu_map.copy()
+ for key,value in map.items():
+ map[key]= value.value
+
+ sample_copy = sample.copy()
+ for key,value in sample_copy.items():
+ sample_copy[key]=value.value
+
+ smu_s = device.smu_dict()
+ smu_s.update(vname ='VS',iname = 'IS',mode = 'COMM',func='CONS') #Source smu is always grounded
+
+ if transfer_check.value == True:
+ plot = plot_transfer.copy()
+ for key,value in plot.items():
+ plot[key] = value.value
+
+ points = number_of_points(Vds_transfer)
+
+ var2=device.var2_dict() #Vds_output is always used in tranfer curve with the same config
+ var2.update(
+ start=Vds_transfer['start'].value,
+ step=Vds_transfer['step'].value,
+ points=points,
+ comp=Vds_transfer['comp'].value,
+ pcomp=Vds_transfer['pcomp'].value,
+ stop = Vds_transfer['stop'].value #not important for setting VAR2 only parameters in file
+ )
+
+ # also drain smu is the same
+ smu_d = device.smu_dict()
+ smu_d.update(vname='VDS',iname='ID',mode = 'V',func = 'VAR2')
+ match transfer_gates.value:
+ case 'VTG' if check_values(Vtg_transfer,'primary') and check_values(Vds_transfer,'secondary'):
+ smu_t = device.smu_dict()
+ smu_t.update(vname = 'VTG',iname='ITG',mode = 'V',func='VAR1')
+ smu_b = device.smu_dict()
+ smu_b.update(vname = 'VBG',iname='IBG',mode = 'COMM',func = 'CONS')
+
+ var1 = device.var1_dict()
+ var1.update(
+ mode=Vtg_transfer['hyst'].value,
+ start=Vtg_transfer['start'].value,
+ stop=Vtg_transfer['stop'].value,
+ step=Vtg_transfer['step'].value,
+ comp =Vtg_transfer['comp'].value,
+ pcomp=Vtg_transfer['pcomp'].value
+ )
+ #define the final dict
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_T":smu_t,
+ "SMU_D": smu_d,
+ "SMU_B":smu_b,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "VAR2":var2,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_transfer.value,
+ }
+ #measure (later)
+ quick.Transfer_VTG(device,meas_dict)
+
+ case 'VBG' if check_values(Vbg_transfer,'primary') and check_values(Vds_transfer,'secondary'):
+ smu_t = device.smu_dict()
+ smu_t.update(vname = 'VTG',iname='ITG',mode = 'COMM',func='CONS')
+ smu_b = device.smu_dict()
+ smu_b.update(vname = 'VBG',iname='IBG',mode = 'V',func = 'VAR1')
+
+ var1 = device.var1_dict()
+ var1.update(
+ mode=Vbg_transfer['hyst'].value,
+ start=Vbg_transfer['start'].value,
+ stop=Vbg_transfer['stop'].value,
+ step=Vbg_transfer['step'].value,
+ comp =Vbg_transfer['comp'].value,
+ pcomp=Vbg_transfer['pcomp'].value
+ )
+
+ #define the final dict
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_T":smu_t,
+ "SMU_D": smu_d,
+ "SMU_B":smu_b,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "VAR2":var2,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_transfer.value,
+ }
+ #measure (later)
+ quick.Transfer_VBG(device,meas_dict)
+
+
+ case 'BOTH' if check_values(Vbg_transfer,'synchronous') and check_values(Vds_transfer,'secondary') and check_values(Vtg_transfer,'primary'):
+ smu_t = device.smu_dict()
+ smu_t.update(vname = 'VTG',iname='ITG',mode = 'V',func='VAR1')
+ smu_b = device.smu_dict()
+ smu_b.update(vname = 'VBG',iname='IBG',mode = 'V',func = 'VARD')
+
+ var1 = device.var1_dict()
+ var1.update(
+ mode=Vtg_transfer['hyst'].value,
+ start=Vtg_transfer['start'].value,
+ stop=Vtg_transfer['stop'].value,
+ step=Vtg_transfer['step'].value,
+ comp =Vtg_transfer['comp'].value,
+ pcomp=Vtg_transfer['pcomp'].value
+ )
+
+ #calculate parameters for VARD
+ ratio,offset = calculate_line(Vtg_transfer,Vbg_transfer)
+
+ # update VBG step
+ Vbg_transfer["step"].value = Decimal(str(ratio)) * Decimal(str(Vtg_transfer["step"].value))
+
+
+ vard = device.vard_dict()
+ vard.update(
+ offset = offset,
+ ratio = ratio,
+ comp = Vbg_transfer["comp"].value,
+ pcomp = Vbg_transfer["pcomp"].value,
+ start = Vbg_transfer["start"].value,
+ step = Vbg_transfer['step'].value,
+ stop = Vbg_transfer['stop'].value,
+ )
+
+ #define the final dict
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_T":smu_t,
+ "SMU_D": smu_d,
+ "SMU_B":smu_b,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "VAR2":var2,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_transfer.value,
+ "VARD":vard
+ }
+
+ #measure (later)
+ quick.Transfer_BOTH(device,meas_dict)
+ case _ :
+ information_box("Transfer Measurement skipped due to invalid parameters")
+
+ if output_check.value == True:
+ smu_d = device.smu_dict()
+ smu_d.update(vname='VDS',iname='ID',mode = 'V',func = 'VAR1')
+
+ var1 = device.var1_dict()
+ var1.update(
+ mode=Vds_output['hyst'].value,
+ start=Vds_output['start'].value,
+ stop=Vds_output['stop'].value,
+ step=Vds_output['step'].value,
+ comp =Vds_output['comp'].value,
+ pcomp=Vds_output['pcomp'].value
+ )
+
+ plot = plot_output.copy()
+ for key,value in plot.items():
+ plot[key] = value.value
+
+ match output_gates.value:
+ case 'VTG' if check_values(Vds_output,'primary') and check_values(Vtg_output,'secondary'):
+ smu_t=device.smu_dict()
+ smu_t.update(vname ='VTG',iname = 'ITG',mode = 'V',func='VAR2')
+
+ smu_b= device.smu_dict()
+ smu_b.update(vname='VBG',iname='IBG',mode = 'COMM',func='CONS')
+
+ points = number_of_points(Vtg_output)
+
+ var2=device.var2_dict()
+ var2.update(
+ start=Vtg_output['start'].value,
+ step=Vtg_output['step'].value,
+ points=points,
+ comp=Vtg_output['comp'].value,
+ pcomp=Vtg_output['pcomp'].value,
+ stop = Vtg_output['stop'].value
+ )
+
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_T":smu_t,
+ "SMU_D": smu_d,
+ "SMU_B":smu_b,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "VAR2":var2,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_output.value,
+ }
+
+ #measure later
+ quick.Output_VTG(device,meas_dict)
+
+ case 'VBG' if check_values(Vds_output,'primary') and check_values(Vbg_output,'secondary'):
+ smu_t=device.smu_dict()
+ smu_t.update(vname ='VTG',iname = 'ITG',mode = 'COMM',func='CONS')
+
+ smu_b= device.smu_dict()
+ smu_b.update(vname='VBG',iname='IBG',mode = 'V',func = 'VAR2')
+
+ points = number_of_points(Vbg_output)
+
+ var2=device.var2_dict()
+ var2.update(
+ start=Vbg_output['start'].value,
+ step=Vbg_output['step'].value,
+ points=points,
+ comp=Vbg_output['comp'].value,
+ pcomp=Vbg_output['pcomp'].value,
+ stop = Vbg_output['stop'].value
+ )
+
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_T":smu_t,
+ "SMU_D": smu_d,
+ "SMU_B":smu_b,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "VAR2":var2,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_output.value,
+ }
+
+ #measure later
+ quick.Output_VBG(device,meas_dict)
+
+
+ case 'BOTH' if check_values(Vds_output,'primary') and check_values(Vtg_output,'secondary') and check_values(Vbg_output,'secondary'):
+ smu_t=device.smu_dict()
+ smu_t.update(vname ='VTG',iname = 'ITG',mode = 'V',func='VAR2')
+
+ smu_b= device.smu_dict()
+ smu_b.update(vname='VBG',iname='IBG',mode = 'V',func = 'CONS')
+
+ points = number_of_points(Vtg_output)
+
+ var2=device.var2_dict()
+ var2.update(
+ start=Vtg_output['start'].value,
+ step=Vtg_output['step'].value,
+ points=points,
+ comp=Vtg_output['comp'].value,
+ pcomp=Vtg_output['pcomp'].value,
+ stop = Vtg_output['stop'].value
+ )
+
+ points_VBG = number_of_points(Vbg_output)
+ values_VBG = np.linspace(Vbg_output["start"].value,Vbg_output["stop"].value,num = points_VBG,endpoint= True)
+
+ #there is not such unit we create it with a loop
+ var3 = {
+ "start":Vbg_output['start'].value,
+ "step":Vbg_output['step'].value,
+ "points":points_VBG,
+ "comp":Vbg_output['comp'].value,
+ "stop" : Vbg_output['stop'].value,
+ "values" : values_VBG
+ }
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_T":smu_t,
+ "SMU_D": smu_d,
+ "SMU_B":smu_b,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "VAR2":var2,
+ "VAR3":var3,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_output.value,
+ }
+
+ #measure later
+ quick.Output_BOTH(device,meas_dict)
+
+ case _ :
+ information_box("Output Measurement skipped due to invalid parameters")
+
+
+ if gatediode_check.value == True:
+ #drain is disabled
+ device.smu_disable(map['D'])
+
+ # VAR1 is set with the same interface
+ var1 = device.var1_dict()
+ var1.update(
+ mode=Vg_gatediode['hyst'].value,
+ start=Vg_gatediode['start'].value,
+ stop=Vg_gatediode['stop'].value,
+ step=Vg_gatediode['step'].value,
+ comp =Vg_gatediode['comp'].value,
+ pcomp=Vg_gatediode['pcomp'].value
+ )
+
+ plot = plot_gatediode.copy()
+ for key,value in plot.items():
+ plot[key] = value.value
+
+ match terminal.value:
+ case 'VTG' if check_values(Vg_gatediode,'primary'):
+ smu_t=device.smu_dict()
+ smu_t.update(vname ='VTG',iname = 'ITG',mode = 'V',func='VAR1')
+
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_T":smu_t,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_gatediode.value,
+ }
+ #measure later
+ quick.Gatediode_VTG(device,meas_dict)
+
+ case 'VBG' if check_values(Vg_gatediode,'primary'):
+ smu_b=device.smu_dict()
+ smu_b.update(vname ='VBG',iname = 'IBG',mode = 'V',func='VAR1')
+
+ meas_dict = {
+ "SAMPLE":sample_copy,
+ "MAP" : map,
+ "SMU_B":smu_b,
+ "SMU_S":smu_s,
+ "VAR1":var1,
+ "PLOT": plot, # plot in the tool
+ "INTEGRATION": integration_gatediode.value,
+ }
+ #measure later
+ quick.Gatediode_VBG(device,meas_dict)
+
+ case _ :
+ information_box("Gatediode Measurement skipped due to invalid parameters")
+
+ information_box("Measurement finished!")
+ enable_widgets(all_widgets)
def on_export_ini_clicked(b):
with output:
@@ -603,6 +972,7 @@ def on_import_ini_clicked(b):
button.on_click(on_start_clicked)
+quick_button.on_click(on_quick_clicked)
import_ini_button.on_click(on_import_ini_clicked)
export_ini_button.on_click(on_export_ini_clicked)
diff --git a/hp4155/ADU for double gate devices-test/lib/quick.py b/hp4155/ADU for double gate devices-test/lib/quick.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa4b489a848582252d3258da87d76c98a9293a94
--- /dev/null
+++ b/hp4155/ADU for double gate devices-test/lib/quick.py
@@ -0,0 +1,769 @@
+# New measurements file for ADU
+
+# The new measurements will have the smus configuration as a parameter and written from the interface
+
+import sys
+sys.path.insert(0, '..') #append parent directory
+
+import hp4155a
+from help import *
+from decimal import Decimal
+
+import os
+
+def Setup(device):
+ device.reset()
+
+ #setup sweep measurement mode
+ device.measurement_mode('SWE')
+
+ #disable all irrelevant units
+ device.disable_not_smu()
+
+# Transfer only VTG
+def Transfer_VTG(device,params):
+ # calculate normalization factor
+
+ norm = normalization_factor(params["SAMPLE"]["width"])
+ try:
+ device.setup_smu(params["MAP"]['TG'],params["SMU_T"])
+ device.setup_smu(params["MAP"]['D'],params["SMU_D"])
+ device.setup_smu(params["MAP"]['BG'],params["SMU_B"])
+ device.setup_smu(params["MAP"]['S'],params["SMU_S"])
+
+ device.setup_var1(params["VAR1"])
+ device.setup_var2(params["VAR2"])
+
+ device.integration_time(params["INTEGRATION"])
+
+ variables_list =["VTG","ITG","VDS","ID"]
+ device.variables_to_save(variables_list)
+
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ device.single_measurement()
+ while device.operation_completed()==False:
+ pass
+
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+ except Exception as e:
+ error_box(e)
+ return
+
+ # Append the normalized current
+ df["IDmm/uA/um"]= (df["ID/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["ITGmm/uA/um"]= (df["ITG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_TOP_GATE_U.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Transfer Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gate:VTG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VTG from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+ f.write(f"VDS from {params['VAR2']['start']}V to {params['VAR2']['stop']}V with step {params['VAR2']['step']}V"+"\n")
+
+ if params['VAR1']['pcomp']==0:
+ f.write(f"Top Gate Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Top Gate Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+
+ if params['VAR2']['pcomp'] == 0:
+ f.write(f"Drain Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Drain Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+ f.write("\nResults\n")
+
+ df.to_csv(file,sep=" ",mode='a')
+
+# Transfer only VBG
+def Transfer_VBG(device,params):
+ try:
+ device.setup_smu(params["MAP"]['TG'],params["SMU_T"])
+ device.setup_smu(params["MAP"]['D'],params["SMU_D"])
+ device.setup_smu(params["MAP"]['BG'],params["SMU_B"])
+ device.setup_smu(params["MAP"]['S'],params["SMU_S"])
+
+
+ device.setup_var1(params["VAR1"])
+ device.setup_var2(params["VAR2"])
+
+ device.integration_time(params["INTEGRATION"])
+
+
+ variables_list =["VBG","IBG","VDS","ID"]
+ device.variables_to_save(variables_list)
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+ device.single_measurement()
+ while device.operation_completed()==False:
+ pass
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+
+ except Exception as e:
+ error_box(e)
+ return
+ # calculate normalization factor
+ norm = normalization_factor(params["SAMPLE"]["width"])
+
+ # Append the normalized current
+ df["IDmm/uA/um"]= (df["ID/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["IBGmm/uA/um"]= (df["IBG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_BACK_GATE_U.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Transfer Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gate:VBG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VBG from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+ f.write(f"VDS from {params['VAR2']['start']}V to {params['VAR2']['stop']}V with step {params['VAR2']['step']}V"+"\n")
+
+ #calculate the values
+ if params['VAR1']['pcomp']==0:
+ f.write(f"Back Gate Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Back Gate Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+
+ if params['VAR2']['pcomp'] == 0:
+ f.write(f"Drain Current Compliance/A:{params['VAR2']['comp']}"+"\n")
+ else:
+ f.write(f"Drain Power Compliance/A:{params['VAR2']['pcomp']}"+"\n")
+
+
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+
+ f.write("\nResults\n")
+
+ df.to_csv(file,sep=" ",mode='a')
+
+
+def Transfer_BOTH(device,params):
+ try:
+ smu_t = device.smu_dict()
+ smu_t.update(vname = 'VTG',iname='ITG',mode = 'V',func='VAR1')
+
+ smu_b = device.smu_dict()
+ smu_b.update(vname = 'VBG',iname='IBG',mode = 'V',func = 'VARD')
+
+ device.setup_smu(params["MAP"]['TG'],params["SMU_T"])
+ device.setup_smu(params["MAP"]['D'],params["SMU_D"])
+ device.setup_smu(params["MAP"]['BG'],params["SMU_B"])
+ device.setup_smu(params["MAP"]['S'],params["SMU_S"])
+
+
+ device.setup_var1(params["VAR1"])
+ device.setup_var2(params["VAR2"])
+ device.setup_vard(params["VARD"])
+
+ device.integration_time(params["INTEGRATION"])
+
+ variables_list =["VBG","IBG","VDS","ID","VTG","ITG"]
+ device.variables_to_save(variables_list)
+
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ device.single_measurement()
+ while device.operation_completed()==False:
+ pass
+
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+ except Exception as e:
+ error_box(e)
+ return
+
+ # calculate normalization factor
+ norm = normalization_factor(params["SAMPLE"]["width"])
+
+ # Append the normalized current
+ df["IDmm/uA/um"]= (df["ID/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["IBGmm/uA/um"]= (df["IBG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["ITGmm/uA/um"]= (df["ITG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_BOTH_GATES_U.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Transfer Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gates:VBG,VTG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VBG from {params['VARD']['start']}V to {params['VARD']['stop']}V with step {params['VARD']['step']}V"+"\n")
+ f.write(f"VTG from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+ f.write(f"VDS from {params['VAR2']['start']}V to {params['VAR2']['stop']}V with step {params['VAR2']['step']}V"+"\n")
+
+ #calculate thes
+ if params['VARD']['pcomp']==0:
+ f.write(f"Back Gate Current Compliance/A:{params['VARD']['comp']}"+"\n")
+ else:
+ f.write(f"Back Gate Power Compliance/A:{params['VARD']['pcomp']}"+"\n")
+
+ if params['VAR1']['pcomp']==0:
+ f.write(f"Top Gate Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Top Gate Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+
+ if params['VAR2']['pcomp'] == 0:
+ f.write(f"Drain Current Compliance/A:{params['VAR2']['comp']}"+"\n")
+ else:
+ f.write(f"Drain Power Compliance/A:{params['VAR2']['pcomp']}"+"\n")
+
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+
+ f.write("\nResults\n")
+
+ df.to_csv(file,sep=" ",mode='a')
+# Output with VTG
+def Output_VTG(device,params):
+ try:
+ device.setup_smu(params['MAP']['TG'],params["SMU_T"])
+ device.setup_smu(params['MAP']['D'],params["SMU_D"])
+ device.setup_smu(params['MAP']['BG'],params["SMU_B"])
+ device.setup_smu(params['MAP']['S'],params["SMU_S"])
+
+ device.setup_var1(params["VAR1"])
+ device.setup_var2(params["VAR2"])
+
+ device.integration_time(params["INTEGRATION"])
+
+ variables_list = ['VDS','ID','VTG','ITG']
+ device.variables_to_save(variables_list)
+
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+ device.single_measurement()
+
+ while device.operation_completed()==False:
+ pass
+
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+ except Exception as e:
+ error_box(e)
+ return
+
+ norm = normalization_factor(params['SAMPLE']["width"])
+
+ # Append the normalized current
+ df["IDmm/uA/um"]= (df["ID/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["ITGmm/uA/um"]= (df["ITG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_TOP_GATE_A.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Output Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gate:VTG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VTG from {params['VAR2']['start']}V to {params['VAR2']['stop']}V with step {params['VAR2']['step']}V"+"\n")
+ f.write(f"VDS from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+
+ #calculate the values
+ if params['VAR2']['pcomp']==0:
+ f.write(f"Top Gate Current Compliance/A:{params['VAR2']['comp']}"+"\n")
+ else:
+ f.write(f"Top Gate Power Compliance/A:{params['VAR2']['pcomp']}"+"\n")
+
+ if params['VAR1']['pcomp'] == 0:
+ f.write(f"Drain Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Drain Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+
+ f.write("\nResults\n")
+
+ df.to_csv(file,sep=" ",mode='a')
+
+
+#Output VBG
+def Output_VBG(device,params):
+ try:
+ device.setup_smu(params["MAP"]['TG'],params["SMU_T"])
+ device.setup_smu(params["MAP"]['D'],params["SMU_D"])
+ device.setup_smu(params["MAP"]['BG'],params["SMU_B"])
+ device.setup_smu(params["MAP"]['S'],params["SMU_S"])
+
+
+ device.setup_var1(params["VAR1"])
+ device.setup_var2(params["VAR2"])
+
+ device.integration_time(params["INTEGRATION"])
+
+ variables_list = ['VDS','ID','VBG','IBG']
+ device.variables_to_save(variables_list)
+
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ device.single_measurement()
+
+ while device.operation_completed()==False:
+ pass
+
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ # calculate normalization factor
+ norm = normalization_factor(params["SAMPLE"]["width"])
+
+ # Append the normalized current
+ df["IDmm/uA/um"]= (df["ID/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["IBGmm/uA/um"]= (df["IBG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_BACK_GATE_A.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Output Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gate:VBG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VBG from {params['VAR2']['start']}V to {params['VAR2']['stop']}V with step {params['VAR2']['step']}V"+"\n")
+ f.write(f"VDS from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+
+ #calculate the values
+ if params['VAR2']['pcomp']==0:
+ f.write(f"Back Gate Current Compliance/A:{params['VAR2']['comp']}"+"\n")
+ else:
+ f.write(f"Back Gate Power Compliance/A:{params['VAR2']['pcomp']}"+"\n")
+
+ if params['VAR1']['pcomp'] == 0:
+ f.write(f"Drain Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Drain Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+
+ f.write("\nResults\n")
+ df.to_csv(file,sep=" ",mode='a')
+
+# Output both
+def Output_BOTH(device,params):
+ try:
+ device.setup_smu(params["MAP"]['TG'],params["SMU_T"])
+ device.setup_smu(params["MAP"]['D'],params["SMU_D"])
+ device.setup_smu(params["MAP"]['BG'],params["SMU_B"])
+ device.setup_smu(params["MAP"]['S'],params["SMU_S"])
+
+
+ device.setup_var1(params["VAR1"])
+ device.setup_var2(params["VAR2"])
+
+
+ device.integration_time(params["INTEGRATION"])
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ variables_list = ['VDS','ID','VBG','IBG','VTG','ITG']
+ device.variables_to_save(variables_list)
+
+ for i , value in enumerate(params["VAR3"]['values']):
+ cons = device.cons_smu_dict()
+ cons.update(comp = params['VAR3']['comp'],value = value)
+ device.setup_cons_smu(params['MAP']['BG'],cons)
+
+ if i == 0:
+ device.single_measurement()
+ else:
+ device.append_measurement()
+
+ while device.operation_completed()==False:
+ pass
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ # calculate normalization factor
+ norm = normalization_factor(params["SAMPLE"]["width"])
+
+ # Append the normalized current
+ df["IDmm/uA/um"]= (df["ID/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["IBGmm/uA/um"]= (df["IBG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+ df["ITGmm/uA/um"]= (df["ITG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_BOTH_GATES_A.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Output Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gates:VBG,VTG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VBG from {params['VAR3']['start']}V to {params['VAR3']['stop']}V with step {params['VAR3']['step']}V"+"\n")
+ f.write(f"VTG from {params['VAR2']['start']}V to {params['VAR2']['stop']}V with step {params['VAR2']['step']}V"+"\n")
+ f.write(f"VDS from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+
+
+ #calculate the values
+ f.write(f"Back Gate Current Compliance/A:{params['VAR3']['comp']}"+"\n")
+
+ if params['VAR2']['pcomp']==0:
+ f.write(f"Top Gate Current Compliance/A:{params['VAR2']['comp']}"+"\n")
+ else:
+ f.write(f"Top Gate Power Compliance/A:{params['VAR2']['pcomp']}"+"\n")
+
+
+ if params['VAR1']['pcomp'] == 0:
+ f.write(f"Drain Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Drain Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+
+ f.write("\nResults\n")
+
+ df.to_csv(file,sep=" ",mode='a')
+
+def Gatediode_VTG(device,params):
+ try:
+ device.setup_smu(params["MAP"]['TG'],params["SMU_T"])
+ device.smu_disable(params["MAP"]['BG'])
+ device.setup_smu(params["MAP"]['S'],params["SMU_S"])
+
+ device.setup_var1(params["VAR1"])
+
+ device.integration_time(params["INTEGRATION"])
+
+ variables_list = ['VTG','ITG']
+ device.variables_to_save(variables_list)
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ device.single_measurement()
+
+ while device.operation_completed()==False:
+ pass
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+ except Exception as e:
+ error_box(e)
+ return
+
+ # calculate normalization factor
+ norm = normalization_factor(params['SAMPLE']["width"])
+
+ # Append the normalized current
+ df["ITGmm/uA/um"]= (df["ITG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_TOP_GATE_D.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Gatediode Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gate:VTG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VTG from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+
+ #calculate the values
+ if params['VAR1']['pcomp']==0:
+ f.write(f"Top Gate Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Top Gate Power Compliance/A:{params['VAR1']['pcomp'].value}"+"\n")
+
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+
+ f.write("\nResults\n")
+
+ df.to_csv(file,sep=" ",mode='a')
+
+
+def Gatediode_VBG(device,params):
+ try:
+ device.setup_smu(params["MAP"]['BG'],params["SMU_B"])
+ device.smu_disable(params["MAP"]['TG'])
+ device.setup_smu(params["MAP"]['S'],params["SMU_S"])
+
+ device.setup_var1(params["VAR1"])
+
+ device.integration_time(params["INTEGRATION"])
+
+ variables_list = ['VBG','IBG']
+ device.variables_to_save(variables_list)
+
+ try:
+ plotted_variables = graph_tool(params,device)
+ except Exception as e:
+ error_box(e)
+ return
+
+
+ device.single_measurement()
+ while device.operation_completed()==False:
+ pass
+
+ device.error_occured()
+
+ values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+ df = get_dataframe_from_results(values)
+ except Exception as e:
+ error_box(e)
+ return
+
+ # plot results
+
+ # calculate normalization factor
+ norm = normalization_factor(params["SAMPLE"]["width"])
+
+ # Append the normalized current
+ df["IBGmm/uA/um"]= (df["IBG/A"].apply(lambda x: Decimal(str(x))*Decimal(str(norm)))).astype('float')
+
+ # Save the results
+ default_filename = f"{params['SAMPLE']['sample']}_{params['SAMPLE']['field']}_{params['SAMPLE']['device']}_BACK_GATE_D.txt"
+
+ root = tk.Tk()
+ root.withdraw()
+ root.lift() #show window above all other applications
+
+ root.attributes("-topmost", True)#window stays above all other applications
+
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ #check if the file path is correct(.txt)
+ while file.endswith(".txt") == False:
+ #open again filedialog with error message box
+ tk.messagebox.showerror(message='invalid filename!')
+ file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =default_filename)
+
+ root.destroy()
+
+ with open(file,'w') as f:
+ date = str(datetime.today().replace(microsecond=0))
+ f.write(f"Gatediode Curve at {date}"+"\n")
+ f.write(f"Series:{params['SAMPLE']['processing_number']}"+"\n")
+ f.write(f"Sample:{params['SAMPLE']['sample']}"+"\n")
+ f.write(f"Field:{params['SAMPLE']['field']}"+"\n")
+ f.write(f"Device:{params['SAMPLE']['device']}"+"\n")
+ f.write(f"Device Width/um:{params['SAMPLE']['width']}"+"\n")
+ f.write("Sweeping Gate:VBG"+"\n\n")
+
+ f.write('Parameters\n')
+ f.write(f"VBG from {params['VAR1']['start']}V to {params['VAR1']['stop']}V with step {params['VAR1']['step']}V"+"\n")
+
+ #calculate the values
+ if params['VAR1']['pcomp']==0:
+ f.write(f"Back Gate Current Compliance/A:{params['VAR1']['comp']}"+"\n")
+ else:
+ f.write(f"Back Gate Power Compliance/A:{params['VAR1']['pcomp']}"+"\n")
+
+ f.write(f"Integration Time:{params['INTEGRATION']}"+"\n")
+
+ f.write("\nResults\n")
+
+ df.to_csv(file,sep=" ",mode='a')
\ No newline at end of file
diff --git a/hp4155/memristor (Version 4.1)/memristor.py b/hp4155/memristor (Version 4.1)/memristor.py
index 83c2d6b056615cb301ad0f3c89fa20eb6169d169..af681660e359fc27e931b9ae591a29b5da7d6be0 100644
--- a/hp4155/memristor (Version 4.1)/memristor.py
+++ b/hp4155/memristor (Version 4.1)/memristor.py
@@ -308,7 +308,7 @@ def on_set_button_clicked(b):
plot_sweep(V12,I12,'SET')
df = create_data_frame(V12,I12)
if voltmeter.value == True:
- df["V3-V1 (V)"] = np.array(device.return_values("VMEAS"))
+ df["(V3-V1)(V)"] = np.array(device.return_values("VMEAS"))
display(df)
@@ -358,7 +358,7 @@ def on_reset_button_clicked(b):
plot_sweep(V34,I34,'RESET')
df = create_data_frame(V34,I34)
if voltmeter.value == True:
- df["V3-V1 (V)"] = np.array(device.return_values("VMEAS"))
+ df["(V3-V1)(V)"] = np.array(device.return_values("VMEAS"))
display(df)
if sampling.value == True: #do sampling set after reset process(100mV)
@@ -489,7 +489,7 @@ def on_full_button_clicked(b):
#create data frame and save to file
df = create_data_frame(V,I)
if voltmeter.value == True:
- df["V3-V1 (V)"] = V_meas
+ df["(V3-V1)(V)"] = V_meas
display(df)
if i == 0 :
header.extend([f"{i+1} Iteration"])