diff --git a/PythonScripts/Calibration.py b/PythonScripts/Calibration.py
index 1eb7c6b578da84ec8c18ce95d83865c99a379a1a..f313dbe09172dba4b21c7d339600aebe2a94f43f 100644
--- a/PythonScripts/Calibration.py
+++ b/PythonScripts/Calibration.py
@@ -1,180 +1,220 @@
 import numpy as np
 from scipy.optimize import curve_fit
 import matplotlib.pyplot as plt
+import matplotlib.font_manager as font_manager
 from matplotlib.offsetbox import AnchoredText
 import sys
-## Performs linear fit for calibration
+from sigfig import round
 
-def FitAndPlot(xp, xm, z1p, z1m, z2p, z2m, z3p, z3m, zAllp, zAllm, Voltage, plots, raw):
-    #Linewidth
-    lw = 0.8
-    
-    #
-    if(plots):
-        if(raw):
-            plt.title("Calibration Measurement " + str(Voltage))
-            plt.plot(xp, z1p, marker=".", color="tab:blue", label="z1-", linewidth=lw)
-            plt.plot(xp, z1m, marker=".", color="b", label="z1+", linewidth=lw)
-            plt.plot(xp, z2p, marker=".", color="tab:red", label="z2-", linewidth=lw)
-            plt.plot(xp, z2m, marker=".", color="chocolate", label="z2+", linewidth=lw)
-            plt.plot(xp, z3p, marker=".", color="tab:green", label="z3-", linewidth=lw)
-            plt.plot(xp, z3m, marker=".", color="darkolivegreen", label="z3+", linewidth=lw)
-            plt.plot(xp, zAllp, marker=".", color="tab:purple", label="zAll-", linewidth=lw)
-            plt.plot(xp, zAllm, marker=".", color="m", label="zAll+", linewidth=lw)
-            plt.ylabel(r"Measured Movement [$\mu m$]")
-            plt.xlabel("# of step")
-            plt.legend()
-            plt.grid()
-            plt.savefig("Plots\Calibration\\" + str(Voltage) + "_All_Data.pdf")
-            plt.show()
-         
-    # Fit 
-    # Errors are 1/sqrt(12) * one pixel length in mikrometers
-    error_z1 = 8.87 / np.sqrt(12)
-    error_z2 = 9.62 / np.sqrt(12)
-    error_z3 = 9.80 / np.sqrt(12)
-    error_zAll = 9.00 / np.sqrt(12)
-    
-    popt_z1p, pcov_z1p = curve_fit(linear, xp, z1p, error_z1)
-    popt_z1m, pcov_z1m = curve_fit(linear, xp, z1m, error_z1)
-    popt_z2p, pcov_z2p = curve_fit(linear, xp, z2p, error_z2)
-    popt_z2m, pcov_z2m = curve_fit(linear, xp, z2m, error_z2)
-    popt_z3p, pcov_z3p = curve_fit(linear, xp, z3p, error_z3)
-    popt_z3m, pcov_z3m = curve_fit(linear, xp, z3m, error_z3)
-    popt_zAllp, pcov_zAllp = curve_fit(linear, xp, zAllp, error_zAll)
-    popt_zAllm, pcov_zAllm = curve_fit(linear, xp, zAllm, error_zAll)
-    
-    # Chi squared Computation per degree of freedom 
-    chi_z1p = np.sum(((z1p - linear(xp, popt_z1p[0]))**2 / error_z1**2)) / (len(z1p) - 1)
-    chi_z1m = np.sum(((z1m - linear(xp, popt_z1m[0]))**2 / error_z1**2)) / (len(z1m) - 1)
-    chi_z2p = np.sum(((z2p - linear(xp, popt_z2p[0]))**2 / error_z2**2)) / (len(z2p) - 1)
-    chi_z2m = np.sum(((z2m - linear(xp, popt_z2m[0]))**2 / error_z2**2)) / (len(z2m) - 1)
-    chi_z3p = np.sum(((z3p - linear(xp, popt_z3p[0]))**2 / error_z3**2)) / (len(z3p) - 1)
-    chi_z3m = np.sum(((z3m - linear(xp, popt_z3m[0]))**2 / error_z3**2)) / (len(z3m) - 1)
-    chi_zAllp = np.sum(((zAllp - linear(xp, popt_zAllp[0]))**2 / error_zAll**2)) / (len(zAllp) - 1)
-    chi_zAllm = np.sum(((zAllm - linear(xp, popt_zAllm[0]))**2 / error_zAll**2)) / (len(zAllm) - 1)
-    
-    # Plots
-    fig, ax = plt.subplots(2, 2)
-    fig.set_figheight(9)
-    fig.set_figwidth(16)
+#plt.rcParams['font.family'] = 'monospace'
 
-    # Z1 
-    capsize = 2
-    if(plots):
-        ax[0,0].set_title("Z1 calibration fit " + str(Voltage))
-        ax[0,0].set_xlabel("# of steps")
-        ax[0,0].set_ylabel(r"Measured Movement [$\mu m$]")
-        ax[0,0].errorbar(xp, z1p, error_z1, linestyle="none", marker=".", linewidth=lw, color="tab:blue", label="z1- data", capsize=capsize)
-        ax[0,0].errorbar(xp, z1m, error_z1, linestyle="none", marker=".", linewidth=lw, color="b", label="z1+ data", capsize=capsize)
-        ax[0,0].plot(xp, linear(xp, popt_z1p[0]), linewidth=lw, color="tab:blue", label="z1- fit")
-        ax[0,0].plot(xp, linear(xp, popt_z1m[0]), linewidth=lw, color="b", label="z1+ fit")
-    
-        #ax = plt.gca()
-        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z1p[0] * 1000, np.sqrt(pcov_z1p[0][0]) * 1000, chi_z1p) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z1m[0] * 1000, np.sqrt(pcov_z1m[0][0]) * 1000, chi_z1m), loc=4)
-        ax[0,0].add_artist(anchored_text)
-        
-        ax[0,0].legend()
-        plt.grid()
-        #plt.savefig("Plots\Calibration\Z1_" + str(Voltage) + ".pdf")
-        #plt.show()
-    
-    print("slope in nm/step z1-:", popt_z1p[0] * 1000, " +- ", np.sqrt(pcov_z1p[0][0]) * 1000, " chi^2 ", chi_z1p)
-    print("slope in nm/step z1+:", popt_z1m[0] * 1000, " +- ", np.sqrt(pcov_z1m[0][0]) * 1000, " chi^2 ", chi_z1m)
-    
-    #Z2
-    if(plots):
-        ax[0,1].set_title("Z2 calibration fit " + str(Voltage))
-        ax[0,1].set_xlabel("# of steps")
-        ax[0,1].set_ylabel(r"Measured Movement [$\mu m$]")
-        ax[0,1].errorbar(xp, z2p, error_z2, linestyle="none", marker=".", linewidth=lw, color="tab:red", label="z2- data", capsize=capsize)
-        ax[0,1].errorbar(xp, z2m, error_z2, linestyle="none", marker=".", linewidth=lw, color="chocolate", label="z2+ data", capsize=capsize)
-        ax[0,1].plot(xp, linear(xp, popt_z2p[0]), linewidth=lw, color="tab:red", label="z2- fit")
-        ax[0,1].plot(xp, linear(xp, popt_z2m[0]), linewidth=lw, color="chocolate", label="z2+ fit")
-    
-        #ax = plt.gca()
-        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z2p[0] * 1000, np.sqrt(pcov_z2p[0][0]) * 1000, chi_z2p) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z2m[0] * 1000, np.sqrt(pcov_z2m[0][0]) * 1000, chi_z2m), loc=4)
-        ax[0,1].add_artist(anchored_text)
-        
-        ax[0,1].legend()
-        plt.grid()
-        #plt.savefig("Plots\Calibration\Z2_" + str(Voltage) + ".pdf")
-        #plt.show()
-    
-    print("slope in nm/step z2-:", popt_z2p[0] * 1000, " +- ", np.sqrt(pcov_z2p[0][0]) * 1000, " chi^2 ", chi_z2p)
-    print("slope in nm/step z2+:", popt_z2m[0] * 1000, " +- ", np.sqrt(pcov_z2m[0][0]) * 1000, " chi^2 ", chi_z2m)
-    
-    #Z3
-    if(plots):
-        ax[1,0].set_title("Z3 calibration fit " + str(Voltage))
-        ax[1,0].set_xlabel("# of steps")
-        ax[1,0].set_ylabel(r"Measured Movement [$\mu m$]")
-        ax[1,0].errorbar(xp, z3p, error_z3, linestyle="none", marker=".", linewidth=lw, color="tab:green", label="z3- data", capsize=capsize)
-        ax[1,0].errorbar(xp, z3m, error_z3, linestyle="none", marker=".", linewidth=lw, color="darkolivegreen", label="z3+ data", capsize=capsize)
-        ax[1,0].plot(xp, linear(xp, popt_z3p[0]), linewidth=lw, color="tab:green", label="z3- fit")
-        ax[1,0].plot(xp, linear(xp, popt_z3m[0]), linewidth=lw, color="darkolivegreen", label="z3+ fit")
-    
-        #ax = plt.gca()
-        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z3p[0] * 1000, np.sqrt(pcov_z3p[0][0]) * 1000, chi_z3p) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z3m[0] * 1000, np.sqrt(pcov_z3m[0][0]) * 1000, chi_z3m), loc=4)
-        ax[1,0].add_artist(anchored_text)
-        
-        ax[1,0].legend()
-        plt.grid()
-        #plt.savefig("Plots\Calibration\Z3_" + str(Voltage) + ".pdf")
-        #plt.show()
-    
-    print("slope in nm/step z3-:", popt_z3p[0] * 1000, " +- ", np.sqrt(pcov_z3p[0][0]) * 1000, " chi^2 ", chi_z3p)
-    print("slope in nm/step z3+:", popt_z3m[0] * 1000, " +- ", np.sqrt(pcov_z3m[0][0]) * 1000, " chi^2 ", chi_z3p)
-    
-    #ZALL
-    if(plots):
-        ax[1,1].set_title("ZAll calibration fit " + str(Voltage))
-        ax[1,1].set_xlabel("# of steps")
-        ax[1,1].set_ylabel(r"Measured Movement [$\mu m$]")
-        ax[1,1].errorbar(xp, zAllp, error_zAll, linestyle="none", marker=".", linewidth=lw, color="tab:purple", label="zAll- data", capsize=capsize)
-        ax[1,1].errorbar(xp, zAllm, error_zAll, linestyle="none", marker=".", linewidth=lw, color="m", label="zAll+ data", capsize=capsize)
-        ax[1,1].plot(xp, linear(xp, popt_zAllp[0]), linewidth=lw, color="tab:purple", label="zAll- fit")
-        ax[1,1].plot(xp, linear(xp, popt_zAllm[0]), linewidth=lw, color="m", label="zAll+ fit")
-    
-        #ax = plt.gca()
-        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_zAllp[0] * 1000, np.sqrt(pcov_zAllp[0][0]) * 1000, chi_zAllp) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_zAllm[0] * 1000, np.sqrt(pcov_zAllm[0][0]) * 1000, chi_zAllm), loc=4)
-        ax[1,1].add_artist(anchored_text)
-        
-        ax[1,1].legend()
-        plt.grid()
-        plt.savefig("Plots\Calibration\Z_" + str(Voltage) + ".pdf")
-        plt.savefig("Plots\Calibration\Z_" + str(Voltage) + ".png", dpi=300)
-        plt.show()
+class var_with_err:
+    def __init__(self, var, err):
+        self.var = var
+        self.err = err
     
