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
