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