-    print("slope in nm/step zAll-:", popt_zAllp[0] * 1000, " +- ", np.sqrt(pcov_zAllp[0][0]) * 1000, " chi^2 ", chi_zAllp)
-    print("slope in nm/step zAll+:", popt_zAllm[0] * 1000, " +- ", np.sqrt(pcov_zAllm[0][0]) * 1000, " chi^2 ", chi_zAllp)
+    def __str__(self):
+        return round(self.var, uncertainty=self.err)
 
 def linear(x, b):
     return b*x
 
-def dataHandling(data, plots, raw):
-    x = data[0]
-    z1p = data[1]
-    z1m = data[2]
-    z2p = data[3]
-    z2m = data[4]
-    z3p = data[5]
-    z3m = data[6]
-    # Check if calibration performed for all otherwise use dummy data.
-    if(len(data) > 7):
-        zAllp = data[7]
-        zAllm = data[8]
-    else:
-        zAllp = np.zeros(len(z1p))
-        zAllm = np.zeros(len(z1m))
+def FitAndPlot(x, z1p, z1m, z2p, z2m, z3p, z3m, z1p_err, z1m_err, z2p_err, z2m_err, z3p_err, z3m_err, voltage, sigma, plots = True, raw = False, residuals=True):
+    
+    font = font_manager.FontProperties(family='DejaVu Sans Mono', style='normal')
+    
+    fac = 1e6
+    
+    popt_z1p, pcov_z1p = curve_fit(linear, x, z1p, sigma=z1p_err)
+    popt_z1m, pcov_z1m = curve_fit(linear, x, z1m, sigma=z1m_err) 
+    popt_z2p, pcov_z2p = curve_fit(linear, x, z2p, sigma=z2p_err) 
+    popt_z2m, pcov_z2m = curve_fit(linear, x, z2m, sigma=z2m_err)
+    popt_z3p, pcov_z3p = curve_fit(linear, x, z3p, sigma=z3p_err) 
+    popt_z3m, pcov_z3m = curve_fit(linear, x, z3m, sigma=z3m_err) 
+    
+    step_z1p = var_with_err(popt_z1p[0] * fac, np.sqrt(pcov_z1p[0][0]) * fac)
+    step_z1m = var_with_err(popt_z1m[0] * fac, np.sqrt(pcov_z1m[0][0]) * fac)
+    step_z2p = var_with_err(popt_z2p[0] * fac, np.sqrt(pcov_z2p[0][0]) * fac)
+    step_z2m = var_with_err(popt_z2m[0] * fac, np.sqrt(pcov_z2m[0][0]) * fac)
+    step_z3p = var_with_err(popt_z3p[0] * fac, np.sqrt(pcov_z3p[0][0]) * fac)
+    step_z3m = var_with_err(popt_z3m[0] * fac, np.sqrt(pcov_z3m[0][0]) * fac)
+    
+    chi_z1p = np.sum(((z1p - linear(x, popt_z1p[0]))/z1p_err)**2) / len(x - 2)
+    chi_z1m = np.sum(((z1m - linear(x, popt_z1m[0]))/z1m_err)**2) / len(x - 2)
+    chi_z2p = np.sum(((z2p - linear(x, popt_z2p[0]))/z2p_err)**2) / len(x - 2)
+    chi_z2m = np.sum(((z2m - linear(x, popt_z2m[0]))/z2m_err)**2) / len(x - 2)
+    chi_z3p = np.sum(((z3p - linear(x, popt_z3p[0]))/z3p_err)**2) / len(x - 2)
+    chi_z3m = np.sum(((z3m - linear(x, popt_z3m[0]))/z3m_err)**2) / len(x - 2)
+
+    err_z3z2p = popt_z3p[0] * fac / (popt_z2p[0] * fac)
+    err_z3z2m = popt_z3m[0] * fac / (popt_z2m[0] * fac)
+    err_z3z1p = popt_z3p[0] * fac / (popt_z1p[0] * fac)
+    err_z3z1m = popt_z3m[0] * fac / (popt_z1m[0] * fac)
+    err_z2z1p = popt_z2p[0] * fac / (popt_z1p[0] * fac)
+    err_z2z1m = popt_z2m[0] * fac / (popt_z1m[0] * fac)
+    
+    print("### Voltage: ", voltage, " ###")
+    
+    print("z1p: ", step_z1p, " nm/step ", "chi^2/ndof = ", chi_z1p)
+    print("z1m: ", step_z1m, " nm/step ", "chi^2/ndof = ", chi_z1m)
+    print("z2p: ", step_z2p, " nm/step ", "chi^2/ndof = ", chi_z2p)
+    print("z2m: ", step_z2m, " nm/step ", "chi^2/ndof = ", chi_z2m)
+    print("z3p: ", step_z3p, " nm/step ", "chi^2/ndof = ", chi_z3p)
+    print("z3m: ", step_z3m, " nm/step ", "chi^2/ndof = ", chi_z3m)
+    
+    print("error (ratio) + z3/z2: ", popt_z3p[0] * fac / (popt_z2p[0] * fac))
+    print("error (ratio) - z3/z2: ", popt_z3m[0] * fac / (popt_z2m[0] * fac))
+    print("error (ratio) + z3/z1: ", popt_z3p[0] * fac / (popt_z1p[0] * fac))
+    print("error (ratio) - z3/z1: ", popt_z3m[0] * fac / (popt_z1m[0] * fac))
+    print("error (ratio) + z2/z1: ", popt_z2p[0] * fac / (popt_z1p[0] * fac))
+    print("error (ratio) - z2/z1: ", popt_z2m[0] * fac / (popt_z1m[0] * fac))
+
+
+    if plots:
+        
+        x_inter = np.arange(min(x), max(x), 1) 
+        l_jus = 5
+        
+        if not residuals:
+            fig = plt.figure()
+        else:
+            fig, ax = plt.subplots(2,1, sharex=True, gridspec_kw={'height_ratios': [3,1]})
+        
+        fig.set_figheight(4.5)
+        fig.set_figwidth(8)
+        
+        if residuals:
+        
+            ax[0].set_title("Mask Aligner Motors at " + str(voltage) + " V")
+            ax[0].errorbar(x + 80, z1p, z1p_err, marker=".", linestyle="none", capsize=3, label="z1+:".ljust(l_jus ) + str(step_z1p) + " nm/step ", color="tab:blue")
+            ax[0].errorbar(x + 40, z2p, z2p_err, marker=".", linestyle="none", capsize=3, label="z2+:".ljust(l_jus ) + str(step_z2p) + " nm/step ", color="tab:orange")
+            ax[0].errorbar(x - 40, z3p, z3p_err, marker=".", linestyle="none", capsize=3, label="z3+:".ljust(l_jus ) + str(step_z3p) + " nm/step ", color="tab:purple")
+            
+            ax[0].plot(x_inter, linear(x_inter, popt_z1p[0]), color="tab:blue")
+            ax[0].plot(x_inter, linear(x_inter, popt_z1m[0]), color="tab:cyan")
+    
+            ax[0].plot(x_inter, linear(x_inter, popt_z2p[0]), color="tab:orange")
+            ax[0].plot(x_inter, linear(x_inter, popt_z2m[0]), color="tab:red")
+            
+            ax[0].errorbar(x - 80, z1m, z1m_err, marker=".", linestyle="none", capsize=3, label="z1-:".ljust(l_jus ) + str(step_z1m) + " nm/step ", color="tab:cyan")
+            ax[0].errorbar(x + 120, z2m, z2m_err, marker=".", linestyle="none", capsize=3, label="z2-:".ljust(l_jus ) + str(step_z2m) + " nm/step ", color="tab:red")
+            ax[0].errorbar(x, z3m, z3m_err, marker=".", linestyle="none", capsize=3, label="z3-:".ljust(l_jus ) + str(step_z3m) + " nm/step ", color="tab:pink")
+            ax[0].plot(x_inter, linear(x_inter, popt_z3p[0]), color="tab:purple")
+            ax[0].plot(x_inter, linear(x_inter, popt_z3m[0]), color="tab:pink")
+            
+            ax[0].set_xlabel("Number of steps driven")
+            ax[0].set_ylabel("Distance travelled [mm]")
+            ax[0].legend(handletextpad=0.1, prop = font)
+            ax[0].grid()
+            plt.tight_layout()
         
