File Programming CV

hp4194/cv.py

@@ -5,6 +5,8 @@ from help import *
 import time
 from IPython.display import clear_output
 import numpy as np
+import datetime
+import pandas as pd
 
 
 #connect to device
@@ -32,7 +34,6 @@ add_widgets_to_list(view,all_widgets)
 add_widgets_to_list(sweep_parameter_dict,all_widgets)
 add_widgets_to_list(messparameter_dict,all_widgets)
 
-fig, axs = 
 def on_measure_clicked(b):
     with out:
         clear_output()
@@ -88,138 +89,175 @@ def on_measure_clicked(b):
         f_values = []
         G_values = []
         B_values = []
-        log_f = []
-        omega = []
-        Z = []
-        phi = []
-        D = []
-        Cs =[]
-        Cp =[]
-        Cp_area =[]
-        Cs_area = []
-        ReZ = []
-        ImZ = []
-        G_f_omega = []
+        log_f_values = []
+        omega_values = []
+        Z_values = []
+        phi_values = []
+        D_values = []
+        Cs_values =[]
+        Cp_values =[]
+        Cp_area_values =[]
+        Cs_area_values = []
+        ReZ_values = []
+        ImZ_values = []
+        G_area_omega_values = []
+        U_values = []
+        area_values = []
         
     
         num_of_points =int(abs(messparameter_dict["stop"].value-messparameter_dict["start"].value)/abs(messparameter_dict["step"].value) + 1)
-        area = np.pi * radius**2
+        area = np.pi * radius**2 # in um2
+        area = area * 10**(-8) # in cm2  
         biases = np.linspace(messparameter_dict["start"].value,messparameter_dict["stop"].value,num_of_points,endpoint = True)
     
         for bias in biases:
+            view["v-value"].value = bias 
+            U_values.extend([bias]*sweep_parameter_dict['nop'].value)
+            area_values.extend([area]*sweep_parameter_dict['nop'].value)
             device.set_parameter('set_bias', bias) #set the bias
             device.write('start_sweep') #start the measurement
             device.wait() #wait for completition
             
             # read the registers
             
-            freq = device.read_register('reg_sweep')
-            G = device.read_register('reg_A')
-            B = device.read_register('reg_B')
+            freq = np.array(device.read_register('reg_sweep'))
+            f_values.extend(freq)
+            G = np.array(device.read_register('reg_A'))
+            G_values.extend(G)
+            B = np.array(device.read_register('reg_B'))
+            B_values.extend(B)
 
     
             time.sleep(messparameter_dict["sleep"].value)
 
             #do the calculations
+            log_f = np.log10(freq)
+            log_f_values.extend(log_f)
+            
+            omega = 2*np.pi*freq
+            omega_values.extend(omega)
+
+            log_omega = np.log10(omega)
+            log_omega_values.extend(omega)
+
+            Y_complex = G + 1j*B
+            Z_complex = 1/Y_complex
+
+            Z = np.absolute(Z_complex)
+            Z_values.extend(Z)
+            phi = np.angle(Z_complex, deg = True)
+            phi_values.extend(phi)
+
+            D = G/B
+            D_values.extend(D)
+                
+            Cp = B/omega
+            Cp_values.extend(Cp)
+
+            Cs = Cp*(1+D**(2))
+            Cs_values.extend(Cs)
+
+            Cp_area = Cp/area
+            Cp_area_values.extend(Cp_area)
+
+            Cs_area = Cs/area
+            Cs_area_values.extend(Cs_area)
+
+            ReZ = np.real(Z_complex)
+            ImZ = np.imag(Z_complex)
+            ReZ_values.extend(Rez)
+            ImZ_values.extend(ImZ)
+
+            G_area_omega= G_p/area/omega
+            G_area_values.extend(G_area_omega)
+    
            
-            f_values.extend(freq)
-            G_values.extend(G)
-            B_vlaues.extend(B)
-            
-            for i in range(len(freq)):
-                log_f.append(np.log10(freq[i]))
-                omega.append(2*np.pi*freq[i])
-                log_omega.append(np.log10(omega))
-                polar = cmath.polar(1/complex(G[i],B[i]))
-                Z .append(polar[0])
-                phi.append(180/np.pi * polar[1]) #in deg
-                D.append(G[i]/B[i])
-                Cp.append(B[i]/omega)
-                Cs.append(Cp*(1+D**(2)))
-                Cp_area.append(Cp/area)
-                Cs_area.append(Cs/area)
-                Z_complex = cmath.rect(polar[0],polar[1])
-                ReZ.append(Z_complex.real)
-                ImZ.append(Z_complex.imag)
-                G_f_omega.append(G_p/area/omega)
-    
-            # Do A test plot
-            fig,ax1 = plt.subplots()
-            
-            color = 'b'
-            ax1.set_xlabel('Frequency (Hz)')
-            ax1.set_ylabel('G (S)', color=color)
-            ax1.plot(current_freq,current_G , color=color)
-            ax1.tick_params(axis='y', labelcolor=color)
-    
-            ax2 = ax1.twinx()
-            color = 'y'
-            ax2.set_ylabel('B (S)', color=color)  # we already handled the x-label with ax1
-            ax2.plot(current_freq,current_B, color=color)
-            ax2.tick_params(axis='y', labelcolor=color)
-    
-            fig.suptitle(f"Results for Bias = {bias}V")
-            fig.tight_layout()
-            display(fig)
     
         if messparameter_dict["hysterisis"].value == True:
             reversed_biases = reversed_array(biases)
             for bias in reversed_biases:
