def run(): import_from = int( input("Import from\n(default = 1)\n\n1 - html\n2 - csv\n") or 1) rows = import_file(import_from) if rows != []: tb.write(rows[::-1]) pv.updateall(rows)
def from_html(): # solved # html parsing with open(html_file, "r", encoding="utf-8") as f: contents = f.read() sp = soup(contents, "lxml") rows = [tuple(row) for row in sp.tbody.find_all("tr")] # corrected row rows = list(modifyrows(html_data, rows)) if tb.count("lastrow") == 0: tb.write(rows[0], "lastrow") num_lastrow = len(rows) else: lastrow = tb.read()[0] num_lastrow = rows.index(lastrow) tb.update(rows[0]) log(num_lastrow) return rows[:num_lastrow]
def create_pivot(table): # solved create(table) header, column = ( [result, "result"] if table == "win_loss" else [fractions, "opponent_fraction"] ) if table in ("win_loss", "versus"): for fraction in fractions.keys(): column_count = tuple( tb.count("games", [("fraction", fraction), (column, value)]) for value in header.keys() ) row = (fraction,) + column_count tb.write(row, table) elif table in ("overall"): overall = tuple( tb.count("games", [("fraction", fraction), ("result", "Победа")]) for fraction in fractions.keys() ) row = (sum(overall),) + overall tb.write(row, table)
plt.savefig('build/plot_ds.pdf') ####################### WRITING RESULT TABLES ####################### slits = ['klein', 'mittel', 'groß', 'doppel'] b = np.array([b_k, b_m, b_g, b_ds]) # in m b_hst = np.array([b_k_hst, b_m_hst, b_g_hst, b_ds_hst]) # in m b_err = np.abs(((b-b_hst) / b_hst)) # relative error A0 = np.array([A0_k, A0_m, A0_g, A0_ds]) # in A/m s_err = np.abs(np.array([(s_ds - s_ds_hst) / s_ds_hst])) # relative error s_mic = np.array([s_ds_mic]) s = np.array([s_ds]) s_hst = np.array([s_ds_hst]) write('build/Tabelle_results.tex', make_table([slits, zeta_0*1e3, A0, b_microscope*1e3, b*1e3, b_hst*1e3, b_err*1e2], [0, 2, 1, 2, 1, 2, 1])) write('build/Tabelle_results_texformat.tex', make_full_table( caption = r'Herstellerangaben, Mikroskopmessungen, Firparameter und der Fehler zwischen Fit und Herstellerangabe für die Spaltbreite $b$.', label = 'table:A1', source_table = 'build/Tabelle_results.tex', stacking = [2,4,6], units = [ 'Spalt', r'$\zeta_0 \:/\: \si{\milli\meter}$', r'$A_0 \:/\: \si{\ampere\per\meter}$', r'$b_\text{mic} \:/\: \si{\milli\meter}$', r'$b_\text{mess} \:/\: \si{\milli\meter}$', r'$b_\text{hst} \:/\: \si{\milli\meter}$', r'$|\varepsilon_b| \:/\: \si{\percent}$'])) write('build/Tabelle_results_s.tex', make_table([s_mic*1e3, s*1e3, s_hst*1e3, s_err*1e2], [2, 1, 2, 1]))
# vacuum velo of light c = 299792458 # metre per second # diffraction distance d = 201.4e-12 # metre #elementary charge e = 1.6e-19#coulomb #Rydbergonstante r = 13.6 #eV #sommerfeldsche Feinstrukturkonstante s_k = 7.29e-3 zwei_theta, impulsrate = np.genfromtxt('messdaten/1_Messung_werte.txt', unpack=True) write('build/Tabelle_messung_1.tex', make_table([zwei_theta,impulsrate],[1, 0])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_messung_1_texformat.tex', make_full_table( 'Messdaten Bragg Bedingung.', 'table:A2', 'build/Tabelle_messung_1.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r'$\theta \:/\: \si{\degree}$', r'$Zaehlrate$'])) theta, Z = np.loadtxt("messdaten/Bremsberg_werte.txt", unpack=True) theta = theta/2
def do_job_a(filename, error, j, filename_out=None): # Einlesen der Messdaten P, Delta_f_30, Delta_f_15, Delta_f_60 = np.genfromtxt(filename, unpack=True) # di = [7, 10, 16] colors = ["rx", "bx", "gx"] Delta_f_30_error = Delta_f_30 * error Delta_f_30 = unp.uarray(Delta_f_30, Delta_f_30_error) Delta_f_15_error = Delta_f_15 * error Delta_f_15 = unp.uarray(Delta_f_15, Delta_f_15_error) Delta_f_60_error = Delta_f_60 * error Delta_f_60 = unp.uarray(Delta_f_60, Delta_f_60_error) v = unp.uarray(np.zeros(3), np.zeros(3)) v[0] = c_L / 2 / nu_0 * Delta_f_30 / np.cos(alpha[0]) v[1] = c_L / 2 / nu_0 * Delta_f_15 / np.cos(alpha[1]) v[2] = c_L / 2 / nu_0 * Delta_f_60 / np.cos(alpha[2]) v_mean = mean([v[0], v[1], v[2]], 0) # TABLES write( "build/Tabelle_a_" + str(di[j]) + ".tex", make_table([P, Delta_f_30, Delta_f_15, Delta_f_60, v[0], v[1], v[2], v_mean], [0, 1, 1, 1, 1, 1, 1, 1]), ) write( "build/Tabelle_a_" + str(di[j]) + "_texformat.tex", make_full_table( r"Messdaten und daraus errechnete Geschwindikgiet für $\d_i = $" + str(di[j]) + r"$\si{\milli\meter}$.", "table:A" + str(j), "build/Tabelle_a_" + str(di[j]) + ".tex", [1, 2, 3, 4, 5, 6, 7], [ r"$\frac{P}{P_\text{max}} \:/\: \si{\percent}$", r"$\Delta f_{30°} \:/\: \si{\hertz}$", r"$\Delta f_{15°} \:/\: \si{\hertz}$", r"$\Delta f_{60°} \:/\: \si{\hertz}$", r"$v_{30°} \:/\: \si{\meter\per\second}$", r"$v_{15°} \:/\: \si{\meter\per\second}$", r"$v_{60°} \:/\: \si{\meter\per\second}$", r"$\overline{v} \:/\: \si{\meter\per\second}$", ], ), ) # Plotting plt.figure(1) y = Delta_f_30 / np.cos(alpha[0]) plt.errorbar( noms(v[0]), noms(y), fmt=colors[j], xerr=stds(v[0]), yerr=stds(y), label=r"$d_i = " + str(di[j]) + r"\si{\milli\meter}$", ) plt.figure(2) y = Delta_f_15 / np.cos(alpha[1]) plt.errorbar( noms(v[1]), noms(y), fmt=colors[j], xerr=stds(v[1]), yerr=stds(y), label=r"$d_i = " + str(di[j]) + r"\si{\milli\meter}$", ) plt.figure(3) y = Delta_f_60 / np.cos(alpha[2]) plt.errorbar( noms(v[2]), noms(y), fmt=colors[j], xerr=stds(v[2]), yerr=stds(y), label=r"$d_i = " + str(di[j]) + r"\si{\milli\meter}$", ) i = 1 if filename_out: for name in filename_out: plt.figure(i) plt.xlabel(r"$v \:/\: \si{\meter\per\second}$") plt.ylabel(r"$\Delta\nu / \cos{\alpha} \:/\: \si{\kilo\volt}$") plt.legend(loc="best") plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig(name) i += 1
# Tabelle für Messdaten Tiefe, Delta_f_45, Intensity_45 = np.genfromtxt("messdaten/stroemungsprofil45.txt", unpack=True) Tiefe, Delta_f_70, Intensity_70 = np.genfromtxt("messdaten/stroemungsprofil70.txt", unpack=True) error = 0.07 Delta_f_45_error = Delta_f_45 * error Delta_f_45 = unp.uarray(Delta_f_45, Delta_f_45_error) Delta_f_70_error = Delta_f_70 * error Delta_f_70 = unp.uarray(Delta_f_70, Delta_f_70_error) Intensity_45_error = Intensity_45 * error Intensity_45 = unp.uarray(Intensity_45, Intensity_45_error) Intensity_70_error = Intensity_70 * error Intensity_70 = unp.uarray(Intensity_70, Intensity_70_error) write( "build/Tabelle_messdaten.tex", make_table([Tiefe, Delta_f_45, Intensity_45, Delta_f_70, Intensity_70], [0, 1, 1, 1, 1]), ) write( "build/Tabelle_messdaten_texformat.tex", make_full_table( "Messdaten zum Strömungsprofil.", "table:messdaten_b", "build/Tabelle_messdaten.tex", [1, 2, 3, 4], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r"$\text{Laufzeit} \:/\: \si{\micro\second}$", r"$\Delta f_{45\si{\percent}} \:/\: \si{\hertz}$", r"$I_{45\si{\percent}} \:/\: \si{\kilo\square\volt\per\second}$", r"$\Delta f_{70\si{\percent}} \:/\: \si{\hertz}$", r"$I_{70\si{\percent}} \:/\: \si{\kilo\square\volt\per\second}$",
print('eta_1:', eta_1) print('eta_2:', eta_2) ################################################################ ### etas und phi ausrechnen ################################################################ phi = 0.5 * (phi_1 - phi_2) phi_Mittel = ufloat(np.mean(phi), np.std(phi)/np.sqrt(len(phi))) # eta = 180 - (360 + eta_1 - eta_2) eta = 180 - (eta_1-eta_2) # mit den Werten von Sonja und Saskia print('eta:', eta) print('phi_Mittel:', phi_Mittel) write('build/Messwerte1.tex', make_table([phi_1, phi_2, phi],[1,1,1])) write('build/Winkel_Prisma.tex', make_SI(phi_Mittel,r'',figures=1)) write('build/Messwerte2.tex', make_table([wavelength*10**9, eta_1, eta_2, eta],[2,1,1,1])) ################################################################ phi_Mittel = 60 ################################################################ ### Brechzahl ################################################################ n = unp.sin( 0.5 * 2 * np.pi / 360 * (eta + phi_Mittel) ) / unp.sin( 0.5 * 2 * np.pi / 360 * phi_Mittel) print('Brechzahl:', n)
from utility import( constant ) ################################################ Finish importing custom libraries ################################################# ########################### a) ############################ Z, I = np.genfromtxt('messdaten/a.txt', unpack=True) # I in µA I = I*1e-6 # in A U = np.array(range(320, 710, 10)) delta_t = 10 # fix for a) Z_err = np.sqrt(Z) # poisson verteilt Z_unc = unp.uarray(Z, Z_err) # mit Fehlern versehen N = Z_unc / delta_t # Zählrate delta_Q = I/N/constant('elementary charge')*1e-10 # in 10^10 e write('build/Tabelle_a.tex', make_table([U, Z_unc, N, I*1e6, delta_Q],[0, 1, 1, 1, 1])) write('build/Tabelle_a_texformat.tex', make_full_table( caption = 'Messdaten für die Charakteristik des Zählrohrs.', label = 'table:a', source_table = 'build/Tabelle_a.tex', stacking = [1,2,4], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [r'$U \:/\: \si{\volt}$', r'$Z$', r'$N \:/\: \si{\per\second}$', r'$I \:/\: 10^{10}\si{\micro\ampere}$', r'$\Delta Q \:/\: \si{\elementarycharge}$'])) ##### Fit #### no_of_first_ignored_values = 3 no_of_last_ignored_values = 5
make_SI, write, ) from uncertainties import ufloat ############Echo-Methode######### h_zylinder_messung = np.array([61.5, 80.55, 102.1, 120.5, 31.1+61.5, 31.3+80.55]) t_zylinder_messung = np.array([44.9, 58.3, 75.0, 87.4, 67.8, 81.1]) np.savetxt('messdaten/a.txt', np.column_stack([h_zylinder_messung, t_zylinder_messung]), header="h [mm], t[µs]") U_2 = 1.105 U_1 = 1.214 t_1 = 1.3 t_2 = 46.2 write('messdaten/U_1.tex', make_SI(U_1, r'\volt', figures=3)) write('messdaten/U_2.tex', make_SI(U_2, r'\volt', figures=3)) write('messdaten/t_1.tex', make_SI(t_1, r'\micro\second', figures=1)) write('messdaten/t_2.tex', make_SI(t_2, r'\micro\second', figures=1)) ###########Durchschallungs-Methode############### h_zylinder_messung = np.array([31.3,61.5, 80.55,]) t_zylinder_messung = np.array([23.1, 45.6, 60.9]) np.savetxt('messdaten/b.txt', np.column_stack([h_zylinder_messung, t_zylinder_messung]), header="h [mm], t[µs]") ###Auge### a_1 = 20*(0.3/7) a_2 = 16.8
from ErrorCalculation import ( MeanError, rmse, ) #a) Wheatstonebrücke #Widerstand Wert 14, 10 Wert_a, R_2, c = np.genfromtxt('Messergebnisse/a.txt', unpack=True) R_2er = R_2*0.002 R_3 = c R_4 = 1000-c R_34 = R_3 / R_4 R_34er = R_34*0.005 R2 = unp.uarray(R_2, R_2er) R34 = unp.uarray(R_34, R_34er) write('build/wheat1tabelle.tex', make_table([Wert_a, R2, R34], [0,1,1 , 1, 1])) Rx = R2*R34 Rx_mean_Wert14=np.mean(Rx[0:3]) Rx_mean_Wert10=np.mean(Rx[3:6]) Rx_mean_Wert14_err = MeanError(noms(Rx[0:3])) Rx_mean_Wert10_err = MeanError(noms(Rx[3:6])) # Building Arrays from this... Werte_a = np.array([Wert_a[0], Wert_a[3]]) Rx_mean = np.array([Rx_mean_Wert14, Rx_mean_Wert10]) # Mittelwert und syst. Fehler Rx_mean_err = np.array([Rx_mean_Wert14_err, Rx_mean_Wert10_err]) # stat. Fehler write('build/Tabelle_err_a.tex', make_table([Werte_a, Rx_mean, Rx_mean_err],[0, 1, 0])) write('build/Tabelle_a.tex', make_table([Wert_a, R2, R34, Rx], [0, 1, 1, 1]))
saturation_current_3 = saturation_current(d.anode_3,1) saturation_current_4 = saturation_current(d.anode_4,1) saturation_current_5 = saturation_current(d.anode_5,1) saturation_current = [] saturation_current.append(saturation_current_1) saturation_current.append(saturation_current_2) saturation_current.append(saturation_current_3) saturation_current.append(saturation_current_4) saturation_current.append(saturation_current_5) saturation_tab = copy.deepcopy(saturation_current) d.make_it_SI2(saturation_tab,6) #write('../tex-data/saturation.tex', # make_table([[1,2,3,4,5],saturation_current], [0, 6])) write('../tex-data/saturation.tex', make_table([[1,2,3,4,5],saturation_tab], [0, 0])) print("Sättigungsstrom 1:",saturation_current_1) print("Sättigungsstrom 2:",saturation_current_2) print("Sättigungsstrom 3:",saturation_current_3) print("Sättigungsstrom 4:",saturation_current_4) print("Sättigungsstrom 5:",saturation_current_5) #calculationg the Langmuir-Schottkysche exponent - should be 1.5 def langmuh_Reg(V, a, b): return a*V + b def make_it_ln(array, k): """takes the logarithm"""
make_table, make_full_table, make_composed_table, make_SI, write, ) ###################################################################################################################################################### ## Verdampfungswärme # Daten einlesen vorgegebene Daten p1, T1 = np.genfromtxt('Messdaten/Verdampfungskurve.txt', unpack=True) T1 += 273.1 # T in K p1 += 1 # Offset 1 bar p1 *= 1e5 # in Pa write('build/Tabelle_Verdampfungskurve.tex', make_table([T1, p1, 1e3/(T1), np.log(p1)], [1,1,3,2])) write('build/Tabelle_Verdampfungskurve_texformat.tex', make_full_table( 'Abgelesene und daraus abgeleitete Werte für die Berechnung der Verdampfungswärme.', 'table:A1', 'build/Tabelle_Verdampfungskurve.tex', [], [r'$T \:/\: \si{\kelvin}$', r'$p \:/\: \si{\bar}$', r'$\frac{1}{T} \:/\: 10^{-3}\si{\per\kelvin}$', r'$\ln{(p/\si{\pascal})}$'])) # Fit Verdampfungskurve params = ucurve_fit(reg.reg_linear, 1/T1, np.log(p1), p0=[-1, 1]) m1, b1 = params write('build/m1.tex', make_SI(m1, r'\kelvin', '', 1)) # 1 signifikante Stelle write('build/b1.tex', make_SI(b1, r'', '', 1)) # 1 signifikante Stelle
import scipy.constants as const import uncertainties.unumpy as unp from uncertainties import ufloat from uncertainties.unumpy import ( nominal_values as noms, std_devs as stds, ) from curve_fit import ucurve_fit from table import ( make_table, make_SI, write, ) p1, T1, T1_fl = np.genfromtxt('Messwerte/bis1000mBar.txt', unpack=True) write('build/MessdatenBis1Bar.tex', make_table([T1, p1, 1e3/(T1+273.1), np.log(p1*1e2)], [0,0,3,2])) # p1 in mbar, T in °C, 1/T in 10^-3 K^-1, ln(p/Pa) T1 += 273.1 # T in K p1 *= 1e2 # p in N/m^2 (Pa) # lineare Regression def f(x, m, b): return m * x + b # Druck als Funktion der Temperatur n=3 def g(x, d, c, b, a): return d*x**3+c*x**2+b*x+a # Druck als Funktion der Temperatur n=4 def h(x, e, d, c, b, a): return e*x**4+d*x**3+c*x**2+b*x+a # Verdampfungswärme als Funktion der Temperatur def L(konst_a, konst_R, T, d, c, b, a):
write, ) from regression import ( reg_linear, reg_quadratic, reg_cubic ) from error_calculation import( MeanError ) ################################################ Finish importing custom libraries ################################################# #variable_Scanart_Richtung rho_acryl = 1180 #kg/m^3 write('build/rho.tex', make_SI(rho_acryl, r'\kilo\gram\per\cubic\meter', figures=0)) E_acryl = 3300 #N/mm^^2 write('build/E.tex', make_SI(E_acryl, r'\newton\per\milli\meter\tothe{2}', figures=0)) E_acryl *= 1e6 c_acryl_1 = np.sqrt(E_acryl/rho_acryl) write('build/c_acryl.tex', make_SI(c_acryl_1, r'\meter\per\second', figures=2)) Höhe = 8.03 #cm Tiefe = 4.04 #cm Laenge = 15.01 #cm write('build/Hoehe.tex', make_SI(Höhe, r'\centi\meter', figures=2)) write('build/Tiefe.tex', make_SI(Tiefe, r'\centi\meter', figures=2)) write('build/Laenge.tex', make_SI(Laenge, r'\centi\meter', figures=2)) Num = [1,2,3,4,5,6,7,8,9,10,11] c_luft = 343.2 #m/s
# Dämpfungswiderstand ausrechnen # params_max = ucurve_fit(reg.reg_linear, tmax, Umax_log) params_max = ucurve_fit(reg.reg_linear, text, U_pos_ges_log) R_a, Offset_a = params_max print('R_a') print(R_a) R_a_2 = R_a*(-2*10.11e-3) R_dampf_theo = 2*(unp.sqrt(L[0]/C[0])) print('hhhhhhh') print(L[0]) print(C[0]) write('build/R_daempfung_theo.tex', make_SI(R_1[0], r'\ohm', figures=1)) write('build/R_daempfung_mess.tex', make_SI(R_a_2, r'\ohm', figures=1)) # type in Anz. signifikanter Stellen write('build/R_abweichung.tex', make_SI(R_a_2-R_1[0], r'\ohm', figures=1)) # write('build/loesung-b.tex', make_SI(b * 1e-3, r'\kilo\hertz', figures=1)) # Abklingzeit ausrechnen Abklingzeit_max = np.log(np.max(Umax)/np.exp(1)/noms(Offset_a)) / R_a Abklingzeit_theo = 2*L[0] / R_1[0] write('build/Abklingzeit_theo.tex', make_SI(Abklingzeit_theo*1e3, r'\milli\second', figures=1)) write('build/Abklingzeit_mess.tex', make_SI(Abklingzeit_max*(-1e3), r'\milli\second', figures=1)) write('build/Abklingzeit_abweichung.tex', make_SI(-Abklingzeit_max*(-1e3)+Abklingzeit_theo*1e3, r'\milli\second', figures=1)) # plt.plot(tmax*1e3, Umax, 'rx', label='Messdaten') # plt.plot(tmax*1e3, np.exp(noms(Offset_a)+tmax*noms(R_a)), 'b-', label='Fit') plt.plot(text*1e3, np.abs(Uext), 'rx', label='Messdaten') plt.plot(text*1e3, np.exp(noms(Offset_a)+text*noms(R_a)), 'b-', label='Fit')
reg_cubic ) from error_calculation import( mean, MeanError ) from utility import( constant ) ################################################ Finish importing custom libraries ################################################# #Nulleffekt nach einer Wartezeit von 900s Nu=460 t_0=900 #in s N_Offset_Indium = (Nu/t_0)*220 write('build/Fehler_Indium.tex', make_SI(N_Offset_Indium, r'', figures=1)) N_Offset_Silber = (Nu/t_0)*9 #Import Data #Indium = Ind #Silber = Si Ind_nom, t = np.genfromtxt('messdaten/Indium.txt', unpack=True) Ind_nom = Ind_nom - N_Offset_Indium Ind = unp.uarray(Ind_nom, np.sqrt(Ind_nom)) # Ind = unp.uarray(Ind_nom, N_Offset_Indium) write('build/Tabelle_Indium.tex', make_table([Ind,t],[1, 0])) write('build/Tabelle_Indium_texformat.tex', make_full_table( caption = 'Messdaten von Indium unter Berücksichtigung des Nulleffekts.', label = 'table:Indium',
make_SI, write, ) from ErrorCalculation import ( MeanError ) m_K = ufloat(0.5122, 0.5122*4e-4) # in kg 0,04 % Fehler d_K = ufloat(50.76, 7e-5*50.76)*1e-3 # in m, 0,007 % Fehler R_K = d_K/2 Theta_Aufhaengung = 22.5 *1e-3 *1e-4 # aus gcm² werden kgm³ Windungszahl = 390 r_HelmHoltz = 78e-3 # m E_lit = 21e10 # N/m² write('build/E.tex', make_SI(E_lit*1e-10, r'\newton\per\square\meter', 'e10', figures=1)) G_lit = 8.21e10 # N/m² write('build/G_lit.tex', make_SI(G_lit*1e-10, r'\newton\per\square\meter', 'e10', figures=1)) B_welt_lit = 3e-5 # T write('build/B_lit.tex', make_SI(B_welt_lit*1e6, r'\micro\tesla', figures=1)) D_array = (np.array([0.179,0.180,0.187,0.182,0.171])+0.024)*1e-3 R = ufloat(np.mean(D_array), np.std(D_array))/2 L_1_array = (np.array([0.552,0.553,0.553])) L_1 = ufloat(np.mean(L_1_array), np.std(L_1_array)) L_2_array = np.array([0.048, 0.049, 0.048]) L_2 = ufloat(np.mean(L_2_array), np.std(L_2_array)) L = L_1 + L_2 write('build/L.tex', make_SI(L*1e2, r'\centi\meter', figures=1)) write('build/R.tex', make_SI(R*1e3, r'\milli\meter', figures=1))
########## DIFFERENT STUFF ########## # R = const.physical_constants["molar gas constant"] # Array of value, unit, error ### VORARBEITEN #### h_zylinder, t_zylinder = np.genfromtxt('messdaten/a.txt', unpack=True) h_zylinder = h_zylinder*10**(-3) t_zylinder = t_zylinder*10**(-6) ##### a ##### v_zylinder = 2*h_zylinder/t_zylinder write('build/Tabelle_0.tex', make_table([h_zylinder*10**3, t_zylinder*10**6, v_zylinder],[2, 1, 2])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_0_texformat.tex', make_full_table( 'Bestimmung der Schallgeschwindigkeit mittels Impuls-Echo-Verfahren.', 'tab:0', 'build/Tabelle_0.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [r'$h_{\text{zylinder}} \:/\: 10^{-3} \si{\metre}$', r'$\increment t \:/\: 10^{-6} \si{\second} $', r'$c_\text{Acryl} \:/\:\si{\metre\per\second} $'])) c_arcyl_1 = ufloat(np.mean(v_zylinder), np.std(v_zylinder)) write('build/c_acryl_1.tex', make_SI(c_arcyl_1, r'\metre\per\second', figures=2)) # type in Anz. signifikanter Stellen params = ucurve_fit(reg_linear, 0.5*t_zylinder, h_zylinder) # linearer Fit a, b = params
#write('../tex-data/v.tex', # make_table([[drops[i][0] for i in range(len(drops))], [drops[i][1] for i #in range(len(drops))], [drops[i][2] for i in range(len(drops))], #[drops[i][3] for i in range(len(drops))]], [0, 1, 1, 1])) fuck1 = [] fuck2 = [] fuck3 = [] fuck4 = [] for i in range(len(drops)): fuck1.append(drops[i][0]) fuck2.append(drops[i][1]*10**(5)) fuck3.append(drops[i][2]*10**(5)) fuck4.append(drops[i][3]*10**(5)) print(fuck3) write('../tex-data/v.tex', make_table([fuck1,fuck2,fuck3,fuck4], [0, 2, 2, 2])) #print(drops) #for i in range(len(drops)): # diff = drops[i][2]-drops[i][3] # print(diff, i) # if drops[i][1] != 0: # c = 2*drops[i][1] / diff # print("Difference:" ,c ,"Stelle:", i) # #for i in range(len(drops2)): # diff = drops2[i][2]-drops2[i][3] # print(diff, i) # if drops2[i][1] != 0: # c2 = 2*drops2[i][1] / diff # print("Difference:" ,c2 ,"Stelle:", i)
def do_job_b(filename, error, P, limits): # Einlesen der Messdaten Tiefe, Delta_f, Intensity = np.genfromtxt(filename, unpack=True) colors = ["rx", "bx", "gx"] Delta_f_error = Delta_f * error Delta_f = unp.uarray(Delta_f, Delta_f_error) v = c_L / 2 / nu_0 * Delta_f / np.cos(alpha[1]) # 15 ° Winkel ###### Fit im Intervall limits mit quadratischer Funktion gemäß dem Gesetz von Hagen-Poiseuille i = 0 start = 0 end = 0 for x in Tiefe: if x == limits[0]: start = i if x == limits[1]: end = i i += 1 params = ucurve_fit(reg_quadratic, Tiefe[start : (end + 1)], v[start : (end + 1)]) # quadratischer Fit a, x0, c = params write("build/parameter_a.tex", make_SI(a * 1e-3, r"\kilo\volt", figures=1)) ##### Ende Fit ######## # Plotting plt.clf fig, ax1 = plt.subplots() t_plot = np.linspace(limits[0] - 0.5, limits[1] + 0.5, 50) # Momentangeschwindigkeiten Ins1 = ax1.plot(Tiefe, noms(v), "rx", label="Momentangeschwindigkeit") Ins2 = ax1.plot(t_plot, reg_quadratic(t_plot, *noms(params)), "r--", label="Fit") ax1.set_xlabel(r"$\text{Laufzeit} \:/\: \si{\micro\second}$") ax1.set_ylabel(r"$v \:/\: \si{\meter\per\second}$") if P == 45: ax1.set_ylim(0.45, 0.9) # hard coded stuff ftl ! # Streuintensitäten ax2 = ax1.twinx() Ins3 = ax2.plot(Tiefe, Intensity, "b+", label="Intensität") ax2.set_ylabel(r"$I \:/\: \si{\kilo\volt\squared\per\second}$") # Theoretische Grenzen des Rohres einzeichnen ax1.plot((noms(x0) - 5 / 1.5, noms(x0) - 5 / 1.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1) ax1.plot((noms(x0) + 5 / 1.5, noms(x0) + 5 / 1.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1) ax1.plot( (noms(x0) - 5 / 1.5 - 2.5 / 2.5, noms(x0) - 5 / 1.5 - 2.5 / 2.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1, ) ax1.plot( (noms(x0) + 5 / 1.5 + 2.5 / 2.5, noms(x0) + 5 / 1.5 + 2.5 / 2.5), (ax1.get_ylim()[0], ax1.get_ylim()[1]), "k:", linewidth=1, ) Ins = Ins1 + Ins2 + Ins3 labs = [l.get_label() for l in Ins] ax1.legend(Ins, labs, loc="upper left") plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig("build/Plot_b_P" + str(P) + ".pdf")
from scipy.optimize import curve_fit from uncertainties import ufloat from scipy.constants import e from table import ( make_table, make_full_table, make_SI, write,) U, c = np.genfromtxt('Messung1.txt', unpack = True) t = 10 #Messzeit 10 sekunden Z = c / t #Zählrate in counts/second Z_fehler = np.sqrt(c)/t write('build/tabelle_charakteristik.txt', make_table([U[:15], Z[:15], Z_fehler[:15], U[15:], Z[15:], Z_fehler[15:]], [2,2,2,2,2,2])) plt.plot(U, Z, 'ko', label='Messwerte') plt.errorbar(U, Z, xerr=1, yerr=Z_fehler, fmt='r.', label = r'Statistischer Fehler') plt.legend(loc='best') plt.xlabel(r'Spannung $U \ /\ \mathrm{V}$') plt.ylabel(r'Zählrate $Z \ /\ {\mathrm{Counts}}/{\mathrm{s}}$') plt.xlim(0,750) plt.savefig('build/charakteristik_gesamt.png') plt.show() def linear(x, m, b): return m*x+b
# Bestimmung der Gitterkonstante # bekannte Wellenlängen der Helium Spektrallinien (hier muss die # Reihenfolge natürlich übereinstimmen mit derjenigen der Datei # WinkelHelium.txt): lambda_helium = np.array([438.8, 447.1, 471.3, 492.2, 501.6, 504.8, 587.6, 667.8, 706.5]) * 1e-9 # in m # sinus für den plot und den fit sin_phi_helium = np.array(np.sin(phi_helium)) # fit sin(phi) gegenüber lambda zur Bestimmung von g params_gitterkonstante = ucurve_fit( reg_linear, sin_phi_helium, lambda_helium) g, offset = params_gitterkonstante # g in m, offset Einheitenfrei write('build/gitterkonstante.tex', make_SI(g * 1e9, r'\nano\meter', figures=1)) write('build/offset.tex', make_SI(offset * 1e9, r'\nano\meter', figures=1)) write('build/Tabelle_messdaten_kalium.tex', make_table([phi_kalium*180/np.pi],[1])) write('build/Tabelle_messdaten_natrium.tex', make_table([phi_natrium*180/np.pi],[1])) write('build/Tabelle_messdaten_rubidium.tex', make_table([phi_rubidium*180/np.pi],[1])) ##### PLOT lineare Regression ##### t_plot = np.linspace(np.amin(sin_phi_helium), np.amax(sin_phi_helium), 2) plt.xlim(t_plot[0] - 1 / np.size(sin_phi_helium) * (t_plot[-1] - t_plot[0]), t_plot[-1] + 1 / np.size(sin_phi_helium) * (t_plot[-1] - t_plot[0])) plt.plot(t_plot, reg_linear(t_plot, *noms(params_gitterkonstante))* 1e9, 'b-', label='Fit') plt.plot(sin_phi_helium, lambda_helium * 1e9, 'rx', label='Messdaten')
plt.plot(x, max(puls1)/2+0.00000001*x, 'k--') plt.annotate(' Mittlere \n Reichweite', xy=(reichweite1.n, max(puls1)/2), xytext=(2.05, 55000), arrowprops=dict(facecolor='black', shrink=0.05), ) plt.xlabel('Effektiver Abstand zwischen Detektor und Strahler x in cm') plt.ylabel('$10^3$ Pulse pro 120s') plt.ylim(30000,120000) plt.xlim(0,2.5) plt.legend(loc='lower left') # 2 = upper left plt.savefig('build/pulse1.png') plt.show() write('build/reichweite1.txt', make_SI(reichweite1, r'\centi\meter', figures=2)) write('build/m1.txt', make_SI(m1, r'\per\centi\meter', figures=1)) write('build/b1.txt', make_SI(b1, r'', figures=1)) write('build/tabelle_messung1.txt', make_table([p1, puls1, x1], [0,0,2])) ########gleiches für messung2 parameters2, popt2 = curve_fit(linear, x2[12:], puls2[12:]) m2 = ufloat(parameters2[0], np.sqrt(popt2[0,0])) b2 = ufloat(parameters2[1], np.sqrt(popt2[1,1])) #mittelere reichweite bestimmen (lineare gleichung auflösen) reichweite2 = (max(puls2)/2 - b2)/m2 print(reichweite2)
k += 1 print ('Parabel') print (a_parabel) a_parabel *= 0.5967 # b) n = [1,2,3,4,5,6,7,8,9] n_ungerade = [1,3,5,7,9,11,13,15,17] U_Dreieck, Skala_Dreieck = np.genfromtxt('Messdaten/Dreieckspannung.txt', unpack=True) U_Dreieck_Fehler = 0.1 * Skala_Dreieck U_Dreieck *= Skala_Dreieck U_Dreieck_ges = unp.uarray(U_Dreieck, U_Dreieck_Fehler) U_Dreieck_normiert = U_Dreieck_ges / U_Dreieck_ges[0] RelFehler_Dreieck = np.abs(U_Dreieck_normiert - a_Dreieck) / a_Dreieck * 100 write('build/Tabelle_Dreieck_1.tex', '1 & 2.8 & 0.1 & 1 & 0 & 1 & 0 & 0 \\\\') write('build/Tabelle_Dreieck_2.tex', make_table([n_ungerade[1:],U_Dreieck_ges[1:],U_Dreieck_normiert[1:],a_Dreieck[1:], RelFehler_Dreieck[1:]],[0, 1, 1, 3, 1])) write('build/Tabelle_Dreieck.tex', make_composed_table(['build/Tabelle_Dreieck_1.tex','build/Tabelle_Dreieck_2.tex'])) ## FULLTABLE write('build/FK_Dreieck_texformat.tex', make_full_table( 'Messdaten, Theoriewerte und relativer Messfehler $f$ der normierten Fourierkoeffizienten: Dreieckspannung.', 'table:FK_Dreieck', 'build/Tabelle_Dreieck.tex', [1,2,4], ['$k$', r'$U_{k,\text{mess}} \:/\: \si{\volt}$', r'$\frac{U_{k,\text{mess}}}{U_{1,\text{mess}}}$', r'$\Abs{\frac{U_{k,\text{theo}}}{U_{1,\text{theo}}}}$', r'$f$ \:/\: \si{\percent}']))
SilberAnf = Silber def Regression(x, m, b): return m*x + b ############################################################################################################### ### Brom ###################################################################################################### ############################################################################################################### tBrom = np.array(range(1,11)) tB = np.linspace(0, 33, num=10) paramsBrom, poptBrom = curve_fit(Regression, tBrom*3, np.log(Brom), sigma = np.log(np.sqrt(Brom))) TBrom = -np.log(2)/ufloat(paramsBrom[0], poptBrom[0,0]) write('build/BromT.tex', make_SI(TBrom, r'\second', figures=1)) plt.errorbar(tBrom*3, Brom, xerr=0, yerr=np.sqrt(Brom), fmt='ko', label = 'Messdaten') plt.plot(tB, np.exp(Regression(tB, paramsBrom[0], paramsBrom[1])), 'r', label = 'Regressionsgerade') plt.xticks(np.arange(0, 3*max(tBrom)+3, 3.0)) plt.legend(loc='best') plt.xlabel('Zeit $t$ in Minuten') plt.ylabel('Anzahl der Pulse in $180s$ ') plt.yscale('log') plt.savefig('build/Brom.png') plt.show() ############################################################################################################### ### Silber ####################################################################################################
from curve_fit import ucurve_fit from table import ( make_table, make_full_table, make_composed_table, make_SI, write, ) import Regression as reg # allgemeingültige Werte: L = 1.75e-3 #Henry C1 = 22e-9 #Farad C2 = 9.4e-9 #Farad write('build/L.tex', make_SI(L * 1e3, r'\milli\henry', figures=2)) write('build/C1.tex', make_SI(C1 * 1e9, r'\nana\farad', figures=1)) write('build/C2.tex', make_SI(C2 * 1e9, r'\nana\farad', figures=1)) # a) # Abschlusswiderstand (Wellenwiderstand) # frequenzunabhängig Z_0 = np.sqrt(L/C1) def Wellenwiderstand ( omega ): return np.sqrt(L/C1) * 1 / np.sqrt((1- 0.25 * omega**2 * L * C1)) write('build/Z_0.tex', make_SI(Z_0, r'\ohm', figures=0)) # "Lineare Regression" # Teil 1 f1_log_a = np.array([29900, 35500, 41800, 49200, 57300, 66300, 77600])
T2 = np.concatenate((T11,T22,T33,T44)) p2 = np.concatenate((p11,p22,p33,p44)) T2 += 273.1 # T in K p2 *= 1e5 # p in N/m^2 (Pa) params_2 = ucurve_fit(g, T2, p2) # Korrektur wegen Offset : T = 373.1 K -> p = 1 bar = 1e5 Pa # write('build1/offset2.tex', make_SI(1e-5*g(373.1, *noms(params_2))-1, r'\bar', '', 1)) # p2 += 1e5-g(373.1, *noms(params_2)) # params_2 = ucurve_fit(g, T2, p2) a2, b2, c2, d2 = params_2 d2 += 48*1e3 # Korrektur Offset (laut Protokoll) write('build1/a2.tex', make_SI(a2 * 1e-5, r'\bar\per\kelvin\tothe{3}', '', 1)) write('build1/b2.tex', make_SI(b2 * 1e-5, r'\bar\per\kelvin\tothe{2}', '', 1)) write('build1/c2.tex', make_SI(c2 * 1e-5, r'\bar\per\kelvin\tothe{1}', '', 1)) write('build1/d2.tex', make_SI(d2 * 1e-5, r'\bar', '', 1)) T_hilf = np.linspace(np.amin(T2), np.amax(T2), 5) T_plot = np.linspace((T_hilf[0]-1/np.size(T2)*(T_hilf[-1]-T_hilf[0])), (T_hilf[-1]+1/np.size(T2)*(T_hilf[-1]-T_hilf[0])), 10) plt.clf() plt.plot(T_plot, g(T_plot, *noms(params_2))*1e-5, 'b-', label='Fit') plt.plot(T2, p2*1e-5, '.r', label='Messdaten') plt.xlim(np.amin(T_plot), np.amax(T_plot)) plt.xlabel(r'$T \:/\: \si{\kelvin}$') plt.ylabel(r'$p \:/\: \si{\bar}$') plt.legend(loc='best')
v_auf_mittel_stds=[ stds(v_2_auf_mittel), stds(v_3_auf_mittel), stds(v_4_auf_mittel), stds(v_5_auf_mittel), stds(v_6_auf_mittel), stds(v_7_auf_mittel), stds(v_8_auf_mittel), stds(v_9_auf_mittel), stds(v_10_auf_mittel)] v_ab_mittel_nom=[ noms(v_2_ab_mittel), noms(v_3_ab_mittel), noms(v_4_ab_mittel), noms(v_5_ab_mittel), noms(v_6_ab_mittel), noms(v_7_ab_mittel), noms(v_8_ab_mittel), noms(v_9_ab_mittel), noms(v_10_ab_mittel)] v_ab_mittel_stds=[ stds(v_2_ab_mittel), stds(v_3_ab_mittel), stds(v_4_ab_mittel), stds(v_5_ab_mittel), stds(v_6_ab_mittel), stds(v_7_ab_mittel), stds(v_8_ab_mittel), stds(v_9_ab_mittel), stds(v_10_ab_mittel)] # v_0 = array(1/v_2_0, 1/v_3_0, 1/v_4_0, 1/v_5_0, 1/v_6_0, 1/v_7_0, 1/v_8_0, 1/v_9_0, 1/v_10_0) v_0 = np.genfromtxt('messdaten/V_0.txt', unpack=True) v_0 = 1/v_0 U = np.genfromtxt('messdaten/Spannung.txt', unpack=True) v_auf = unp.uarray(v_auf_mittel_nom, v_auf_mittel_stds) v_auf = 1/v_auf v_ab = unp.uarray(v_ab_mittel_nom, v_ab_mittel_stds) v_ab = 1/v_ab write('build/Tabelle_Geschwindigkeiten.tex', make_table([v_auf, v_auf ,v_0, U],[1, 1, 3, 0])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Geschwindigkeiten_texformat.tex', make_full_table( caption = 'Mittelwerte der Messdaten für jedes untersuchte Tröpfchen und zugehörige Spannung.', label = 'table:A2', source_table = 'build/Tabelle_Geschwindigkeiten.tex', stacking = [0,1], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [ r'$v_\textrm{auf} \:/\: \si{\milli\meter\per\second}$', r'$v_\textrm{ab} \:/\: \si{\milli\meter\per\second}$', r'$v_0\:/\: \si{\milli\meter\per\second}$', r'$U\:/\: \si{\volt}$'])) write('build/Tabelle_Kriterium.tex', make_table([2*v_0, v_ab-v_auf],[3,3])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Kriterium_texformat.tex', make_full_table( caption = 'Überprüfung der Bedinung.',
i = 0 print(m_K) x = [] while i < np.size(m_K): x.append(S(c_W, m_w[i], c_g_m_g, T_M[i], T_W[i], m_K[i], T_K[i])) # np.append(x, S(c_W, m_w[i], c_g_m_g, T_M[i], T_W[i], m_K[i], T_K[i])) print(m_K[i], m_w[i], T_K[i], T_W[i], T_M[i], c_W, c_g_m_g) print(x) # write('build/Waermekapazitaeten_Blei['+str(i)+'].txt',str(x)) i += 1 print(np.std(x)) print(np.mean(x)) print(x) print(x[0]) c_k = ufloat(np.mean(x), np.std(x)) write("build/Waermekapazitaeten_Blei_gemittelt.tex", make_SI(c_k * 1e3, r"\joule\per\kelvin\per\kilogram")) write("build/blei_tabelle.tex", make_table([m_K, m_w, T_K, T_W, T_M], [0, 0, 1, 1, 1])) write("build/Waermekapazitaeten_Blei.tex", str(x[0]) + "&" + str(x[1]) + "&" + str(x[2])) write("build/Waermekapazitaeten_Blei.txt", str(x[0]) + " " + str(x[1]) + " " + str(x[2])) # aluminium m_K, m_w, T_K, T_W, T_M = np.genfromtxt("Messdaten/alu_messung.txt", unpack=True) c_W = np.genfromtxt("Messdaten/spezifischen_Waermekapazitaet.txt", unpack=True) c_g_m_g = np.genfromtxt("Messdaten/Waermekapazitaet.txt", unpack=True) print(m_K, m_w, T_K, T_W, T_M, c_W, c_g_m_g) x = S(c_W, m_w, c_g_m_g, T_M, T_W, m_K, T_K) c_k = x print(x) print(c_k) # write('build/Waermekapazitaeten_Alu.tex', make_SI(c_k)*1e3, r'\joule\per\kelvin\per\gram' ))
import matplotlib.pyplot as plt from scipy.optimize import curve_fit from uncertainties import ufloat from table import( make_table, make_SI, write) # Spannungen und Ströme einlesen spannung_orange, orange = np.genfromtxt('Daten1.txt', unpack=True) spannung, rot, grun, lila, blau, uv = np.genfromtxt('Daten2.txt', unpack=True) matrix=np.array([rot, grun, lila, blau, uv]) #werte in tabelle schreiben write('build/tabelle_alle_wellenlangen.tex', make_table([spannung, rot, grun, lila, blau, uv],[2,0,0,0,0,0])) write('build/tabelle_alle_wellenlangen_wurzel.tex', make_table([spannung, np.sqrt(rot), np.sqrt(grun), np.sqrt(lila), np.sqrt(blau), np.sqrt(uv)],[2,1,1,1,1,1])) write('build/tabelle_orange_wellenlange.tex', make_table([spannung_orange, orange],[2,0])) #pikoampere in ampere umrechnen matrix = matrix*10**-12 orange = orange*10**-12 #Werte mit positivem strom heraussuchen und plotten matrix_plus = np.ones((len(matrix[:,0]),len(matrix[0,:]))) #matrix_plus = np.ones((10,5))
from table import( make_table, make_SI, write, make_composed_table) e1, e2, t1, t2 = np.genfromtxt('WerteA.txt', unpack=True) print(e1) # in SI-Einheiten umrechnen e1 = e1/100 e2=e2/100 t1=t1*10**-6 t2=t2*10**-6 #schallgeschwindigkeit in acryl c = 2730 s1 = c*t1/2 s2= c*t2/2 print(np.mean(s1-e1)) print(np.mean(s2-e2)) print(s1) print(s2[::-1]) write('build/tabelle_WerteA.txt', make_table([e1*100, s1*100, (s1-np.mean(s1-e1))*100, e2*100, s2*100, (s2-np.mean(s2-e2))*100], [3,3,3,3,3,3]))
import numpy as np import scipy.constants as const from table import ( make_table, make_full_table, make_composed_table, make_SI, write, search_replace_within_file, ) m = const.physical_constants["electron mass"] m = m[0] * 0.063 # effektive Masse e = const.physical_constants["elementary charge"] e = e[0] hbar = const.physical_constants["Planck constant over 2 pi"] hbar = hbar[0] V0 = e * 0.1768 tau = hbar / V0 xi = np.sqrt(hbar**2 / m / V0) print(tau) print(xi) write('tex_files/tau.tex', make_SI(tau * 1e15, r'\second', exp='e-15', figures=2)) write('tex_files/xi.tex', make_SI(xi * 1e9, r'\meter', exp='e-9', figures=2))
# R = const.physical_constants["molar gas constant"] # Array of value, unit, error ###########Daten des Blocks################ tiefe = 4.03*10**(-2) breite = 15.02*10**(-2) hoehe = 8.035*10**(-2) ##########A-Scan################## c = 2730 t_start = 1.6*10**(-6) t_end = 59.4*10**(-6) write('build/t_start.tex', make_SI(t_start*10**6, r'\micro\second', figures=2)) write('build/t_end.tex', make_SI(t_end*10**6, r'\micro\second', figures=2)) hoehe_mess = c*(t_end-t_start)/2 write('build/hoehe_mess.tex', make_SI(hoehe_mess*10**2, r'\centi\metre', figures=2)) hoehe_mess_rel = abs(hoehe_mess-hoehe)/hoehe * 100 write('build/hoehe_mess_rel.tex', make_SI(hoehe_mess_rel, r'\percent', figures=1)) D_o , t_o, t_u = np.genfromtxt('messdaten/a.txt', unpack=True) D_o = D_o*10**(-2) t_o = t_o*10**(-6) t_u = t_u*10**(-6) D_mess_o = D_o