-    FitAndPlot(x, x, z1p, z1m, z2p, z2m, z3p, z3m, zAllp, zAllm, 85, plots, raw)
+            #ax[1].set_title("residuals")
+            ax[1].errorbar(x + 80, z1p - linear(x, popt_z1p[0]), z1p_err, marker=".", linestyle="none", capsize=3, label="z1+:".ljust(l_jus ) + str(step_z1p) + " nm/step ", color="tab:blue")
+            ax[1].errorbar(x + 40, z2p - linear(x, popt_z2p[0]), z2p_err, marker=".", linestyle="none", capsize=3, label="z2+:".ljust(l_jus ) + str(step_z2p) + " nm/step ", color="tab:orange")
+            ax[1].errorbar(x- 40, z3p - linear(x, popt_z3p[0]), z3p_err, marker=".", linestyle="none", capsize=3, label="z3+:".ljust(l_jus ) + str(step_z3p) + " nm/step ", color="tab:purple")
+            
+            ax[1].plot(x_inter, np.zeros(len(x_inter)), color="tab:blue")
+            ax[1].set_ylim(0 - max(np.absolute(z3m - linear(x, popt_z1m[0]))) - max(z3m_err) - 0.05, 0 + max(np.absolute(z3m - linear(x, popt_z1m[0]))) + max(z3m_err)+ 0.05)
+            #ax[1].plot(x_inter, linear(x_inter, popt_z1m[0]), color="tab:cyan")
+    
+            #ax[1].plot(x_inter, linear(x_inter, popt_z2p[0]), color="tab:orange")
+            #ax[1].plot(x_inter, linear(x_inter, popt_z2m[0]), color="tab:red")
+            
+            ax[1].errorbar(x - 80, z1m - linear(x, popt_z1m[0]), z1m_err, marker=".", linestyle="none", capsize=3, label="z1-:".ljust(l_jus ) + str(step_z1m) + " nm/step ", color="tab:cyan")
+            ax[1].errorbar(x + 120, z2m - linear(x, popt_z1m[0]), z2m_err, marker=".", linestyle="none", capsize=3, label="z2-:".ljust(l_jus ) + str(step_z2m) + " nm/step ", color="tab:red")
+            ax[1].errorbar(x, z3m - linear(x, popt_z1m[0]), z3m_err, marker=".", linestyle="none", capsize=3, label="z3-:".ljust(l_jus ) + str(step_z3m) + " nm/step ", color="tab:pink")
+            #ax[1].plot(x_inter, linear(x_inter, popt_z3p[0]), color="tab:purple")
+            #ax[1].plot(x_inter, linear(x_inter, popt_z3m[0]), color="tab:pink")
+            
+            ax[1].set_xlabel("Number of steps driven")
+            ax[1].set_ylabel("Distance travelled [mm]")
+            
+            ax[1].grid()
+            
+        else:
+            
+            plt.title("Mask Aligner Motors at " + str(voltage) + " V")
+            plt.errorbar(x + 80, z1p, z1p_err, marker=".", linestyle="none", capsize=3, label="z1+:".ljust(l_jus ) + str(step_z1p) + " nm/step ", color="tab:blue")
+            plt.errorbar(x + 40, z2p, z2p_err, marker=".", linestyle="none", capsize=3, label="z2+:".ljust(l_jus ) + str(step_z2p) + " nm/step ", color="tab:orange")
+            plt.errorbar(x - 40, z3p, z3p_err, marker=".", linestyle="none", capsize=3, label="z3+:".ljust(l_jus ) + str(step_z3p) + " nm/step ", color="tab:purple")
+            
+            plt.plot(x_inter, linear(x_inter, popt_z1p[0]), color="tab:blue")
+            plt.plot(x_inter, linear(x_inter, popt_z1m[0]), color="tab:cyan")
+    
+            plt.plot(x_inter, linear(x_inter, popt_z2p[0]), color="tab:orange")
+            plt.plot(x_inter, linear(x_inter, popt_z2m[0]), color="tab:red")
+            
+            plt.errorbar(x - 80, z1m, z1m_err, marker=".", linestyle="none", capsize=3, label="z1-:".ljust(l_jus ) + str(step_z1m) + " nm/step ", color="tab:cyan")
+            plt.errorbar(x + 120, z2m, z2m_err, marker=".", linestyle="none", capsize=3, label="z2-:".ljust(l_jus ) + str(step_z2m) + " nm/step ", color="tab:red")
+            plt.errorbar(x, z3m, z3m_err, marker=".", linestyle="none", capsize=3, label="z3-:".ljust(l_jus ) + str(step_z3m) + " nm/step ", color="tab:pink")
+            plt.plot(x_inter, linear(x_inter, popt_z3p[0]), color="tab:purple")
+            plt.plot(x_inter, linear(x_inter, popt_z3m[0]), color="tab:pink")
+            
+            plt.xlabel("Number of steps driven")
+            plt.ylabel("Distance travelled [mm]")
+            plt.legend(handletextpad=0.1, prop = font)
+            plt.grid()
+            plt.tight_layout()
+                
+        plt.savefig("Plots/CalibrationAfterRepair/" + str(voltage) + "V.pdf")
+        plt.savefig("Plots/CalibrationAfterRepair/" + str(voltage) + "V.png", dpi=300)
+        plt.show()
+        
+    return step_z1p, step_z1m, step_z2p, step_z2m, step_z3p, step_z3m, err_z3z2p, err_z3z2m, err_z3z1p, err_z3z1m, err_z2z1p, err_z2z1m   
 
+def dataHandling(data, offset, voltage, plots, raw):
+    x = data[0 + offset]
+    z3m = data[1 + offset]
+    z3p = data[2 + offset]
+    z2m = data[3 + offset]
+    z2p = data[4 + offset]
+    z1m = data[5 + offset]
+    z1p = data[6 + offset]
+    
+    z3m_err = data[7 + offset]
+    z3p_err = data[8 + offset]
+    z2m_err = data[9 + offset]
+    z2p_err = data[10 + offset]
+    z1m_err = data[11 + offset]
+    z1p_err = data[12 + offset]
+    
+    sigma = np.ones(len(x)) * data[0][0]
+    
+    #Check for empty data and fill with dummy
+    if np.isnan(z1p).any():
+        z1p = np.zeros(5)
+    if np.isnan(z1m).any():
+        z1m = np.zeros(5)
+    if np.isnan(z2p).any():
+        z2p = np.zeros(5)
+    if np.isnan(z2m).any():
+        z2m = np.zeros(5)
+    if np.isnan(z3p).any():
+        z3p = np.zeros(5)
+    if np.isnan(z3m).any():
+        z3m = np.zeros(5)
+        
+    if np.isnan(z1p_err).any():
+        z1p_err = np.ones(5) * sigma
+    if np.isnan(z1m_err).any():
+        z1m_err = np.ones(5) * sigma
+    if np.isnan(z2p_err).any():
+        z2p_err = np.ones(5) * sigma
+    if np.isnan(z2m_err).any():
+        z2m_err = np.ones(5) * sigma
+    if np.isnan(z3p_err).any():
+        z3p_err = np.ones(5) * sigma
+    if np.isnan(z3m_err).any():
+        z3m_err = np.ones(5) * sigma
+    
+    step_z1p, step_z1m, step_z2p, step_z2m, step_z3p, step_z3m, err_z3z2p, err_z3z2m, err_z3z1p, err_z3z1m, err_z2z1p, err_z2z1m = FitAndPlot(x, z1p, z1m, z2p, z2m, z3p, z3m, z1p_err, z1m_err, z2p_err, z2m_err, z3p_err, z3m_err, voltage, sigma, plots, raw)
+    return step_z1p, step_z1m, step_z2p, step_z2m, step_z3p, step_z3m, err_z3z2p, err_z3z2m, err_z3z1p, err_z3z1m, err_z2z1p, err_z2z1m
+    
 def main():
     plots = True
     raw = False
 
-    file = "C:\MaskAligner\Data\Calibration.csv"
+    file = "C:\MaskAligner\Data\Calibration\CalibrationAfterRepair_13_11_23.csv"
 
     # very Simple commandline parser
     if("--no_plots" in sys.argv):
@@ -191,10 +231,77 @@ def main():
     if("--raw_plot" in sys.argv):
         raw = True
 
-    data = np.genfromtxt(file, skip_header=0, delimiter=",")
+    data = np.genfromtxt(file, skip_header=1, delimiter=",")
     data = data.T
     