+                U_values.extend([bias]*sweep_parameter_dict['nop'].value)
+                area_values.extend([area]*sweep_parameter_dict['nop'].value)
                 device.set_parameter('set_bias', bias) #set the bias
                 device.write('start_sweep') #start the measurement
                 device.wait() #wait for completition
                 
                 # read the registers
             
-                freq = device.read_register('reg_sweep')
-                G = device.read_register('reg_A')
-                B = device.read_register('reg_B')
-        
-                time.sleep(messparameter_dict["sleep"].value)
-
+                freq = np.array(device.read_register('reg_sweep'))
                 f_values.extend(freq)
+                G = np.array(device.read_register('reg_A'))
                 G_values.extend(G)
-                B_vlaues.extend(B)
+                B = np.array(device.read_register('reg_B'))
+                B_values.extend(B)
+    
+        
+                time.sleep(messparameter_dict["sleep"].value)
     
                 #do the calculations
-                for i in range(len(freq)):
-                    log_f.append(np.log10(freq[i]))
-                    omega.append(2*np.pi*freq[i])
-                    log_omega.append(np.log10(omega))
-                    polar = cmath.polar(1/complex(G[i],B[i]))
-                    Z.append(polar[0])
-                    phi.append(180/np.pi * polar[1]) #in deg
-                    D.append(G[i]/B[i])
-                    Cp.append(B[i]/omega)
-                    Cs.append(Cp*(1+D**(2)))
-                    Cp_area.append(Cp/area)
-                    Cs_area.append(Cs/area)
-                    Z_complex = cmath.rect(polar[0],polar[1])
-                    ReZ.append(Z_complex.real)
-                    ImZ.append(Z_complex.imag)
-                    G_f_omega.append(G_p/area/omega)
-            
-                # Do A test plot
-                fig,ax1 = plt.subplots()
-                
-                color = 'b'
-                ax1.set_xlabel('Frequency (Hz)')
-                ax1.set_ylabel('G (S)', color=color)
-                ax1.plot(freq,G , color=color)
-                ax1.tick_params(axis='y', labelcolor=color)
-        
-                ax2 = ax1.twinx()
-                color = 'y'
-                ax2.set_ylabel('B (S)', color=color)  # we already handled the x-label with ax1
-                ax2.plot(freq,B, color=color)
-                ax2.tick_params(axis='y', labelcolor=color)
-        
-                fig.suptitle(f"Results for Bias = {bias}V")
-                fig.tight_layout()
-                display(fig)
+                log_f = np.log10(freq)
+                log_f_values.extend(log_f)
+                
+                omega = 2*np.pi*freq
+                omega_values.extend(omega)
+    
+                log_omega = np.log10(omega)
+                log_omega_values.extend(omega)
+    
+                Y_complex = G + 1j*B
+                Z_complex = 1/Y_complex
+    
+                Z = np.absolute(Z_complex)
+                Z_values.extend(Z)
+                phi = np.angle(Z_complex, deg = True)
+                phi_values.extend(phi)
+    
+                D = G/B
+                D_values.extend(D)
+                    
+                Cp = B/omega
+                Cp_values.extend(Cp)
+    
+                Cs = Cp*(1+D**(2))
+                Cs_values.extend(Cs)
+    
+                Cp_area = Cp/area
+                Cp_area_values.extend(Cp_area)
+    
+                Cs_area = Cs/area
+                Cs_area_values.extend(Cs_area)
+    
+                ReZ = np.real(Z_complex)
+                ImZ = np.imag(Z_complex)
+                ReZ_values.extend(Rez)
+                ImZ_values.extend(ImZ)
+    
+                G_area_omega= G_p/area/omega
+                G_area_omega_values.extend(G_area_omega)
+           
             
         device.write('bias_off')
 
+        # save to file
+        with open(file,'w') as f:
+            dt = datetime.now().replace(second=0, microsecond=0)
+            f.write(f'# Measurement started at {dt}'+"\n")
+            f.write(f"# Wafer {sample_dict['wafer'].value} Sample {sample_dict['sample'].value} Comment {sample_dict['comment'].value} Temperature {sample_dict['temperature'].value}" +"\n")
+            f.write(f"# V_start {messparameter_dict['start'].value} V V_stop {messparameter_dict['stop'].value} V V_step {messparameter_dict['step'].value} V"+"\n")
+            f.write(f"# f_start {sweep_parameter_dict['stop'].value} Hz f_stop {sweep_parameter_dict['stop'].value} Hz no_steps {sweep_parameter_dict['nop'].value} SweepType {sweep_parameter_dict['type'].value}"+"\n")
+            f.write(f"# OSC {sweep_parameter_dict['osc'].value} V"+"\n")
+            f.write(f"# integration time {sweep_parameter_dict['integration'].value} averaging {sweep_parameter_dict['averaging'].value}"+"\n")
+            f.write(f"area {area} cm^2"+"\n")
+            f.write("\n")
+
+        # create the dataframe
+        dictionary = {"U(V)": U_values, "A(cm^2)":area_values,"f(Hz)":f_values ,"log_f(Hz)":log_f_values,"omega(1/s)":omega_values,"log_omega(1/s)":log_omega_values,"Z(Ohm)":Z_values,"Phi(°)":phi_values, "G(S)":G_values,"B(S)":B_values,"D":D_values,"Cs(F)":Cs_values, "Cs_area(F/cm^2)":Cs_area_values,"Cp(F)":Cp_values,"Cp_area(F/cm^2)":Cp_area_values,"ReZ(Ohm)":ReZ_values,"ImZ(Ohm)":ImZ,"G_area/omega(S*s/cm^2)":G_area_omega_values}
+
+        df = pd.DataFrame(dictionary)
+
+        #save the dictionary
+        df.to_csv(file,sep=" ",mode='a')
+
         information_box("measurement finished")
         change_state(all_widgets)