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()