-    dataHandling(data, plots, raw)
+    volt = data[0][0]
+    
+    arr = []
+    
+    arr.append(dataHandling(data, 1, volt, plots, raw))
+    
+    arr = np.array(arr).T
+    
+    ## Plot motors errors against one another against voltage 
+    """
+    fig = plt.figure() 
+    fig.set_figheight(4.5)
+    fig.set_figwidth(8)
+    
+    plt.plot([70, 80, 100, 120], arr[6], label="error z3/z2+", marker=".", linestyle="dashed")
+    plt.plot([70, 80, 100, 120], arr[8], label="error z3/z1+", marker=".", linestyle="dashed")
+    plt.plot([70, 80, 100, 120], arr[10], label="error z2/z1+", marker=".", linestyle="dashed")
+    plt.plot([70, 80, 100, 120], arr[7], label="error z3/z2-", marker=".", linestyle="dashed")
+    plt.plot([70, 80, 100, 120], arr[9], label="error z3/z1-", marker=".", linestyle="dashed")
+    plt.plot([70, 80, 100, 120], arr[11], label="error z2/z1-", marker=".", linestyle="dashed")
+    plt.xlabel("Voltage [V]")
+    plt.ylabel("ratio of motor's stepsizes")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig("Plots/CalibrationAfterRepair/Errors.pdf")
+    plt.savefig("Plots/CalibrationAfterRepair/Errors.png", dpi=300)
+    plt.show()
+    
+    ## Plot stepsizes against voltage 
+    fig = plt.figure() 
+    fig.set_figheight(4.5)
+    fig.set_figwidth(8)   
+    
+    plt.errorbar([70, 80, 100, 120], [x.var for x in arr[0]], [x.err for x in arr[0]], label="z1+", marker=".", linestyle="dashed", capsize=3, color="tab:blue")
+    plt.errorbar([70, 80, 100, 120], [x.var for x in arr[1]], [x.err for x in arr[1]], label="z1-", marker=".", linestyle="dashed", capsize=3, color="tab:cyan")
+    plt.errorbar([70, 80, 100, 120], [x.var for x in arr[2]], [x.err for x in arr[2]], label="z2+", marker=".", linestyle="dashed", capsize=3, color="tab:orange")
+    plt.errorbar([70, 80, 100, 120], [x.var for x in arr[3]], [x.err for x in arr[3]], label="z2-", marker=".", linestyle="dashed", capsize=3, color="tab:red")
+    plt.errorbar([70, 80, 100, 120], [x.var for x in arr[4]], [x.err for x in arr[4]], label="z3+", marker=".", linestyle="dashed", capsize=3, color="tab:purple")
+    plt.errorbar([70, 80, 100, 120], [x.var for x in arr[5]], [x.err for x in arr[5]], label="z3-", marker=".", linestyle="dashed", capsize=3, color="tab:pink")
+    plt.xlabel("Voltage [V]")
+    plt.ylabel("stepsize [nm/step]")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig("Plots/CalibrationAfterRepair/Stepsizes.pdf")
+    plt.savefig("Plots/CalibrationAfterRepair/Stepsizes.png", dpi=300)
+    plt.show()
+    
+    
+    ## Plot up/down ratio against Voltage
+    z1_ud = var_with_err(np.array([x.var for x in arr[0]])/np.array([x.var for x in arr[1]]), np.sqrt((1/np.array([x.var for x in arr[1]]) * np.array([x.err for x in arr[0]]))**2 + (np.array([x.var for x in arr[0]])/np.array([x.var for x in arr[1]])**2 * np.array([x.err for x in arr[1]]))**2))
+    z2_ud = var_with_err(np.array([x.var for x in arr[2]])/np.array([x.var for x in arr[3]]), np.sqrt((1/np.array([x.var for x in arr[3]]) * np.array([x.err for x in arr[2]]))**2 + (np.array([x.var for x in arr[2]])/np.array([x.var for x in arr[3]])**2 * np.array([x.err for x in arr[3]]))**2))
+    z3_ud = var_with_err(np.array([x.var for x in arr[4]])/np.array([x.var for x in arr[5]]), np.sqrt((1/np.array([x.var for x in arr[5]]) * np.array([x.err for x in arr[4]]))**2 + (np.array([x.var for x in arr[4]])/np.array([x.var for x in arr[5]])**2 * np.array([x.err for x in arr[5]]))**2))
+    
+    fig = plt.figure() 
+    fig.set_figheight(4.5)
+    fig.set_figwidth(8)   
+    
+    plt.errorbar([70, 80, 100, 120], z1_ud.var, z1_ud.err, label="z1", marker=".", linestyle="dashed", capsize=3, color="tab:blue")
+    plt.errorbar([70, 80, 100, 120], z2_ud.var, z2_ud.err, label="z2", marker=".", linestyle="dashed", capsize=3, color="tab:cyan")
+    plt.errorbar([70, 80, 100, 120], z3_ud.var, z3_ud.err, label="z3", marker=".", linestyle="dashed", capsize=3, color="tab:orange")
+    plt.xlabel("Voltage [V]")
+    plt.ylabel("ratio approach/retract")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig("Plots/CalibrationAfterRepair/ratioUD.pdf")
+    plt.savefig("Plots/CalibrationAfterRepair/ratioUD.png", dpi=300)
+    plt.show()
+    """
 
 if __name__ == "__main__":
     main()
\ No newline at end of file
diff --git a/PythonScripts/CalibrationDragAndDrop.bat b/PythonScripts/CalibrationDragAndDrop.bat
index 418a6bde516c75a95372e393ff8445c9fb074653..7799874bbe16d29b51ea46ccf0b95cc4ce73af5e 100644
--- a/PythonScripts/CalibrationDragAndDrop.bat
+++ b/PythonScripts/CalibrationDragAndDrop.bat
@@ -1,3 +1,4 @@
 @echo off
 cd /D "%~dp0"
 for %%a in (%*) do py .\Calibration.py --file %%a
