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
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('build/parameter_a.tex', make_SI(a, r'\metre\per\second', figures=1)) # type in Anz. signifikanter Stellen write('build/parameter_b.tex', make_SI(b, r'\metre', figures=2)) # type in Anz. signifikanter Stellen v_lit = 2730 v_rel_3 = abs(np.mean(a)-v_lit)/v_lit *100
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}$", ], ), ) ################################ FREQUENTLY USED CODE ################################ # ########## IMPORT ########## # t, U, U_err = np.genfromtxt('data.txt', unpack=True) # t *= 1e-3
m_kl = 4.4531*1e-3 # KiloGramm m_gr = 4.6*1e-3 # KiloGramm write('build/m_kl.tex', make_SI(m_kl*1e3, r'\kilo\gram','e-3', figures=1)) write('build/m_gr.tex', make_SI(m_gr*1e3, r'\kilo\gram','e-3', figures=1)) write('build/L.tex', make_SI(L, r'\meter', figures=1)) write('build/m_gr.tex', make_SI(m_gr*1e3, r'\kilo\gram','e-3', figures=1)) Radius_kl = np.genfromtxt('Messdaten/RadiusKK.txt', unpack=True) /2 #in mm Radius_gr = np.genfromtxt('Messdaten/RadiusGK.txt', unpack=True) /2 #in mm write('build/radien.tex', make_table([Radius_kl, Radius_gr],[3, 3])) # FULLTABLE write('build/radien_texformat.tex', make_full_table( 'Ermittelte Radien.', 'table:radien', 'build/radien.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen [r'$R_\text{Kl} \:/\: \si{\milli\meter}$', r'$R_\text{Gr} \:/\: \si{\milli\meter}$'])) Radius_kl_mean = np.mean(Radius_kl) Radius_kl_std = np.std(Radius_kl) Radius_kl_unc = ufloat(Radius_kl_mean, Radius_kl_std) write('build/radius_kl_unc.tex', make_SI(Radius_kl_unc*1e3, r'\milli\meter', figures=1)) # print ('Radius: ' + str(Radius_kl_unc)) V_kl = 4/3 * np.pi * (Radius_kl_unc*1e-3)**3 write('build/volumen_kl_unc.tex', make_SI(V_kl*1e6, r'\cubic\meter','e-6', figures=1)) # print ('Vol: ' + str(V_kl)) Radius_gr_mean = np.mean(Radius_gr) Radius_gr_std = np.std(Radius_gr) Radius_gr_unc = ufloat(Radius_gr_mean, Radius_gr_std) write('build/radius_gr_unc.tex', make_SI(Radius_gr_unc*1e3, r'\milli\meter', figures=1))
D_mess_u = c*t_u/2 D_loch = hoehe_mess - (D_mess_o + D_mess_u) D_mess_o = D_mess_o*10**(2) D_mess_u = D_mess_u*10**(2) D_o = D_o*10**2 D_loch = D_loch*10**3 List = [1,2,3,4,5,6,7,8,9,10,11] write('build/Tabelle_a.tex', make_table([List, D_o, D_mess_o, D_mess_u, D_loch],[0,2,2,2,2])) #cm, cm ,cm, mm write('build/Tabelle_a_texformat.tex', make_full_table( 'Messdaten Tiefenmessungen.', 'table:1', 'build/Tabelle_a.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r'$\text{Stelle}$', r'$D_{\text{oben}} \:/\: \si{\centi\metre}$', r'$D_{\text{oben,gem}} \:/\: \si{\centi\metre}$', r'$D_{\text{unten,gem}} \:/\: \si{\centi\metre}$', r'$D_{\text{loch,gem}} \:/\: \si{\milli\metre}$'])) D_o_rel_a = abs(D_mess_o-D_o)/D_o * 100 D_o_rel_a = np.mean(D_o_rel_a) write('build/D_o_rel_a.tex', make_SI(D_o_rel_a, r'\percent', figures=2)) #um herauszufinden, welche Methode besser ist (Spoiler: Durchschnittlich 4% Abweichung) #####################B-Scan################## t_start2 = 5.5*0.5*10**(-6) t_end2 = (55+0.5*7)*10**(-6) write('build/t_start2.tex', make_SI(t_start2*10**6, r'\micro\second', figures=2))
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}'])) U_Rechteck, Skala_Rechteck = np.genfromtxt('Messdaten/Rechteckspannung.txt', unpack=True) U_Rechteck_Fehler = 0.1 * Skala_Rechteck U_Rechteck *= Skala_Rechteck U_Rechteck_ges = unp.uarray(U_Rechteck, U_Rechteck_Fehler) U_Rechteck_normiert = U_Rechteck_ges / U_Rechteck_ges[0] RelFehler_Rechteck = np.abs(U_Rechteck_normiert - a_Rechteck) / a_Rechteck * 100 # Die folgende Zeile ist nicht schön, aber nötig, da make_table noch nicht mit 0 Fehlern klarkommt wegen \SI, führt nämlich auf 0.0 +- 0 statt 0 +- 0 write('build/Tabelle_Rechteck_1.tex', '1 & 2.2 & 0.2 & 1 & 0 & 1 & 0 & 0 \\\\')
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.', label = 'table:A3', source_table = 'build/Tabelle_Kriterium.tex', stacking = [1], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [ r'$2v_0 \:/\: \si{\milli\meter\per\second}$', r'$v_\textrm{ab} - v_\textrm{auf} \:/\: \si{\milli\meter\per\second}$']))
) ###################################################################################################################################################### ## 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 # Plot ln(p) vs 1/T -> Verdampfungskurve T_plot = np.linspace(np.amin(1/T1), np.amax(1/T1), 100) plt.plot(T_plot*1e3, reg.reg_linear(T_plot, *noms(params)), 'b-', label='Fit') plt.plot(1/T1*1e3, np.log(p1), '.r', label='Messdaten')
from table import make_full_table # print(make_full_table('Bloed', 'Baz', 'TabelleTest.tex', [1,2,3])) print(make_full_table('Bloed', 'Baz', 'TabelleTest.tex', [1,2], [1,2,3,4,5]))
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', source_table = 'build/Tabelle_Indium.tex', stacking = [0], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [ r'$N_\textrm{\Delta t}$', r'$t \:/\: \si{\second}$'])) # default = '-' Si_nom, t_Si = np.genfromtxt('messdaten/Silber.txt', unpack=True) Si_nom = Si_nom - N_Offset_Silber Si = unp.uarray(Si_nom, np.sqrt(Si_nom)) # Si = unp.uarray(Si_nom, N_Offset_Silber) write('build/Tabelle_Silber.tex', make_table([Si[:23],t_Si[:23],Si[23:],t_Si[23:]],[1,0,1,0])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Silber_texformat.tex', make_full_table(
Abstände_A = np.genfromtxt('messdaten/Abstände.txt', unpack=True) # in centimeter Abstände_B = Höhe-Abstände_A Abstand = np.genfromtxt('messdaten/Abstände.txt', unpack=True) Abstand_B = Höhe - Abstand # # y[n - 1::n] print('Hallo') print(Num[0:5]) print(Num[6:10]) write('build/Tabelle_Abstaende.tex', make_table([Num,Abstand],[0,2])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Abstaende_texformat.tex', make_full_table( 'Gemessene Tiefe der Bohrungen aus Sicht der "A-Seite".', 'table:A5', 'build/Tabelle_Abstaende.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [ r'$\text{Num.} $', r'$\text{Tiefe} \:/\: \si{\centi\meter}$'])) #### A-Scan #### Ich schätze einen Ablesefehler von 0.1 Fehler_A = 0.1*1e-6 #in sekunden Werte_A_A, Werte_A_B = np.genfromtxt('messdaten/aufgabenteil_a.txt', unpack=True) t_a_a = unp.uarray(Werte_A_A, Fehler_A) t_a_b = unp.uarray(Werte_A_B, Fehler_A) t_a_a *=1e-6 # in sekunden t_a_b *=1e-6 # in sekunden
D_o, D_m, x = np.genfromtxt('Messwerte/Material1_eingespannt.txt', unpack=True) #mm #mm #cm x*=1e-2 #meter D_o*=1e-3 #meter D_m*=1e-3 #meter D_x = D_o - D_m #meter x_achse = L_1*x**2 - ((x**3)/3) #meter print(D_x) write('build/Material1_messdaten.tex', make_table([x[::-1]*1e3, D_o[::-1]*1e3, D_m[::-1]*1e3,D_x[::-1]*1e3, x_achse[::-1]*1e3], [2, 2, 2,2,2])) write('build/Material1_messdaten_texformat.tex', make_full_table( 'Messdaten Material 1.', 'table:Material1_messdaten', 'build/Material1_messdaten.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen [ r'$x \:/\: \si{\milli\meter}$', r'$D_\text{ohne} \:/\: \si{\milli\meter}$', r'$D_\text{mit} \:/\: \si{\milli\meter}$', r'$D_\text{x} \:/\: \si{\milli\meter}$', r'$L_1 x^2-\frac{x^3}{3} \:/\: \si{\milli\meter}$'])) ### Berechnung des E-moduls für Material1 plt.plot(x_achse[::-1]*1e3,D_x[::-1]*1e3, 'rx', label='Messdaten') plt.ylabel(r'$U \:/\: \si{\volt}$') plt.xlabel(r'$t \:/\: \si{\milli\second}$') plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) params = ucurve_fit(reg.reg_linear, x_achse[::-1] , D_x[::-1])
########## Aufgabenteil 0) ########## T = np.genfromtxt('messdaten/0.txt', unpack=True) T += 273.15 p_saet = p_saet(T) w_quer = w_quer(p_saet) write('build/Tabelle_0.tex', make_table([T,p_saet*1000,w_quer*1000],[2, 3, 3])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_0_texformat.tex', make_full_table( 'Bestimmung der Sättigungsdampfdrücke sowie der mittleren Weglängen.', 'tab:0', 'build/Tabelle_0.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen ['T / \si{\kelvin}', r'$p_{\text{sätt}} \:/\: 10^{-3} \si{\bar}$', r'$\bar{w} \:/\: 10^{-3} \si{\metre} $'])) ########## Aufgabenteil a) ########## U_a, I_a, I_a_plus_delta = np.genfromtxt('messdaten/a_1.txt', unpack=True) # Ströme in Nanoampere plt.clf # clear actual plot before generating a new one t_plot = np.linspace(np.amin(U_a), np.amax(U_a), 100) plt.xlim(t_plot[0]-1/np.size(U_a)*(t_plot[-1]-t_plot[0]), t_plot[-1]+1/np.size(U_a)*(t_plot[-1]-t_plot[0])) plt.plot(U_a, I_a_plus_delta, 'rx', label=r'Messwerte für $T = \SI{26.1}{\celsius}$') plt.xlabel(r'$U_a \:/\: \si{\volt}$')
lambda_nm = np.genfromtxt('messdaten/lambda.txt', unpack=True) eta = np.genfromtxt('messdaten/eta.txt', unpack=True) eta *= np.pi/180 phi = 60.4 # in grad write('build/phi.tex', make_SI(phi, r'\degree', figures=1)) phi*= np.pi/180 n = np.sin((eta+phi)/2)/np.sin(phi/2) print(n) write('build/Tabelle_Brechung.tex', make_table([lambda_nm, eta*180/np.pi, n],[0,0,4])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten write('build/Tabelle_Brechung_texformat.tex', make_full_table( caption = 'Brechungsindices.', label = 'table:A1', source_table = 'build/Tabelle_Brechung.tex', stacking = [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, die Multicolumns sein sollen units = [ r'$\lambda \:/\: \si{\nano\metre}$', r'$\eta \:/\: \si{\degree}$', r'$n$'])) plt.plot(lambda_nm,n**2, 'rx', label='Messdaten') plt.xlabel(r'$\lambda \:/\: \si{\nano\metre}$') plt.ylabel(r'$n^2$') plt.legend(loc='best') plt.savefig('build/Dispersionskurve_ohne_Fit.pdf') # def reg_linear (x, m, b): # return m*x + b
'rx', label='Messdaten') plt.ylabel(r'$\lambda \:/\: \si{\nano\meter}$') plt.xlabel(r'$\sin(\varphi)$') plt.legend(loc='best') plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08) plt.savefig('build/aufgabenteil_a_plot.pdf') plt.clf() #### Ende Plot #### #### TABELLE #### write('build/Tabelle_a.tex', make_table([lambda_helium*1e9, -phi_helium, -sin_phi_helium],[1, 3, 3])) write('build/Tabelle_a_texformat.tex', make_full_table( 'Messdaten zur Bestimmung der Gitterkonstante.', 'table:gitterkonstante', 'build/Tabelle_a.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # die Multicolumns sein sollen [r'$\lambda \:/\: \si{\nano\meter}$', r'$|\varphi| \:/\: \si{\radian}$', r'$|\sin(\varphi)|$'])) #### Ende Tabelle #### ########## Aufgabenteil b) ########## # Kalibrierung des Okularmikrometers lambda_kalibrierung = np.array( [438.8, 447.1, 501.6, 504.8]) * 1e-9 # in m Eichgroesse = unp.uarray(np.zeros(np.size(lambda_kalibrierung)/2), np.zeros(np.size(lambda_kalibrierung)/2)) # in m Skt Skt = Sektor
b=np.array([Rx_mean[0]]) c=np.array([Rx_mean_err[0]]) d=np.array([Cx_mean[0]*1e9]) e=np.array([Cx_mean_err[0]*1e9]) write('build/Tabelle_err_b1.tex', make_table([a,b,c,d,e],[0, 1, 0, 1, 1])) write('build/Tabelle_err_b2.tex', make_table([Werte_b[1:3], Rx_mean[1:3], Rx_mean[1:3], Rx_mean_err[1:3], Cx_mean[1:3]*1e9, Cx_mean_err[1:3]*1e9],[0, 0, 0, 0, 1, 1])) # write('build/Tabelle_b.tex', make_table([Wert_b, C2*1e9, R2, R34, Rx, Cx*1e9], [0, 1, 1, 1, 1, 1])) # Ich muss hier leider aufteilen, weil make_table Probleme mit der 0 hat... macht daraus 0.0 -.- write('build/Tabelle_b1.tex', make_table([Wert_b[0:3], C2[0:3]*1e9, R2[0:3], R34[0:3], Rx[0:3], Cx[0:3]*1e9], [0, 1, 1, 1, 1, 1])) write('build/Tabelle_b2.tex', make_table([Wert_b[3:9], C2[3:9]*1e9, R_2[3:9], R_2er[3:9], R34[3:9], Rx[3:9], Rx[3:9], Cx[3:9]*1e9], [0, 1, 0, 0, 1, 0, 0, 1])) write('build/Tabelle_b.tex', make_composed_table(['build/Tabelle_b1.tex','build/Tabelle_b2.tex'])) write('build/Tabelle_b_texformat.tex', make_full_table( 'Messdaten Kapazitätsmessbrücke.', 'table:A2', 'build/Tabelle_b.tex', [1,2,3,4,5], ['Wert', '$C_2 \\:/\\: \\si{\\nano\\farad}$', '$R_2 \\:/\\: \\si{\\ohm}$', '$R_3 / R_4$', '$R_x \\:/\\: \\si{\\ohm}$', '$C_x \\:/\\: \\si{\\nano\\farad}$'])) # write('build/kapa_b.C15m.tex', make_SI(Cx_mean_Wert15*1e9, r'\nano\farad', figures=1)) # write('build/kapa_b.R15m.tex', make_SI(Rx_mean_Wert15, r'\ohm', figures=1)) # write('build/kapa_b.C3m.tex', make_SI(Cx_mean_Wert3*1e9, r'\nano\farad', figures=1)) # write('build/kapa_b.C2m.tex', make_SI(Cx_mean_Wert2*1e9, r'\nano\farad', figures=1)) #c) Induktivitätsbrücke #L/R-Kombination Wert 18 Wert_c, R_2, L_2, c = np.genfromtxt('Messergebnisse/c.txt', unpack=True) L_2er = L_2*0.002 R_2er = R_2*0.03 R_3 = c R_4 = 1000-c
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 plt.xlabel(r'$\theta \:/\: \si{\degree}$') plt.ylabel(r'$Impulsrate \:/\: \si{\kilo\gram\meter\per\second\tothe{2}}$') # plt.xlabel(r'$t \:/\: \si{\milli\second}$') #plt.title("Emissionsspektrum einer Cu-Anode bei 35 kV") plt.grid()
########################### 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 params = ucurve_fit(reg_linear, U[no_of_first_ignored_values:-no_of_last_ignored_values], N[no_of_first_ignored_values:-no_of_last_ignored_values]) # skip first 3 and last 5 values as they dont belong to the plateau write('build/plateaulaenge.tex', make_SI(U[-no_of_last_ignored_values] - U[no_of_first_ignored_values], r'\volt', figures = 0)) a, b = params write('build/parameter_a.tex', make_SI(a, r'\per\second\per\volt', figures=1)) write('build/plateaumitte.tex', make_SI(reg_linear(500, *noms(params)), r'\per\second', figures=1) ) # Der Wert in der Hälfte des Plateaus als Referenz für die plateausteigung
abstand_skala2_a = [0,2,4,6,8,10,12,14,16,18,20,22] f2_a = np.log(f2_log_a) params = ucurve_fit(reg.reg_linear, abstand_skala2_a, f2_a) m2, b2 = params write('build/m2_a.tex', make_SI(m2*1e3, r'\per\centi\meter', 'e-3',figures=1)) # type in Anz. signifikanter Stellen write('build/b2_a.tex', make_SI(b2*1e3, r'', 'e-3', figures=1)) write('build/Tabelle_a.tex', make_table([abstand_skala1_a, f1_log_a*1e-3, f1_a, abstand_skala2_a, f2_log_a*1e-3, f2_a], [0, 1, 2, 0, 1, 2])) # type in Nachkommastellen # FULLTABLE write('build/Tabelle_a_texformat.tex', make_full_table( 'Messdaten Aderlasskurven.', 'table:A1', 'Tabelle_a.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen ['$\\textrm{Abstand}_\\textrm{C} \\:/\\: \\si{\\cm}$', '$\\nu_\\textrm{C} \\:/\\: \\si{\\kilo\\hertz}$', '$\\log{\\abs{\\nu_\\textrm{C}}}$', '$\\textrm{Abstand}_\\textrm{C$_1$,C$_2$} \\:/\\: \\si{\\cm}$', '$\\nu_\\textrm{C$_1$,C$_2$} \\:/\\: \\si{\\kilo\\hertz}$', '$\\log{\\abs{\\nu_\\textrm{C$_1$,C$_2$}}}$'])) # Testplot für lin. fit # plt.clf # #AUTOMATICLY CHOSING LIMITS WITH EXISTING ARRAY T1 # t_plot = np.linspace(np.amin(abstand_skala1_a), np.amax(abstand_skala1_a), 100) # plt.xlim(t_plot[0]-1/np.size(abstand_skala1_a)*(t_plot[-1]-t_plot[0]), t_plot[-1]+1/np.size(abstand_skala1_a)*(t_plot[-1]-t_plot[0])) # # plt.plot(t_plot, reg.reg_linear(t_plot, *noms(params)), 'b-', label='Fit') # plt.xlim(t_plot[0], t_plot[-1]) # # plt.xlabel(r'$t \:/\: \si{\milli\second}$')
T_10 = np.genfromtxt('Messdaten/I10.txt', unpack=True) T_08 = np.genfromtxt('Messdaten/I08.txt', unpack=True) T_06 = np.genfromtxt('Messdaten/I06.txt', unpack=True) T_04 = np.genfromtxt('Messdaten/I04.txt', unpack=True) T_02 = np.genfromtxt('Messdaten/I02.txt', unpack=True) I=np.array([1,0.8,0.6,0.4,0.2]) write('build/Tabelle_Strom.tex', make_table([T_10,T_08,T_06,T_04,T_02],[3, 3, 3, 3, 3])) # FULLTABLE write('build/MagnetfeldPerioden_texformat.tex', make_full_table( 'Periodendauern mit eingeschalteter Helmholtzspule.', 'table:MagnetfeldPerioden', 'build/Tabelle_Strom.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen [r'$T_{1,0\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,4\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,6\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,8\si{\ampere}} \:/\: \si{\second}$', r'$T_{0,2\si{\ampere}} \:/\: \si{\second}$'])) write('build/aaa.tex', make_table([T_ohneB_roh, T_mitB_roh],[3, 3])) # FULLTABLE write('build/Ausw2_texformat.tex', make_full_table( 'Periodendauern für ausgeschaltete Helmholtzspule.', 'tab:Ausw2', 'build/aaa.tex', [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern, # # die Multicolumns sein sollen [r'$T_{\text{ohne Erdmagnetfeld}} \:/\: \si{\second}$',
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])) write('build/Tabelle_results_s_texformat.tex', make_full_table( caption = r'Herstellerangabe, Mikroskopmessung, Firparameter und der Fehler zwischen Fit und Herstellerangabe für den Abstand $s$ des Doppelspalts.', label = 'table:A2', source_table = 'build/Tabelle_results_s.tex', stacking = [1,3], units = [ r'$s_\text{mic} \:/\: \si{\milli\meter}$',
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([s1*1000, (s1-np.mean(s1-e1))*1000, s2*1000, (s2-np.mean(s2-e2))*1000], [2,2,2,2])) write('build/WerteA.tex', make_full_table( r'Aus den A-Scans bestimmte Abstände der Löcher zum Rand in \si{\milli\meter}', 'tab:werteA', 'build/tabelle_WerteA.txt', [], [r'$d_\text{berechnet}$', r'$d_\text{korrigiert}$', r'$d_\text{berechnet}$', r'$d_\text{korrigiert}$'])) ############################################################################### ### B-Scan ############################################################################### tObenG, tUntenG = np.genfromtxt('WerteB.txt', unpack = True) sOben, sUnten, tO,tU = np.genfromtxt('WerteA.txt', unpack = True) sOben *= 0.01 sUnten *= 0.01 # 100 * 10**(-6) sekunden = 543.0 pixel