for i in range(1,len(q)):
n=0
while abs(gcd-q[i])>1e-19 and n <= maxi:
if gcd > q[i]:
gcd = gcd - q[i]
else:
q[i] = q[i] - gcd
n = n+1
return gcd
test1 = copy.deepcopy(noms(q))
test2 = copy.deepcopy(noms(q_korr))
e_0 = GCD(test1,30)
e_0_korr = GCD(test2,30)
write('build/e_0.tex', make_SI(e_0 * 1e16, r'\coulomb','e-16', figures=2))
write('build/e_0_korr.tex', make_SI(e_0_korr * 1e17, r'\coulomb','e-17', figures=2))
write('build/e_0_lit.tex', make_SI(1.60, r'\coulomb','e-19', figures=2))
write('build/Ordnung.tex', make_SI(1, r'','e-19', figures=0))
F = 96485.3329 #sA/mol
A_v = F/e_0
A_v_korr = F/e_0_korr
print(A_v)
print(A_v_korr)
write('build/A_v.tex', make_SI(A_v * 1e-20, r'\per\mol','e20', figures=2))
write('build/A_v_korr.tex', make_SI(A_v_korr * 1e-21, r'\per\mol','e21', figures=2))
write('build/A_v_lit.tex', make_SI(6.022, r'\per\mol','e23', figures=2))
################################ FREQUENTLY USED CODE ################################
#
# 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')
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")
# print("hallo")
# #np.arcsin(0.5)
# print(np.arcsin(1))
# print(np.sin(90))
# import math
# print("try")
# print(math.sin(90))
# print(math.cos(math.radians(1)))
####Grenzwinkel-Bestimmung####
print("Ergebniss")
#lamb1 = math.sin(math.radians(5.4)) * 2* 201.4*10**(-12)
lamb_min = 2*d*np.sin(np.deg2rad(5.4))
E_max = h*c/lamb_min
write('build/lambda_min.tex', make_SI(lamb_min*1e12, r'\pico\meter', figures=2)) # type in Anz. signifikanter Stellen
write('build/E_max.tex', make_SI(E_max*1e-3, r'\kilo\electronvolt', figures=2)) # type in Anz. signifikanter Stellen
####Halbwertsbreite####
def halbwertsbreite(x, y):
spline = UnivariateSpline(x, y-np.max(y)/2, s=0)
r1, r2 = spline.roots() # find the roots
lambda1 = 2*d*np.sin(np.deg2rad(r1))
lambda2 = 2*d*np.sin(np.deg2rad(r2))
E1 = h*c/lambda1
E2 = h*c/lambda2
DE = E1 - E2
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' ))
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)
n_nom = unp.nominal_values(n)
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',
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 ####################################################################################################
make_table,
make_full_table,
make_composed_table,
make_SI,
write,
)
### Bestimmung der Dichte
L1, kante1 = np.genfromtxt('Messwerte/Material1_laenge_seitenlaenge.txt', unpack=True)
gewicht_stab1 = np.genfromtxt('Messwerte/Material1_gewicht.txt', unpack=True) #gram
gewicht_stab1*=1e-3
L1*=1e-2 #meter
kante1*=1e-3 #meter
L1_mittel = ufloat(np.mean(L1), np.std(L1))
write('build/L1_mittel.tex', make_SI(L1[0], r'\meter', figures=1))
kante1_mittel = ufloat(np.mean(kante1), np.std(kante1))
write('build/kante1_mittel.tex', make_SI(kante1_mittel*1e3,r'\meter','e-3', figures=1))
print(kante1_mittel)
rho1 = gewicht_stab1/(kante1_mittel**2 * L1_mittel) # m/V kg/m^3
write('build/rho1.tex', make_SI(rho1, r'\kilo\gram\per\cubic\meter', figures=1))
print('dichte')
print(rho1)
L2, kante2 = np.genfromtxt('Messwerte/Material2_laenge_seitenlaenge.txt', unpack=True)
gewicht_stab2 = np.genfromtxt('Messwerte/Material2_gewicht.txt', unpack=True) #gram
gewicht_stab2*=1e-3
L2*=1e-2 #meter
kante2*=1e-3 #meter
########## Aufgabenteil a) ##########
# 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.ylabel(r"$\lambda \:/\: \si{\nano\meter}$")
plt.xlabel(r"$\sin(\varphi)$")
write('build/Tabelle_b1.tex', make_table([U_max_2],[2])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten
#write('build/Tabelle_b1_texformat.tex', make_full_table(
# r'Maxima der Franck-Hertz-Kurve bei $T = \SI{178}{\celsius}$.',
# 'tab:3',
# 'build/Tabelle_b1.tex',
# [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern,
# # die Multicolumns sein sollen
# [r'$U_max / \si{\volt}$']))
U_max_2_deltas = ([U_max_2[1]-U_max_2[0], U_max_2[2]-U_max_2[1], U_max_2[3]-U_max_2[2]])
max1 = U_max_2[0]
max2 = U_max_2[1]
max3 = U_max_2[2]
max4 = U_max_2[3]
write('build/b_max1.tex', make_SI(max1, r'\volt', figures=1))
write('build/b_max2.tex', make_SI(max2, r'\volt', figures=1))
write('build/b_max3.tex', make_SI(max3, r'\volt', figures=1))
write('build/b_max4.tex', make_SI(max4, r'\volt', figures=1))
write('build/Tabelle_b2.tex', make_table([U_max_2_deltas],[2])) # Jeder fehlerbehaftete Wert bekommt zwei Spalten
#write('build/Tabelle_b2_texformat.tex', make_full_table(
# r'Abstände der Maxima der Franck-Hertz-Kurve bei $T = \SI{178}{\celsius}$.',
# 'tab:4',
# 'build/Tabelle_b2.tex',
# [], # Hier aufpassen: diese Zahlen bezeichnen diejenigen resultierenden Spaltennummern,
# # die Multicolumns sein sollen
# [r'$\Delta U_max / \si{\volt}$']))
U_max_2_delta_mean = np.mean(U_max_2_deltas)
write('build/Tabelle_Rechteck.tex', make_table([U_recht_ges , I_recht_ges*1e3],[2,1]))
print('hallo, nah alles klar bei dir ?')
# plot für die Monozelle
plt.errorbar(unp.nominal_values(I1_ges)*1e3, unp.nominal_values(U1_ges), xerr = unp.std_devs(I1_ges), yerr=unp.std_devs(U1_ges), fmt='r.')
plt.ylabel(r'$U \:/\: \si{\volt}$')
plt.xlabel(r'$I \:/\: \si{\milli\ampere}$')
plt.legend(loc='best')
plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08)
#plt.savefig('build/plot1.pdf')
params = ucurve_fit(f, I1, U1_ges)
m1, b1 = params
write('build/m1.tex', make_SI(m1, r'\ohm', '', 1)) # 1 signifikante Stelle
write('build/m1_fuer_Latex.tex', make_SI(m1*(-1), r'\ohm', '', 1)) # 1 signifikante Stelle
write('build/b1.tex', make_SI(b1, r'\volt', '', 1)) # 1 signifikante Stelle
i = np.linspace(0.02,0.11, 100)
plt.plot(i*1e3,f(i, noms(m1), noms(b1) ), 'b-', label='Monozelle')
plt.savefig('build/plot1.pdf')
plt.clf()
plt.errorbar(unp.nominal_values(I1_c_ges)*1e3, unp.nominal_values(U1_c_ges), xerr = unp.std_devs(I1_c_ges), yerr=unp.std_devs(U1_c_ges), fmt='r.')
plt.ylabel(r'$U \:/\: \si{\volt}$')
plt.xlabel(r'$I \:/\: \si{\milli\ampere}$')
plt.legend(loc='best')
plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08)
#plt.savefig('build/plot1.pdf')
)
from regression import (
reg_linear,
reg_quadratic,
reg_cubic
)
from error_calculation import(
mean,
MeanError
)
from utility import(
constant
)
################################################ Finish importing custom libraries #################################################
write('build/phir.tex', make_SI(100.7, r'\degree', figures=1))
write('build/phil.tex', make_SI(221.5, r'\degree', figures=1))
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.',
plt.xlabel('Spannung / V')
plt.ylabel(r'Steigung des Stromes / nA/V')
plt.savefig('build/Energieverteilung_140.png')
plt.show()
write('build/tabelle_stromverlauf_140.tex', make_table([Spannung2, Strom2*10**9], [2,0]))
write('build/tabelle_energieverteilung_140.tex', make_table([matrix2[1,:], matrix2[0,:]*10**9], [2,2]))
# Berechnung der Austrittsenergie
Anregungsspannung_gesamt = ufloat(np.mean(Anregungsspannung), sem(Anregungsspannung))
Energie = const.e * Anregungsspannung_gesamt
Wellenlange = const.h*const.c / Energie
write('build/tabelle_anregungsspannung.tex', make_table([Anregungsspannung], [4]))
write('build/Anregungsspannung.tex', make_SI(Anregungsspannung_gesamt, r'\volt', figures=2))
write('build/Energie.tex', make_SI(Energie*10**19, r'\joule','e-19',figures=1))
write('build/Wellenlange.tex', make_SI(Wellenlange*10**9, r'\nano\meter', figures=1))
print(Anregungsspannung_gesamt, Energie, Wellenlange)
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
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)
p = d*T**3 + c*T**2 + b*T +a
dp = 3*d*T**2 + 2*c*T + b
return (R*T/2+np.sqrt((R*T/2)**2 - A*p))*dp*T/p
# Verdampfungswärme als Funktion der Temperatur n=4
def L4(konst_a, konst_R, T, e, d, c, b, a):
A=konst_a
R=konst_R
p = e*T**4 + d*T**3 + c*T**2 + b*T +a
dp = 4*e*T**3 + 3*d*T**2 + 2*c*T + b
return (R*T/2+np.sqrt((R*T/2)**2 - A*p))*dp*T/p
params = ucurve_fit(f, 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
T_plot = np.linspace(np.amin(1/T1), np.amax(1/T1), 100)
T_hilf = np.linspace(2.5e-3, 3.5e-3, 100)
plt.plot(T_hilf*1e3, f(T_hilf, *noms(params)), 'b-', label='Fit')
plt.plot(1/T1*1e3, np.log(p1), '.r', label='Messdaten')
plt.xlim(1e3*(T_plot[0]-1/np.size(T1)*(T_plot[-1]-T_plot[0])), 1e3*(T_plot[-1]+1/np.size(T1)*(T_plot[-1]-T_plot[0])))
plt.xlabel(r'$T^{-1} \:/\: 10^{-3}\si{\per\kelvin}$')
plt.ylabel(r'$\ln(p / \si{\pascal})$')
plt.legend(loc='best')
plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08)
plt.savefig('build/plot1.pdf')
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')
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')
plt.xlim(1e3*(T_plot[0]-1/np.size(T1)*(T_plot[-1]-T_plot[0])), 1e3*(T_plot[-1]+1/np.size(T1)*(T_plot[-1]-T_plot[0])))
plt.xlabel(r'$T^{-1} \:/\: 10^{-3}\si{\per\kelvin}$')
plt.ylabel(r'$\ln(p / \si{\pascal})$')
plt.legend(loc='best')
plt.tight_layout(pad=0, h_pad=1.08, w_pad=1.08)
plt.savefig('build/Verdampfungskurve.pdf')
R = const.physical_constants["molar gas constant"] # value, unit, error
R_unc = ufloat(R[0],R[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
Ustab1, Ustab2 = np.array_split(Us, 2)
write('build/frequenztabelle.tex', make_table([vtab1, Utab1, Ustab1, vtab2, Utab2, Ustab2], [0, 2, 1, 0, 2, 1]))
write('build/frequenztabelle_texformat.tex', make_full_table(
'Messdaten TT-Brücke.',
'table:A5',
'build/frequenztabelle.tex',
[],
['$\\nu \\:/\\: \\si{\\hertz}$', '$U_\\mathrm{Br} \\:/\\: \\si{\\volt}$', '$U_\\mathrm{S} \\:/\\: \\si{\\volt}$',
'$\\nu \\:/\\: \\si{\\hertz}$', '$U_\\mathrm{Br} \\:/\\: \\si{\\volt}$', '$U_\mathrm{S} \\:/\\: \\si{\\volt}$']
))
R = 1000
C = Cx_mean_Wert3
w0 = 1/(R*C)
v0 = w0/(2*np.pi)
write('build/f0.tex',make_SI(v0, r'\hertz', 1))
U = U/Us
plt.plot(v/noms(v0), U,'.r', label=r'Messwerte')
plt.xscale('log')
def f(v):
return np.sqrt( (v**2 - 1)**2 / ( (1 - v**2)**2 + 16 * v**2 ) )
# Plot
x_plot = np.logspace(-2, 2, 100)
plt.plot(x_plot, f(x_plot), 'b-', label=r'Theoriekurve', linewidth=0.5)
plt.ylabel(r'$U_{Br} \ /\ U_S$')
plt.xlabel(r'$\nu \ /\ \nu_0$')
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
write('build/v_rel_3.tex', make_SI(v_rel_3, r'\percent', figures=2))
t_plot = np.linspace(0.9*np.amin(0.5*t_zylinder), np.amax(0.5*t_zylinder)*1.1, 100)
plt.plot(t_plot, t_plot*a.n+b.n, 'b-', label='Linearer Fit')
plt.plot(0.5*t_zylinder, h_zylinder, 'rx', label='Messdaten')
# t_plot = np.linspace(-0.5, 2 * np.pi + 0.5, 1000) * 1e-3
#
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
# 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')
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
write('build/plateausteigung.tex', make_SI(a*100*100/reg_linear(500, *noms(params)), r'\percent', figures=1)) # %/100V lässt sich nicht mit siunitx machen -> wird in latex hart reingeschrieben
write('build/parameter_b.tex', make_SI(b, r'\per\second', figures=1))
#### Plot ####
t_plot = np.linspace(350, 650, 2)
plt.xlim(290,710)
plt.plot(t_plot, reg_linear(t_plot, *noms(params)), 'b-', label='Fit')
U[no_of_first_ignored_values:-no_of_last_ignored_values]
plt.errorbar(U[no_of_first_ignored_values:-no_of_last_ignored_values],
noms(N[no_of_first_ignored_values:-no_of_last_ignored_values]),
fmt='bx', yerr=stds(N[no_of_first_ignored_values:-no_of_last_ignored_values]),
label='Messdaten auf dem Plateau')
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])
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))
#plots erstellen
x = np.linspace(-2.1, 2)
null = np.zeros(50) #da linspace 50 werte erzeugt
plt.plot(x, 10**6*g(x, *parameters), 'k-', label='Lineare Regression')
plt.plot(spannung, 10**6*np.sqrt(matrix_linear[i,:]), 'ro', label='Messdaten')
plt.plot(spannung[0], 10**6*np.sqrt(matrix[i,0]), 'ko', label='Ausgenommene Messdaten')
plt.plot(spannung[1], 10**6*np.sqrt(matrix[i,1]), 'ko')
plt.plot(x, null, 'k-')
plt.xlim(-2.1,2)
plt.ylabel(r'Wurzel des Stromes / $\sqrt{\mathrm{pA}}$')
plt.xlabel(r'Spannung / V')
plt.legend(loc='best')
plt.savefig('build/regression_Farbe:'+str(i)+'.png')
plt.show()
#daten speichern
write('build/Steigung_'+str(i)+'.tex', make_SI(m*10**6, r'\sqrt{\pico\ampere}\per\volt', figures=1))
write('build/y-Achsenabschnitt_'+str(i)+'.tex', make_SI(b*10**6, r'\sqrt{\pico\ampere}', figures=1))
write('build/Grenzspannung_'+str(i)+'.tex', make_SI(Ug, r'\volt', figures=1))
print(spannung[0], matrix[i,0])
#aufgabe 2:
#wellenlangen in nanometer (von wikipedia - muss noch genau nachgeschaut werden!!!)
L_rot = 615
L_grun = 546
L_lila = 435
L_blau = 405
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
parameters1, popt1 = curve_fit(linear, U[15:27], Z[15:27])
m1 = ufloat(parameters1[0], np.sqrt(popt1[0,0]))
b1 = ufloat(parameters1[1], np.sqrt(popt1[1,1]))
write('build/m1.txt', make_SI(m1, r'\per\volt\per\second', figures=1))
write('build/b1.txt', make_SI(b1, r'\per\second', figures=1))
x = np.linspace(300,750)
plt.plot(U[12:], Z[12:], 'ro', label='Messwerte')
plt.plot(U[15:27], Z[15:27], 'ko', label='Messwerte (linearer Teil)')
plt.plot(x, linear(x, *parameters1),'k-', label = 'Regression (linearer Teil)')
plt.errorbar(U[12:], Z[12:], xerr=1, yerr=Z_fehler[12:], 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.savefig('build/charakteristik_linear.png')
plt.show()
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))
from curve_fit import ucurve_fit
from table import (
make_table,
make_full_table,
make_composed_table,
make_SI,
write,
)
L=0.1 #m
# Dichte
# kleine Kugel
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