+pause
\ No newline at end of file
diff --git a/PythonScripts/CalibrationOld.py b/PythonScripts/CalibrationOld.py
new file mode 100644
index 0000000000000000000000000000000000000000..1eb7c6b578da84ec8c18ce95d83865c99a379a1a
--- /dev/null
+++ b/PythonScripts/CalibrationOld.py
@@ -0,0 +1,200 @@
+import numpy as np
+from scipy.optimize import curve_fit
+import matplotlib.pyplot as plt
+from matplotlib.offsetbox import AnchoredText
+import sys
+## Performs linear fit for calibration
+
+def FitAndPlot(xp, xm, z1p, z1m, z2p, z2m, z3p, z3m, zAllp, zAllm, Voltage, plots, raw):
+    #Linewidth
+    lw = 0.8
+    
+    #
+    if(plots):
+        if(raw):
+            plt.title("Calibration Measurement " + str(Voltage))
+            plt.plot(xp, z1p, marker=".", color="tab:blue", label="z1-", linewidth=lw)
+            plt.plot(xp, z1m, marker=".", color="b", label="z1+", linewidth=lw)
+            plt.plot(xp, z2p, marker=".", color="tab:red", label="z2-", linewidth=lw)
+            plt.plot(xp, z2m, marker=".", color="chocolate", label="z2+", linewidth=lw)
+            plt.plot(xp, z3p, marker=".", color="tab:green", label="z3-", linewidth=lw)
+            plt.plot(xp, z3m, marker=".", color="darkolivegreen", label="z3+", linewidth=lw)
+            plt.plot(xp, zAllp, marker=".", color="tab:purple", label="zAll-", linewidth=lw)
+            plt.plot(xp, zAllm, marker=".", color="m", label="zAll+", linewidth=lw)
+            plt.ylabel(r"Measured Movement [$\mu m$]")
+            plt.xlabel("# of step")
+            plt.legend()
+            plt.grid()
+            plt.savefig("Plots\Calibration\\" + str(Voltage) + "_All_Data.pdf")
+            plt.show()
+         
+    # Fit 
+    # Errors are 1/sqrt(12) * one pixel length in mikrometers
+    error_z1 = 8.87 / np.sqrt(12)
+    error_z2 = 9.62 / np.sqrt(12)
+    error_z3 = 9.80 / np.sqrt(12)
+    error_zAll = 9.00 / np.sqrt(12)
+    
+    popt_z1p, pcov_z1p = curve_fit(linear, xp, z1p, error_z1)
+    popt_z1m, pcov_z1m = curve_fit(linear, xp, z1m, error_z1)
+    popt_z2p, pcov_z2p = curve_fit(linear, xp, z2p, error_z2)
+    popt_z2m, pcov_z2m = curve_fit(linear, xp, z2m, error_z2)
+    popt_z3p, pcov_z3p = curve_fit(linear, xp, z3p, error_z3)
+    popt_z3m, pcov_z3m = curve_fit(linear, xp, z3m, error_z3)
+    popt_zAllp, pcov_zAllp = curve_fit(linear, xp, zAllp, error_zAll)
+    popt_zAllm, pcov_zAllm = curve_fit(linear, xp, zAllm, error_zAll)
+    
+    # Chi squared Computation per degree of freedom 
+    chi_z1p = np.sum(((z1p - linear(xp, popt_z1p[0]))**2 / error_z1**2)) / (len(z1p) - 1)
+    chi_z1m = np.sum(((z1m - linear(xp, popt_z1m[0]))**2 / error_z1**2)) / (len(z1m) - 1)
+    chi_z2p = np.sum(((z2p - linear(xp, popt_z2p[0]))**2 / error_z2**2)) / (len(z2p) - 1)
+    chi_z2m = np.sum(((z2m - linear(xp, popt_z2m[0]))**2 / error_z2**2)) / (len(z2m) - 1)
+    chi_z3p = np.sum(((z3p - linear(xp, popt_z3p[0]))**2 / error_z3**2)) / (len(z3p) - 1)
+    chi_z3m = np.sum(((z3m - linear(xp, popt_z3m[0]))**2 / error_z3**2)) / (len(z3m) - 1)
+    chi_zAllp = np.sum(((zAllp - linear(xp, popt_zAllp[0]))**2 / error_zAll**2)) / (len(zAllp) - 1)
+    chi_zAllm = np.sum(((zAllm - linear(xp, popt_zAllm[0]))**2 / error_zAll**2)) / (len(zAllm) - 1)
+    
+    # Plots
+    fig, ax = plt.subplots(2, 2)
+    fig.set_figheight(9)
+    fig.set_figwidth(16)
+
+    # Z1 
+    capsize = 2
+    if(plots):
+        ax[0,0].set_title("Z1 calibration fit " + str(Voltage))
+        ax[0,0].set_xlabel("# of steps")
+        ax[0,0].set_ylabel(r"Measured Movement [$\mu m$]")
+        ax[0,0].errorbar(xp, z1p, error_z1, linestyle="none", marker=".", linewidth=lw, color="tab:blue", label="z1- data", capsize=capsize)
+        ax[0,0].errorbar(xp, z1m, error_z1, linestyle="none", marker=".", linewidth=lw, color="b", label="z1+ data", capsize=capsize)
+        ax[0,0].plot(xp, linear(xp, popt_z1p[0]), linewidth=lw, color="tab:blue", label="z1- fit")
+        ax[0,0].plot(xp, linear(xp, popt_z1m[0]), linewidth=lw, color="b", label="z1+ fit")
+    
+        #ax = plt.gca()
+        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z1p[0] * 1000, np.sqrt(pcov_z1p[0][0]) * 1000, chi_z1p) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z1m[0] * 1000, np.sqrt(pcov_z1m[0][0]) * 1000, chi_z1m), loc=4)
+        ax[0,0].add_artist(anchored_text)
+        
+        ax[0,0].legend()
+        plt.grid()
+        #plt.savefig("Plots\Calibration\Z1_" + str(Voltage) + ".pdf")
+        #plt.show()
+    
+    print("slope in nm/step z1-:", popt_z1p[0] * 1000, " +- ", np.sqrt(pcov_z1p[0][0]) * 1000, " chi^2 ", chi_z1p)
+    print("slope in nm/step z1+:", popt_z1m[0] * 1000, " +- ", np.sqrt(pcov_z1m[0][0]) * 1000, " chi^2 ", chi_z1m)
+    
+    #Z2
+    if(plots):
+        ax[0,1].set_title("Z2 calibration fit " + str(Voltage))
+        ax[0,1].set_xlabel("# of steps")
+        ax[0,1].set_ylabel(r"Measured Movement [$\mu m$]")
+        ax[0,1].errorbar(xp, z2p, error_z2, linestyle="none", marker=".", linewidth=lw, color="tab:red", label="z2- data", capsize=capsize)
+        ax[0,1].errorbar(xp, z2m, error_z2, linestyle="none", marker=".", linewidth=lw, color="chocolate", label="z2+ data", capsize=capsize)
+        ax[0,1].plot(xp, linear(xp, popt_z2p[0]), linewidth=lw, color="tab:red", label="z2- fit")
+        ax[0,1].plot(xp, linear(xp, popt_z2m[0]), linewidth=lw, color="chocolate", label="z2+ fit")
+    
+        #ax = plt.gca()
+        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z2p[0] * 1000, np.sqrt(pcov_z2p[0][0]) * 1000, chi_z2p) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z2m[0] * 1000, np.sqrt(pcov_z2m[0][0]) * 1000, chi_z2m), loc=4)
+        ax[0,1].add_artist(anchored_text)
+        
+        ax[0,1].legend()
+        plt.grid()
+        #plt.savefig("Plots\Calibration\Z2_" + str(Voltage) + ".pdf")
+        #plt.show()
+    
+    print("slope in nm/step z2-:", popt_z2p[0] * 1000, " +- ", np.sqrt(pcov_z2p[0][0]) * 1000, " chi^2 ", chi_z2p)
+    print("slope in nm/step z2+:", popt_z2m[0] * 1000, " +- ", np.sqrt(pcov_z2m[0][0]) * 1000, " chi^2 ", chi_z2m)
+    
+    #Z3
+    if(plots):
+        ax[1,0].set_title("Z3 calibration fit " + str(Voltage))
+        ax[1,0].set_xlabel("# of steps")
+        ax[1,0].set_ylabel(r"Measured Movement [$\mu m$]")
+        ax[1,0].errorbar(xp, z3p, error_z3, linestyle="none", marker=".", linewidth=lw, color="tab:green", label="z3- data", capsize=capsize)
+        ax[1,0].errorbar(xp, z3m, error_z3, linestyle="none", marker=".", linewidth=lw, color="darkolivegreen", label="z3+ data", capsize=capsize)
+        ax[1,0].plot(xp, linear(xp, popt_z3p[0]), linewidth=lw, color="tab:green", label="z3- fit")
+        ax[1,0].plot(xp, linear(xp, popt_z3m[0]), linewidth=lw, color="darkolivegreen", label="z3+ fit")
+    
+        #ax = plt.gca()
+        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z3p[0] * 1000, np.sqrt(pcov_z3p[0][0]) * 1000, chi_z3p) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_z3m[0] * 1000, np.sqrt(pcov_z3m[0][0]) * 1000, chi_z3m), loc=4)
+        ax[1,0].add_artist(anchored_text)
+        
+        ax[1,0].legend()
+        plt.grid()
+        #plt.savefig("Plots\Calibration\Z3_" + str(Voltage) + ".pdf")
+        #plt.show()
+    
+    print("slope in nm/step z3-:", popt_z3p[0] * 1000, " +- ", np.sqrt(pcov_z3p[0][0]) * 1000, " chi^2 ", chi_z3p)
+    print("slope in nm/step z3+:", popt_z3m[0] * 1000, " +- ", np.sqrt(pcov_z3m[0][0]) * 1000, " chi^2 ", chi_z3p)
+    
+    #ZALL
+    if(plots):
+        ax[1,1].set_title("ZAll calibration fit " + str(Voltage))
+        ax[1,1].set_xlabel("# of steps")
+        ax[1,1].set_ylabel(r"Measured Movement [$\mu m$]")
+        ax[1,1].errorbar(xp, zAllp, error_zAll, linestyle="none", marker=".", linewidth=lw, color="tab:purple", label="zAll- data", capsize=capsize)
+        ax[1,1].errorbar(xp, zAllm, error_zAll, linestyle="none", marker=".", linewidth=lw, color="m", label="zAll+ data", capsize=capsize)
+        ax[1,1].plot(xp, linear(xp, popt_zAllp[0]), linewidth=lw, color="tab:purple", label="zAll- fit")
+        ax[1,1].plot(xp, linear(xp, popt_zAllm[0]), linewidth=lw, color="m", label="zAll+ fit")
+    
+        #ax = plt.gca()
+        anchored_text = AnchoredText(r"$b_-$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_zAllp[0] * 1000, np.sqrt(pcov_zAllp[0][0]) * 1000, chi_zAllp) + "\n" + "$b_+$= {:.2f} $\pm$ {:.2f} $n m$/step, $\chi^2/ndof =${:.2f}".format(popt_zAllm[0] * 1000, np.sqrt(pcov_zAllm[0][0]) * 1000, chi_zAllm), loc=4)
+        ax[1,1].add_artist(anchored_text)
+        
+        ax[1,1].legend()
+        plt.grid()
+        plt.savefig("Plots\Calibration\Z_" + str(Voltage) + ".pdf")
+        plt.savefig("Plots\Calibration\Z_" + str(Voltage) + ".png", dpi=300)
+        plt.show()
+    
+    print("slope in nm/step zAll-:", popt_zAllp[0] * 1000, " +- ", np.sqrt(pcov_zAllp[0][0]) * 1000, " chi^2 ", chi_zAllp)
+    print("slope in nm/step zAll+:", popt_zAllm[0] * 1000, " +- ", np.sqrt(pcov_zAllm[0][0]) * 1000, " chi^2 ", chi_zAllp)
+
+def linear(x, b):
+    return b*x
+
+def dataHandling(data, plots, raw):
+    x = data[0]
+    z1p = data[1]
+    z1m = data[2]
+    z2p = data[3]
+    z2m = data[4]
+    z3p = data[5]
+    z3m = data[6]
+    # Check if calibration performed for all otherwise use dummy data.
+    if(len(data) > 7):
+        zAllp = data[7]
+        zAllm = data[8]
+    else:
+        zAllp = np.zeros(len(z1p))
+        zAllm = np.zeros(len(z1m))
+        
+    FitAndPlot(x, x, z1p, z1m, z2p, z2m, z3p, z3m, zAllp, zAllm, 85, plots, raw)
+
+def main():
+    plots = True
+    raw = False
+
+    file = "C:\MaskAligner\Data\Calibration.csv"
+
+    # very Simple commandline parser
+    if("--no_plots" in sys.argv):
+        plots = False
+    
+    if("--file" in sys.argv or "-f" in sys.argv):
+        for i in range(len(sys.argv)):
+            if("--file" in sys.argv[i] or "-f" == sys.argv[i]):
+                try:
+                    file = sys.argv[i+1]
+                except:
+                    print("No file or incorrect file specification.")
+    
+    if("--raw_plot" in sys.argv):
+        raw = True
+
+    data = np.genfromtxt(file, skip_header=0, delimiter=",")
+    data = data.T
+    
+    dataHandling(data, plots, raw)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/PythonScripts/CalibrationQuick_07_02_24.py b/PythonScripts/CalibrationQuick_07_02_24.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdf05d9b69e8b246c8e98d5cc61a24a42479a4ee
--- /dev/null
+++ b/PythonScripts/CalibrationQuick_07_02_24.py
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb  7 14:40:15 2024
+
+@author: admin
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+def main():
+    file = "C:\MaskAligner\Data\Calibration07_02_24\CalibrationQuick.csv"
+    data = np.genfromtxt(file, delimiter=",", skip_header=1).T
+    
+    Z1m = data[1]
+    Z1p = data[2]
+    
+    Z2m = data[4]
+    Z2p = data[5]
+
+    Z3m = data[7]
+    Z3p = data[8]
+    
+    
+    plt.plot(np.zeros(len(Z1m)) + 0.1, Z1m, color="tab:blue", label="Z1", marker=".", linestyle="none")
+    plt.plot(np.zeros(len(Z2m)), Z2m, color="tab:orange", label="Z2", marker=".", linestyle="none")
+    plt.plot(np.zeros(len(Z3m)) - 0.1, Z3m, color="tab:green", label="Z3", marker=".", linestyle="none")
+    
+    plt.plot(np.ones(len(Z1p)) + 0.1, Z1p, color="tab:blue", marker=".", linestyle="none")
+    plt.plot(np.ones(len(Z2p)), Z2p, color="tab:orange", marker=".", linestyle="none")
+    plt.plot(np.ones(len(Z3p)) - 0.1, Z3p, color="tab:green", marker=".", linestyle="none")
+    
+    plt.errorbar(0 + 0.1, np.nanmean(Z1m), np.nanstd(Z1m, ddof=1), color="tab:blue", capsize=3, marker="_")
+    plt.errorbar(1 + 0.1, np.nanmean(Z1p), np.nanstd(Z1p, ddof=1), color="tab:blue", capsize=3, marker="_")
+    
+    plt.errorbar(0, np.nanmean(Z2m), np.nanstd(Z2m, ddof=1), color="tab:orange", capsize=3, marker="_")
+    plt.errorbar(1, np.nanmean(Z2p), np.nanstd(Z2p, ddof=1), color="tab:orange", capsize=3, marker="_")
+    
+    plt.errorbar(0 - 0.1, np.nanmean(Z3m), np.nanstd(Z3m, ddof=1), color="tab:green", capsize=3, marker="_")
+    plt.errorbar(1 - 0.1, np.nanmean(Z3p), np.nanstd(Z3p, ddof=1), color="tab:green", capsize=3, marker="_")
+    
+    plt.xticks([0,1], ["-", "+"])
+    plt.xlabel("direction")
+    plt.ylabel(r"time [s] for distance of $\approx 2$ mm")
+    
+    plt.legend()
+    plt.show()
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/PythonScripts/PlotPressurePlortMatlabScript.py b/PythonScripts/PlotPressurePlortMatlabScript.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cb7aed65c26d33d922ec7a83590a1ee26d839a6
--- /dev/null
+++ b/PythonScripts/PlotPressurePlortMatlabScript.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jan 26 13:18:01 2024
+
+@author: admin
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+from datetime import datetime
+from dateutil import parser
+
+def main():
+    file = "C:\\MaskAligner\\Matlab\\test20.12.23\\Data_25-Jan-2024_10-16-48.csv"
+    if("--file" in sys.argv or "-f" in sys.argv):
+        for i in range(len(sys.argv)):
+            if("--file" in sys.argv[i] or "-f" == sys.argv[i]):
+                try:
+                    file = sys.argv[i+1]
+                except:
+                    print("No file or incorrect file specification.")
+                   
+    times = []
+    times_sec = []
+    pressures = []
+    
+    with open(file, "r") as read_file:
+        lines = read_file.readlines() 
+        #pressures = np.zeros(len(lines) - 1)
+        
+        for i in range(1, len(lines)):
+            temp = lines[i].split(",")
+            if(i == 1):
+                for j in range(len(temp) - 3): 
+                    pressures.append(np.zeros(len(lines) - 1))
+            
+            t = parser.parse(temp[0].replace("  ", " "))
+            times.append(t)
+            times_sec.append(temp[1])
+            for j in range(len(temp) - 3):
+                pressures[j][i-1] = float(temp[j+3])
+           
+    for pressure in pressures:
+        plt.plot(times, pressure)
+    plt.ylabel("pressure [mbar]")
+    plt.yscale("log")
+    plt.show()
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/PythonScripts/PlotPressurePlortMatlabScriptDragAndDrop.bat b/PythonScripts/PlotPressurePlortMatlabScriptDragAndDrop.bat
new file mode 100644
index 0000000000000000000000000000000000000000..c8e6133e996b70ec549bbf857e766f5c76539f1d
--- /dev/null
+++ b/PythonScripts/PlotPressurePlortMatlabScriptDragAndDrop.bat
@@ -0,0 +1,4 @@
+@echo off
+cd /D "%~dp0"
+for %%a in (%*) do py .\PlotPressurePlortMatlabScript.py --file %%a
+pause
\ No newline at end of file
diff --git a/PythonScripts/PlotPressureRealtime.py b/PythonScripts/PlotPressureRealtime.py
deleted file mode 100644
index 4a73632d85fe19de0b36e5972ce29a61d17868e3..0000000000000000000000000000000000000000
--- a/PythonScripts/PlotPressureRealtime.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Thu Nov 30 15:07:58 2023
-
-@author: admin
-"""
-
-import time 
-import serial
-import numpy as np
-import matplotlib.pyplot as plt
-
-def reading():
-    ser = serial.Serial('COM7', 19200, timeout=0, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=8)
-    read_command = b"RFM%d\r" % 1
-    ser.write(read_command)
-    time.sleep(.03)
-    pressure = ''
-    while ser.inWaiting() > 0:
-        pressure += ser.read(1).decode('ascii')
-    
-        print(pressure)
-    
-        if pressure[0] == '0':
-            return float(pressure)
-        else:
-            return float('nan')
-        
-    ser.close()
-        
-def main():
-    for i in range(0, 100):
-        pressure = []
-        temp_press = reading()
-        pressure.append(temp_press)
-        
-        plt.plot(pressure)
-        plt.pause(0.05)
-        plt.show()   
-        
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact.pdf
index b83d28672d129ec739434e39150f7113deb9aa69..ac98a1efa88f04c9c1d5682ed191347a0c0bd9ae 100644
Binary files a/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact.pdf and b/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact.pdf differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact_editForPres.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact_editForPres.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..199ef7db0a7fb4b1599cca404b32698423f714e2
Binary files /dev/null and b/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact_editForPres.pdf differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact_editForPres.png b/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact_editForPres.png
new file mode 100644
index 0000000000000000000000000000000000000000..c76e80ee0bd012592ff8fc2ebfe475e5eb0895c4
Binary files /dev/null and b/PythonScripts/Plots/ApproachCurves/ApproachCurve21_11_23_ToFullContact_editForPres.png differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.pdf
index ed3fdf3e6154a73c87ea8f940f9e6018ad737e82..7b5af12a0be056b8e2b78b6ba541073074b2c2e5 100644
Binary files a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.pdf and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.pdf differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.png b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.png
index b0883551504f939c72c9ff9cd25bfe85de3f5410..23273092dccf3a2e75176829cc24900e1690409d 100644
Binary files a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.png and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent1.png differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent17.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent17.pdf
index 2e81bc25b48ffd4639012c1682d67a97621d72ed..41607ed97089f674f8dce44100b685c8fbc1ec97 100644
Binary files a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent17.pdf and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent17.pdf differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent3-cop.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent3-cop.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..0e109c06c9f68c4cb560c177b6c682ab93770483
Binary files /dev/null and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent3-cop.pdf differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent3-cop.png b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent3-cop.png
new file mode 100644
index 0000000000000000000000000000000000000000..c6262b17c401a53d0017cd88e7d839b105553272
Binary files /dev/null and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent3-cop.png differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent4.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent4.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..1ecf68b83b46637f0b0937d8df7182babab7d6d5
Binary files /dev/null and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent4.pdf differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent4.png b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent4.png
new file mode 100644
index 0000000000000000000000000000000000000000..573bb270f25c79abaababc1b7d74b3e06d6764b7
Binary files /dev/null and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent4.png differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent9.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent9.pdf
index f6a0f1b577cc3c5040e7291b8d36700a287f21d8..feef91bc698c39d5e599dfc153c72227a04b02c7 100644
Binary files a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent9.pdf and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrent9.pdf differ
diff --git a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrentToFullContactAfterFeedthroughRepair.pdf b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrentToFullContactAfterFeedthroughRepair.pdf
index d1677c68f2b378086c9c055f9bd94f176596bec8..add36d18e8a4b3301c378024d7d60175ae2eb50c 100644
Binary files a/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrentToFullContactAfterFeedthroughRepair.pdf and b/PythonScripts/Plots/ApproachCurves/ApproachCurveCurrentToFullContactAfterFeedthroughRepair.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/0.08V.pdf b/PythonScripts/Plots/CalibrationAfterRepair/0.08V.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..2c67d13736d6d3d67c2a5911141bd0c8f76233f7
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/0.08V.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/0.08V.png b/PythonScripts/Plots/CalibrationAfterRepair/0.08V.png
new file mode 100644
index 0000000000000000000000000000000000000000..7fbe9f32e5e37ab41728757039f7b5a01e4f2397
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/0.08V.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/100V.pdf b/PythonScripts/Plots/CalibrationAfterRepair/100V.pdf
index b7b20d1a2f9b362574459f2de23b4140ccc3dbd9..5d554550cfb5e2104f1e5fb51c12e12613a21890 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/100V.pdf and b/PythonScripts/Plots/CalibrationAfterRepair/100V.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/100V.png b/PythonScripts/Plots/CalibrationAfterRepair/100V.png
index 2a2f7e66d6414a9b6b195ad23fec51d9c4c39de9..839a975da1ae8d5b3a9b7be3bc01d30112a65120 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/100V.png and b/PythonScripts/Plots/CalibrationAfterRepair/100V.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/120V.pdf b/PythonScripts/Plots/CalibrationAfterRepair/120V.pdf
index ce1a5ce799312159132b174cb85ab6213bdbc0d5..ad9963717c4b462c5ede412c6a895858ce61426d 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/120V.pdf and b/PythonScripts/Plots/CalibrationAfterRepair/120V.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/120V.png b/PythonScripts/Plots/CalibrationAfterRepair/120V.png
index be1a53ffb66a40f30f9db4fd5bf5d0e42c71a1d0..3f1000321c7c6af61f9c4eeaae43d450818e5e78 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/120V.png and b/PythonScripts/Plots/CalibrationAfterRepair/120V.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/70V.pdf b/PythonScripts/Plots/CalibrationAfterRepair/70V.pdf
index 411b9b640372a52c18b1db0ef48c31fd0534f3ac..a6c1a166988347de6d8403ed1338b2d3602c9d9c 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/70V.pdf and b/PythonScripts/Plots/CalibrationAfterRepair/70V.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/70V.png b/PythonScripts/Plots/CalibrationAfterRepair/70V.png
index 7ecd9218df513afa205073a02b92cb9db405b036..e48476bb9a9bbc4211a58623547a425d805e3b13 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/70V.png and b/PythonScripts/Plots/CalibrationAfterRepair/70V.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/80.0V.pdf b/PythonScripts/Plots/CalibrationAfterRepair/80.0V.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..838660cdcf7b8a2f0e00eaaf77bb20982e452fe9
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/80.0V.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/80.0V.png b/PythonScripts/Plots/CalibrationAfterRepair/80.0V.png
new file mode 100644
index 0000000000000000000000000000000000000000..4392820ae362ef83bd5a36e0bb1d4496b9ac5e33
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/80.0V.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/80V.pdf b/PythonScripts/Plots/CalibrationAfterRepair/80V.pdf
index d432a01769ad91392b92c76f72251d4bb51639f5..1edcb534f2af80cbcb6c9b6ec21c9a71a1d324e7 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/80V.pdf and b/PythonScripts/Plots/CalibrationAfterRepair/80V.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/80V.png b/PythonScripts/Plots/CalibrationAfterRepair/80V.png
index 8890c756f0e2d44f0ba00e0ab0a2781fc92cfb56..8b94cbe4da9822e72cfc12b310bb677f008bae1f 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/80V.png and b/PythonScripts/Plots/CalibrationAfterRepair/80V.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/Errors.pdf b/PythonScripts/Plots/CalibrationAfterRepair/Errors.pdf
index 9502fe33658a8cc9e7b7225a21e36f2f94c75562..efbc1a57b274efde2793c7e4234c84babb3304b9 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/Errors.pdf and b/PythonScripts/Plots/CalibrationAfterRepair/Errors.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/Errors.png b/PythonScripts/Plots/CalibrationAfterRepair/Errors.png
index 99acfe6d84aee9d75fc6ae96c5647be717f0bdb3..820ea6e12863d064b4be113fccf1978f8ab56484 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/Errors.png and b/PythonScripts/Plots/CalibrationAfterRepair/Errors.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.pdf b/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.pdf
index f3ead9c340c0ad15bb4e20d18a3a6be21a49503f..c81f6caa74d36aa741e30e942750145cbc6f7a4d 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.pdf and b/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.png b/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.png
index 7be87da929af3ef6be6a119d1915f12217e0d1c1..95079c099d54d8fca2fbca4520c5fac87e8b00f9 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.png and b/PythonScripts/Plots/CalibrationAfterRepair/Stepsizes.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/[0.08  nan  nan  nan  nan]V.pdf b/PythonScripts/Plots/CalibrationAfterRepair/[0.08  nan  nan  nan  nan]V.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..644f7548bb06e67395ed19bdf178cd37717bfc17
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/[0.08  nan  nan  nan  nan]V.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/[0.08  nan  nan  nan  nan]V.png b/PythonScripts/Plots/CalibrationAfterRepair/[0.08  nan  nan  nan  nan]V.png
new file mode 100644
index 0000000000000000000000000000000000000000..414013c422ee3c16656a077bfb74cd64f04f074c
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/[0.08  nan  nan  nan  nan]V.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/nanV.pdf b/PythonScripts/Plots/CalibrationAfterRepair/nanV.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..bbb7ecbbfe76d0eef7e1e81ba27f977d99d272ca
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/nanV.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/nanV.png b/PythonScripts/Plots/CalibrationAfterRepair/nanV.png
new file mode 100644
index 0000000000000000000000000000000000000000..a54ff57e237c5a0e5eb34dc21d1ad2716c54357c
Binary files /dev/null and b/PythonScripts/Plots/CalibrationAfterRepair/nanV.png differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.pdf b/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.pdf
index 7ad4c99571514f078d84c7cb9b674e887c102743..dcb7245d7a3d087bba6a47d70111ad7bb527ef16 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.pdf and b/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.pdf differ
diff --git a/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.png b/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.png
index b21bfe55488469d5ea565ba70cef281a4f09fb10..26cfdf727e29f3fc735ee91eef90ad42a8e7defc 100644
Binary files a/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.png and b/PythonScripts/Plots/CalibrationAfterRepair/ratioUD.png differ
diff --git a/PythonScripts/Plots/Presentation/DACSTART.pdf b/PythonScripts/Plots/Presentation/DACSTART.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..af289b33f7bacbaa6382707dbe89e420246e9db0
Binary files /dev/null and b/PythonScripts/Plots/Presentation/DACSTART.pdf differ
diff --git a/PythonScripts/Plots/Presentation/DACSTART.png b/PythonScripts/Plots/Presentation/DACSTART.png
new file mode 100644
index 0000000000000000000000000000000000000000..bcb3522c7232839ca7ae9fe5b095d9241ac1c393
Binary files /dev/null and b/PythonScripts/Plots/Presentation/DACSTART.png differ
diff --git a/PythonScripts/Plots/Presentation/Filtering.pdf b/PythonScripts/Plots/Presentation/Filtering.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..51425e866a4851c523b1d9448e13b99b25958883
Binary files /dev/null and b/PythonScripts/Plots/Presentation/Filtering.pdf differ
diff --git a/PythonScripts/Plots/Presentation/Filtering.png b/PythonScripts/Plots/Presentation/Filtering.png
new file mode 100644
index 0000000000000000000000000000000000000000..9c4e112813f09041595828c2de48c71ff31ecd6b
Binary files /dev/null and b/PythonScripts/Plots/Presentation/Filtering.png differ
diff --git a/PythonScripts/Plots/Presentation/FilteringDone.pdf b/PythonScripts/Plots/Presentation/FilteringDone.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..99fc911ae2c015ee55dfddda9c7499a6ff18eb18
Binary files /dev/null and b/PythonScripts/Plots/Presentation/FilteringDone.pdf differ
diff --git a/PythonScripts/Plots/Presentation/FilteringDone.png b/PythonScripts/Plots/Presentation/FilteringDone.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ca57b4cfe7ca522c174f05b2bcc616149e90d45
Binary files /dev/null and b/PythonScripts/Plots/Presentation/FilteringDone.png differ
diff --git a/PythonScripts/Plots/Presentation/FinalAmplification.pdf b/PythonScripts/Plots/Presentation/FinalAmplification.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..8c47490d907d5a8eb3397d4ad6680011c8ab414a
Binary files /dev/null and b/PythonScripts/Plots/Presentation/FinalAmplification.pdf differ
diff --git a/PythonScripts/Plots/Presentation/FinalAmplification.png b/PythonScripts/Plots/Presentation/FinalAmplification.png
new file mode 100644
index 0000000000000000000000000000000000000000..1166077c8c03b88e91359c08befff6b34e6931be
Binary files /dev/null and b/PythonScripts/Plots/Presentation/FinalAmplification.png differ
diff --git a/PythonScripts/Plots/Presentation/GeneratingSignal.pdf b/PythonScripts/Plots/Presentation/GeneratingSignal.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..bdb960e5b68a92539f05254b95456ad103c750e2
Binary files /dev/null and b/PythonScripts/Plots/Presentation/GeneratingSignal.pdf differ
diff --git a/PythonScripts/Plots/Presentation/GeneratingSignal.png b/PythonScripts/Plots/Presentation/GeneratingSignal.png
new file mode 100644
index 0000000000000000000000000000000000000000..7462c7dbae810743dddeedcb202712fb4693aa64
Binary files /dev/null and b/PythonScripts/Plots/Presentation/GeneratingSignal.png differ
diff --git a/PythonScripts/Plots/Presentation/GeneratingSignalInt.pdf b/PythonScripts/Plots/Presentation/GeneratingSignalInt.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..63c9491c9a2d7e35ee665124e678de33fa667043
Binary files /dev/null and b/PythonScripts/Plots/Presentation/GeneratingSignalInt.pdf differ
diff --git a/PythonScripts/Plots/Presentation/GeneratingSignalInt.png b/PythonScripts/Plots/Presentation/GeneratingSignalInt.png
new file mode 100644
index 0000000000000000000000000000000000000000..76c38eccbac117c47bd3edc105c1a995ec254002
Binary files /dev/null and b/PythonScripts/Plots/Presentation/GeneratingSignalInt.png differ
diff --git a/PythonScripts/Plots/Presentation/InvertedSginal.pdf b/PythonScripts/Plots/Presentation/InvertedSginal.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..a77e48f823878171ef67042452f492d1d895f0eb
Binary files /dev/null and b/PythonScripts/Plots/Presentation/InvertedSginal.pdf differ
diff --git a/PythonScripts/Plots/Presentation/InvertedSginal.png b/PythonScripts/Plots/Presentation/InvertedSginal.png
new file mode 100644
index 0000000000000000000000000000000000000000..f7556c579733fc43103f3440433cf1a272d14c15
Binary files /dev/null and b/PythonScripts/Plots/Presentation/InvertedSginal.png differ
diff --git a/PythonScripts/Plots/Presentation/Switching01.pdf b/PythonScripts/Plots/Presentation/Switching01.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..ae496592f253d1c66b51c71d710446f86b12f617
Binary files /dev/null and b/PythonScripts/Plots/Presentation/Switching01.pdf differ
diff --git a/PythonScripts/Plots/Presentation/Switching01.png b/PythonScripts/Plots/Presentation/Switching01.png
new file mode 100644
index 0000000000000000000000000000000000000000..7cbb7aa7480da405d5e8dd37191efa69937d8aba
Binary files /dev/null and b/PythonScripts/Plots/Presentation/Switching01.png differ
diff --git a/PythonScripts/Plots/Presentation/Switching02.pdf b/PythonScripts/Plots/Presentation/Switching02.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..55c6e62dbbdab9919f6fa9bbc6879a2146b15b4a
Binary files /dev/null and b/PythonScripts/Plots/Presentation/Switching02.pdf differ
diff --git a/PythonScripts/Plots/Presentation/Switching02.png b/PythonScripts/Plots/Presentation/Switching02.png
new file mode 100644
index 0000000000000000000000000000000000000000..6d5b62dcfb73d4b2446dca1a7f01ebdac30a7386
Binary files /dev/null and b/PythonScripts/Plots/Presentation/Switching02.png differ
diff --git a/PythonScripts/PresentationPlots.py b/PythonScripts/PresentationPlots.py
new file mode 100644
index 0000000000000000000000000000000000000000..11ec97da1e2d25ed61ef6e368da6c675055ab4fd
--- /dev/null
+++ b/PythonScripts/PresentationPlots.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jan  9 10:39:27 2024
+
+@author: admin
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import scipy as sp
+
+def sin_s(t):
+    x = np.where(t < np.pi, 4095 * (-1.0/(2.0*np.pi) * np.sin(2*np.pi * t / np.pi) + t / np.pi), 4095)
+    return x
+
+t = np.arange(0, np.pi, 0.001)
+pulse = sin_s(t)
+
+factor = 1/4095 * 3.3 
+
+#Signal Generated
+fig, ax = plt.subplots()
+#plt.plot(t, pulse)
+ax.plot(t / np.pi, pulse, linestyle="none", marker=".", markersize=1, label="DAC0")
+ax.plot(t / np.pi, 4095 - pulse, linestyle="none", marker=".", markersize=1, label="DAC1")
+plt.legend()
+ax.set_xlabel(r"$\frac{t}{T}$")
+ax.set_ylabel("Amplitude in arb. units")
+fig.savefig("Plots/Presentation/GeneratingSignal.pdf")
+fig.savefig("Plots/Presentation/GeneratingSignal.png", dpi=300)
+plt.show()
+
+#Signal Generated
+fig, ax = plt.subplots()
+#plt.plot(t, pulse)
+#ax.plot(t, pulse, linestyle="none", marker=".", markersize=1, label="DAC0")
+ax.plot(t / np.pi, pulse - (4095 - pulse), linestyle="none", marker=".", markersize=1, label="DAC0")
+ax.plot(t / np.pi, (4095 - pulse) - pulse, linestyle="none", marker=".", markersize=1, label="DAC1")
+plt.legend()
+ax.set_xlabel(r"$\frac{t}{T}$")
+ax.set_ylabel("Amplitude in arb. units")
+fig.savefig("Plots/Presentation/GeneratingSignal.pdf")
+fig.savefig("Plots/Presentation/GeneratingSignal.png", dpi=300)
+plt.show()
+
+#Signal Generated
+fig, ax = plt.subplots()
+#plt.plot(t, pulse)
+ax.plot(t / np.pi, pulse.astype(np.int16), linestyle="none", marker=".", markersize=1, label="DAC0")
+ax.plot(t / np.pi, 4095 - pulse.astype(np.int16), linestyle="none", marker=".", markersize=1, label="DAC1")
+plt.legend()
+ax.set_xlabel(r"$\frac{t}{T}$")
+ax.set_ylabel("Amplitude in arb. units")
+fig.savefig("Plots/Presentation/GeneratingSignalInt.pdf")
+fig.savefig("Plots/Presentation/GeneratingSignalInt.png", dpi=300)
+plt.show()
+
+#Signal In Dac At First
+fig2, ax2 = plt.subplots()
+b, a = sp.signal.bessel(8, 0.05, btype='low', analog=False)
+noised_signal_0 = pulse.astype(np.int16) + np.random.normal(0, 50, len(pulse))
+noised_signal_1 = 4095 - pulse.astype(np.int16) + np.random.normal(0, 50, len(pulse))
+ax2.plot(t / np.pi, factor * noised_signal_0, marker=".", markersize=1, label="DAC0 noisy")
+#ax2.plot(t, factor * filtered_pulse, marker=".", markersize=1, label="DAC0 bessel filtered")
+ax2.plot(t / np.pi, factor * noised_signal_1, marker=".", markersize=1, label="DAC1 noisy")
+#ax2.plot(t, factor * (4095 - filtered_pulse), marker=".", markersize=1, label="DAC1 bessel filtered")
+plt.legend()
+ax2.set_xlabel(r"$\frac{t}{T}$")
+ax2.set_ylabel("U [V]")
+fig2.savefig("Plots/Presentation/DACSTART.pdf")
+fig2.savefig("Plots/Presentation/DACSTART.png", dpi=300)
+plt.show()
+
+pulse, a_pulse = pulse - (4095 - pulse), (4095 - pulse) - pulse
+
+#Bessel Filter
+fig2, ax2 = plt.subplots()
+b, a = sp.signal.bessel(8, 0.2, btype='low', analog=False)
+noised_signal_0 = pulse.astype(np.int16) + np.random.normal(0, 50, len(pulse))
+noised_signal_1 = a_pulse.astype(np.int16) + np.random.normal(0, 50, len(pulse))
+
+filtered_pulse_0 = sp.signal.filtfilt(b, a, noised_signal_0)
+filtered_pulse_1 = sp.signal.filtfilt(b, a, noised_signal_1)
+
+ax2.plot(t / np.pi, factor * noised_signal_0, marker=".", markersize=1, label="Signal noisy")
+#ax2.plot(t, factor * filtered_pulse, marker=".", markersize=1, label="DAC0 bessel filtered")
+#ax2.plot(t, factor * noised_signal_1, marker=".", markersize=1, label="DAC1 noisy")
+#ax2.plot(t, factor * (4095 - filtered_pulse), marker=".", markersize=1, label="DAC1 bessel filtered")
+plt.legend()
+ax2.set_xlabel(r"$\frac{t}{T}$")
+ax2.set_ylabel("U [V]")
+fig2.savefig("Plots/Presentation/Filtering.pdf")
+fig2.savefig("Plots/Presentation/Filtering.png", dpi=300)
+plt.show()
+
+fig2, ax2 = plt.subplots()
+#ax2.plot(t, factor * noised_signal, marker=".", markersize=1, label="DAC0 noisy")
+ax2.plot(t / np.pi, factor * filtered_pulse_0, marker=".", markersize=1, label="Signal bessel filtered")
+#ax2.plot(t, factor * (4095 - noised_signal), marker=".", markersize=1, label="DAC1 noisy")
+#ax2.plot(t, factor * filtered_pulse_1, marker=".", markersize=1, label="DAC1 bessel filtered")
+plt.legend()
+ax2.set_xlabel(r"$\frac{t}{T}$")
+ax2.set_ylabel("U [V]")
+fig2.savefig("Plots/Presentation/FilteringDone.pdf")
+fig2.savefig("Plots/Presentation/FilteringDone.png", dpi=300)
+plt.show()
+
+
+#Generating Inverted Signal
+fig3, ax3 = plt.subplots()
+ax3.plot(t / np.pi, filtered_pulse_0 * factor, marker=".", markersize=1, label="Signal")
+ax3.plot(t / np.pi, -filtered_pulse_0 * factor, marker=".", markersize=1, label="Signal inverted")
+plt.legend()
+ax3.set_xlabel(r"$\frac{t}{T}$")
+ax3.set_ylabel("U [V]")
+fig3.savefig("Plots/Presentation/InvertedSginal.pdf")
+fig3.savefig("Plots/Presentation/InvertedSginal.png", dpi=300)
+plt.show()
+
+#Switching between Inverted and not inverted Signal
+fig4, ax4 = plt.subplots()
+ax4.plot(np.concatenate((t,t + np.pi))[: len(t)-1] / (2 * np.pi) , np.concatenate((filtered_pulse_0, -filtered_pulse_1))[: len(t)-1] * factor, marker=".", markersize=1, label="Signal")
+ax4.plot(np.concatenate((t,t + np.pi))[len(t):] / (2 * np.pi) , np.concatenate((filtered_pulse_0, -filtered_pulse_1))[len(t):] * factor, marker=".", markersize=1, label="Signal inverted")
+ax4.plot(np.concatenate((t,t + np.pi))[len(t)-1 : len(t)+1] / (2 * np.pi)  , np.concatenate((filtered_pulse_0, -filtered_pulse_1))[len(t)-1  : len(t)+1] * factor, marker=".", markersize=1, label="switch")
+plt.legend()
+ax4.set_xlabel(r"$\frac{t}{T}$")
+ax4.set_ylabel("U [V]")
+fig4.savefig("Plots/Presentation/Switching01.pdf")
+fig4.savefig("Plots/Presentation/Switching01.png", dpi=300)
+plt.show()
+
+#Switching between Inverted and not inverted Signal
+fig5, ax5 = plt.subplots()
+ax5.plot(np.concatenate((t,t + np.pi))[: len(t)-1] / (2 * np.pi) , np.concatenate((filtered_pulse_1, -filtered_pulse_0))[: len(t)-1] * factor, marker=".", markersize=1, label="Signal inverted")
+ax5.plot(np.concatenate((t,t + np.pi))[len(t)-1 : len(t)+1] / (2 * np.pi)  , np.concatenate((filtered_pulse_1, -filtered_pulse_0))[len(t)-1  : len(t)+1] * factor, marker=".", markersize=1, label="switch")
+ax5.plot(np.concatenate((t,t + np.pi))[len(t):] / (2 * np.pi) , np.concatenate((filtered_pulse_1, -filtered_pulse_0))[len(t):] * factor, marker=".", markersize=1, label="Signal")
+plt.legend()
+ax5.set_xlabel(r"$\frac{t}{T}$")
+ax5.set_ylabel("U [V]")
+fig5.savefig("Plots/Presentation/Switching02.pdf")
+fig5.savefig("Plots/Presentation/Switching02.png", dpi=300)
+plt.show()
+
+#Switching between Inverted and not inverted Signal
+fig6, ax6 = plt.subplots()
+ax6.plot(np.concatenate((t,t + np.pi))[: len(t)-1] / (2 * np.pi) , np.concatenate((filtered_pulse_0, -filtered_pulse_1))[: len(t)-1] * factor * 24.24, marker=".", markersize=1, label="Signal")
+ax6.plot(np.concatenate((t,t + np.pi))[len(t):] / (2 * np.pi) , np.concatenate((filtered_pulse_0, -filtered_pulse_1))[len(t):] * factor* 24.24, marker=".", markersize=1, label="Signal inverted")
+ax6.plot(np.concatenate((t,t + np.pi))[len(t)-1 : len(t)+1] / (2 * np.pi)  , np.concatenate((filtered_pulse_0, -filtered_pulse_1))[len(t)-1  : len(t)+1] * factor* 24.24, marker=".", markersize=1, label="switch")
+plt.legend()
+ax6.set_xlabel(r"$\frac{t}{T}$")
+ax6.set_ylabel("U [V]")
+fig6.savefig("Plots/Presentation/FinalAmplification.pdf")
+fig6.savefig("Plots/Presentation/FinalAmplification.png", dpi=300)
+plt.show()