Durchführung¶
Detaillierte Hinweise zur Durchführung der Versuche finden Sie in der Datei Spezifische_Ladung_des_Elektrons_Hinweise.ipynb
Aufgabe 1: Fadenstrahlrohr¶
Aufgabe 1.1: Magnetfeld im Fadenstrahlrohr¶
- Schätzen Sie das Magnetfeld $B(r)$ im Inneren der Helmholtz-Spulen $H_{1}$ und $H_{2}$ mit Hilfe einer baugleichen, weiteren Helmholtz-Spule $H_{3}$ und einer Hall-Sonde ab.
- Kalibrieren Sie hierzu die Hall-Sonde mit Hilfe einer weiteren, langen Spule, deren Magnetfeld Sie über das Ampèresche Gesetz bestimmen können.
- Diskutieren Sie die Homogenität von $B(r)$ für die vorliegende Anordnung von Helmholtz-Spulen.
- Vergleichen Sie Ihre Messung für $r=0$ mit Ihrer Erwartung.
Anm.: $r$ bezeichnet den Abstand von der Symmetrieachse des Spulenpaars.
V E R S U C H S B E S C H R E I B U N G
Damit bei dem Versuchsaufbau 1.2 die Messung durchgeführt werden kann muss zunächst verifiziert werden, dass der Versuchsaufbau funktioniert.
Es soll überprüft werden, ob das Magnetfeld der Helmholzspule annähernd homogen ist in der Nähe des Zentrums, wo später die Messung stattfindet. Desweiteren soll durch eine lange Spule die Sonde, die zur Messung verwendet wird, kalibriert werden.
Zunächst zu der Homogenität des Magnetfeldes:
Da die zwei Spulen, die später verwendet werden in einem Kasten eingeschlossen sind, muss die Homogenität anderweitig bestimmt werden. Hierzu wird eine dritte, gleichartige Spule im gleichen Abstand zu einer der beiden Spulen im Kasten gestellt, wie diese Spulen voneinander entfernt sind. Dies soll den Aufbau im Kasten simulieren. Nun wird in das Steckbrett, welches an der äußeren Spule angebracht ist eine Hall-Sonde in unterschiedlichen Abständen gesteckt und das B-Feld gemessen. Hier soll im Bereich des späteren Experimentes ein annährend homogenes Magnetfeld gemessen werden.
Abbildung 1: Material des Aufbau zur Kontrolle der Homogenität des $B$-Feldes (Eigene Darstellung, 2024)
Nun zu der Kalibrierung:
Die Hall-Sonde wird in das Zentrum einer langen (als unendlich lang angenommen) Spule gesteckt werden und es wird bei unterschiedlichen Stromstärken in der Spule die Hall-Spannung in die Hall-Sonde gemessen.
Über $B(I_{\mathrm{S}}, N, \ell) = \mu_{0}\,\frac{N\,I_{\mathrm{S}}}{\ell}$ wird aus der Stromstärke das Magnetfeld berechnet. Das Verhältnis von Magnetfeld zu Hall-Spannung wird dann als Kalibrationsfaktor verwendet.
Über diese Messwerte wird der Proportionalitätsfaktor k bestimmt, welcher die Steigung der Gerade $\mathrm B = \mathrm{k * U}$ angibt.
Abbildung 2: Material des Aufbau zur Kalibration der Hall-Sonde (Eigene Darstellung, 2024)
L Ö S U N G
Importieren der Python Module:
import numpy as np
import pandas as pd
import sympy as sp
from matplotlib import rc
import matplotlib.lines as mlines
import matplotlib.pyplot as plt
from scipy.interpolate import Rbf
from scipy.signal import find_peaks
import scipy.integrate as integrate
from scipy.interpolate import interp1d
from kafe2 import XYContainer, XYFit, Plot,ContoursProfiler
from IPython.display import Latex
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C
plt.style.use('_mpl-gallery')
rc('text', usetex=True)
Importieren der aufgenommene Daten (Homogenität des $B$-Feldes):
data_current = [[1,1.506,1.996],[1,1,1,1,1.506,1.506,1.506,1.506,1.996,1.996,1.996,1.996],
[1,1,1,1,1.506,1.506,1.506,1.506,1.996,1.996,1.996,1.996],[1,1,1.506,1.506,1.996,1.996],[1,1.506,1.996]]
data_distance = [0,3,6,9,12]
data_voltage_h = [[-27.75,-40.5,-54.19],[-27.37,-27.37,-27.56,-27.56,-40.31,-40.5,-40.31,-40.31,-54.19,-54.19,-54,-54.19],
[-27.37,-27.19,-26.81,-26.44,-39.94,-40.31,-39.56,-39.75,-53.44,-53.63,-53.06,-53.25],
[-25.87,-24.75,-37.5,-36.94,-50.81,-49.88],[-21.94,-31.31,-42.75]]
data_distance_x = [0,-3,3,0,0,-6,6,0,0,0,0,0]
data_distance_y = [0,0,0,-3,3,0,0,-6,6,-9,9,-12]
data_distance_o0 = [0,3,3,3,3,6,6,6,6,9,9,12]
data_current_o0 = [1,1.506,1.996]
data_current_o1 = [1,1,1,1,1,1,1,1,1,1,1,1]
data_current_o2 = [1.506,1.506,1.506,1.506,1.506,1.506,1.506,1.506,1.506,1.506,1.506,1.506]
data_current_o3 = [1.996,1.996,1.996,1.996,1.996,1.996,1.996,1.996,1.996,1.996,1.996,1.996]
data_voltage_o1 = [27.75,27.37,27.37,27.56,27.56,27.37,27.19,26.81,26.44,25.87,24.75,21.94]
data_voltage_o2 = [40.5,40.31,40.5,40.31,40.31,39.94,40.31,39.56,39.75,37.5,36.94,31.31]
data_voltage_o3 = [54.19,54.19,54.19,54,54.19,53.44,53.63,53.06,53.25,50.81,49.88,42.75]
Fehlerschätzung:
$\Delta U_H = \pm \ 0.01$ V
$\Delta I_S = \pm \ 0.001$ mA
$\Delta l = 0.005$ m
$\Delta N = 7.5$
Plot der aufgenommene Daten:
plt.figure(figsize=(6, 4))
plt.errorbar(data_current[0], data_voltage_h[0], label=f'Radius = 0', yerr=0.01, fmt='.',color="black")
plt.errorbar(data_current[1], data_voltage_h[1], label=f'Radius = 3', yerr=0.01, fmt='.',color="cyan")
plt.errorbar(data_current[2], data_voltage_h[2], label=f'Radius = 6', yerr=0.01, fmt='.',color="#ac1f55")
plt.errorbar(data_current[3], data_voltage_h[3], label=f'Radius = 9', yerr=0.01, fmt='.',color="#e9593e")
plt.errorbar(data_current[4], data_voltage_h[4], label=f'Radius = 12', yerr=0.01, fmt='.',color="#ffa600")
plt.xlabel('Strom $I_S$ (A)', fontsize=10)
plt.ylabel('Spannung $U_H$ (mV)', fontsize=10)
plt.legend(title="Distanz (cm)", fontsize=10)
plt.grid(True)
plt.show()
plt.figure(figsize=(6, 4))
plt.errorbar(data_distance_o0, data_voltage_o1, label="1A", color="black", yerr=0.01, fmt='.')
plt.errorbar(data_distance_o0, data_voltage_o2, label="1.5A", color="#ac1f55", yerr=0.01, fmt='2')
plt.errorbar(data_distance_o0, data_voltage_o3, label="2A", color="#e9593e", yerr=0.01, fmt='x')
plt.xlabel('Radius $d$ (cm)', fontsize=10)
plt.ylabel('$U_H$ (mV)', fontsize=10)
plt.legend(fontsize=10)
plt.grid(True)
plt.show()
U_I1 = []
U_I2 = []
U_I3 = []
for n in range(len(data_voltage_o1)):
a = data_voltage_o1[n]/data_current_o1[n]
U_I1.append(a)
for n in range(len(data_voltage_o2)):
a = data_voltage_o2[n]/data_current_o2[n]
U_I2.append(a)
for n in range(len(data_voltage_o3)):
a = data_voltage_o3[n]/data_current_o3[n]
U_I3.append(a)
plt.figure(figsize=(6, 4))
plt.errorbar(data_distance_o0, U_I1, label="1A", color="black", yerr=0.01, fmt='.')
plt.errorbar(data_distance_o0, U_I2, label="1.5A", color="#ac1f55", yerr=0.01, fmt='2')
plt.errorbar(data_distance_o0, U_I3, label="2A", color="#e9593e", yerr=0.01, fmt='x')
plt.xlabel('Radius $d$ (cm)', fontsize=10)
plt.ylabel('$U_H/I_S$ (mV/A)', fontsize=10)
plt.legend(fontsize=10)
plt.grid(True)
plt.show()
Plot der Hallspannung über x/y-Koordinaten für die Kontrolle der Homogenität:
coordinates_with_voltage = list(zip(zip(data_distance_x, data_distance_y), data_voltage_o1))
print(80*"-")
for coord, voltage in coordinates_with_voltage:
print(f"Koordinate: {coord}, Spannung: {voltage}")
print(80*"-")
-------------------------------------------------------------------------------- Koordinate: (0, 0), Spannung: 27.75 Koordinate: (-3, 0), Spannung: 27.37 Koordinate: (3, 0), Spannung: 27.37 Koordinate: (0, -3), Spannung: 27.56 Koordinate: (0, 3), Spannung: 27.56 Koordinate: (-6, 0), Spannung: 27.37 Koordinate: (6, 0), Spannung: 27.19 Koordinate: (0, -6), Spannung: 26.81 Koordinate: (0, 6), Spannung: 26.44 Koordinate: (0, -9), Spannung: 25.87 Koordinate: (0, 9), Spannung: 24.75 Koordinate: (0, -12), Spannung: 21.94 --------------------------------------------------------------------------------
Plot mit der Gaußsch`schen Interpolation:
fig = plt.figure(figsize=(15, 12))
ax = fig.add_subplot(322, projection='3d')
ax.title.set_text("Datenpunkte (2A)")
ax.set_xlabel("X (cm)", fontsize=10)
ax.set_ylabel("Y (cm)", fontsize=10)
ax.set_zlabel("Spannung $U_H$(mV)", fontsize=10)
ax.view_init(elev=45, azim=240)
scat1 = ax.scatter(data_distance_x, data_distance_y, data_voltage_o1, c=data_voltage_o1, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat1, ax=ax, label="Spannung $U_H$")
bx = fig.add_subplot(324, projection='3d')
bx.title.set_text("Datenpunkte (1.5A)")
bx.set_xlabel("X (cm)", fontsize=10)
bx.set_ylabel("Y (cm)", fontsize=10)
bx.set_zlabel("Spannung $U_H$(mV)", fontsize=10)
bx.view_init(elev=45, azim=240)
scat2 = bx.scatter(data_distance_x, data_distance_y, data_voltage_o2, c=data_voltage_o2, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat2, ax=bx, label="Spannung $U_H$")
cx = fig.add_subplot(326, projection='3d')
cx.title.set_text("Datenpunkte (2A)")
cx.set_xlabel("X (cm)", fontsize=10)
cx.set_ylabel("Y (cm)", fontsize=10)
cx.set_zlabel("Spannung $U_H$(mV)", fontsize=10)
cx.view_init(elev=45, azim=240)
scat3 = cx.scatter(data_distance_x, data_distance_y, data_voltage_o3, c=data_voltage_o3, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat3, ax=cx, label="Spannung $U_H$")
X = np.column_stack((data_distance_x, data_distance_y))
y_1 = data_voltage_o1
y_2 = data_voltage_o2
y_3 = data_voltage_o3
kernel = C(1.0, (1e-4, 1000e1)) * RBF(1.0, (1e-4, 1e1))
gp_1 = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
gp_2 = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
gp_3 = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
x_grid = np.linspace(-10, 10, 500)
y_grid = np.linspace(-15, 15, 500)
X_grid, Y_grid = np.meshgrid(x_grid, y_grid)
grid_points = np.column_stack((X_grid.flatten(), Y_grid.flatten()))
gp_1.fit(X, y_1)
gp_2.fit(X, y_2)
gp_3.fit(X, y_3)
Z_grid_1, _ = gp_1.predict(grid_points, return_std=True)
Z_grid_1 = Z_grid_1.reshape(X_grid.shape)
Z_grid_2, _ = gp_2.predict(grid_points, return_std=True)
Z_grid_2 = Z_grid_2.reshape(X_grid.shape)
Z_grid_3, _ = gp_3.predict(grid_points, return_std=True)
Z_grid_3 = Z_grid_3.reshape(X_grid.shape)
ax = fig.add_subplot(321, projection='3d')
ax.scatter(data_distance_x, data_distance_y, data_voltage_o1, c=data_voltage_o1, cmap='coolwarm', s=100, label="Daten Punkte", marker='x')
ax.set_title("Gauß`sche Interpolation der Spannung (1A)", fontsize=14)
ax.set_xlabel("X (cm)", fontsize=12)
ax.set_ylabel("Y (cm)", fontsize=12)
ax.view_init(elev=45, azim=200)
plt.colorbar(ax.plot_surface(X_grid, Y_grid, Z_grid_1, cmap='viridis', alpha=0.7, label="Spannung $U_H$ (mV)"))
plt.legend()
bx = fig.add_subplot(323, projection='3d')
bx.scatter(data_distance_x, data_distance_y, data_voltage_o1, c=data_voltage_o1, cmap='coolwarm', s=100, label="Daten Punkte", marker='x')
bx.set_title("Gauß`sche Interpolation der Spannung (1.5A)", fontsize=14)
bx.set_xlabel("X (cm)", fontsize=12)
bx.set_ylabel("Y (cm)", fontsize=12)
bx.view_init(elev=45, azim=200)
plt.colorbar(bx.plot_surface(X_grid, Y_grid, Z_grid_2, cmap='viridis', label="Spannung $U_H$ (mV)"))
plt.legend()
ax = fig.add_subplot(325, projection='3d')
ax.scatter(data_distance_x, data_distance_y, data_voltage_o1, c=data_voltage_o1, cmap='coolwarm', s=100, label="Daten Punkte", marker='x')
ax.set_title("Gauß`sche Interpolation der Spannung (2A)", fontsize=14)
ax.set_xlabel("X (cm)", fontsize=12)
ax.set_ylabel("Y (cm)", fontsize=12)
ax.view_init(elev=45, azim=200)
plt.colorbar(ax.plot_surface(X_grid, Y_grid, Z_grid_3, cmap='viridis', alpha=0.7, label="Spannung $U_H$ (mV)"))
plt.legend()
plt.tight_layout(pad=4.0)
plt.show()
Plot mit der "Radial basis function" Interpolation:
grid_x, grid_y = np.linspace(-10, 10, 100), np.linspace(-15, 15, 100)
grid_x, grid_y = np.meshgrid(grid_x, grid_y)
rbf_1 = Rbf(data_distance_x, data_distance_y, data_voltage_o1, function="inverse_multiquadric")
grid_z_1 = rbf_1(grid_x, grid_y)
rbf_2 = Rbf(data_distance_x, data_distance_y, data_voltage_o2, function="inverse_multiquadric")
grid_z_2 = rbf_2(grid_x, grid_y)
rbf_3 = Rbf(data_distance_x, data_distance_y, data_voltage_o3, function="inverse_multiquadric")
grid_z_3 = rbf_3(grid_x, grid_y)
fig = plt.figure(figsize=(15, 12))
ax = fig.add_subplot(322, projection='3d')
ax.title.set_text("Datenpunkte (2A)")
ax.set_xlabel("X (cm)", fontsize=10)
ax.set_ylabel("Y (cm)", fontsize=10)
ax.set_zlabel("Spannung $U_H$(mV)", fontsize=10)
ax.view_init(elev=45, azim=240)
scat1 = ax.scatter(data_distance_x, data_distance_y, data_voltage_o1, c=data_voltage_o1, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat1, ax=ax, label="Spannung $H_S$")
bx = fig.add_subplot(324, projection='3d')
bx.title.set_text("Datenpunkte (1.5A)")
bx.set_xlabel("X (cm)", fontsize=10)
bx.set_ylabel("Y (cm)", fontsize=10)
bx.set_zlabel("Spannung $U_H$(mV)", fontsize=10)
bx.view_init(elev=45, azim=240)
scat2 = bx.scatter(data_distance_x, data_distance_y, data_voltage_o2, c=data_voltage_o2, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat2, ax=bx, label="Spannung $H_S$")
cx = fig.add_subplot(326, projection='3d')
cx.title.set_text("Datenpunkte (2A)")
cx.set_xlabel("X (cm)", fontsize=10)
cx.set_ylabel("Y (cm)", fontsize=10)
cx.set_zlabel("Spannung $U_H$(mV)", fontsize=10)
cx.view_init(elev=45, azim=240)
scat3 = cx.scatter(data_distance_x, data_distance_y, data_voltage_o3, c=data_voltage_o3, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat3, ax=cx, label="Spannung $H_S$")
ax = fig.add_subplot(321, projection='3d')
surf = ax.plot_surface(grid_x, grid_y, grid_z_1, cmap='turbo', alpha=0.8, edgecolor='none')
ax.set_xlabel("X (cm)", fontsize=10)
ax.set_ylabel("Y (cm)", fontsize=10)
ax.set_zlabel("Spannung $U_H$ (mV)", fontsize=10)
ax.set_title("RBF-Interpolierte Oberfläche", fontsize=12)
ax.view_init(elev=45, azim=200)
plt.colorbar(surf, ax=ax, shrink=0.5, aspect=10, label="Spannung $U_H$ (mV)")
bx = fig.add_subplot(323, projection='3d')
surf = bx.plot_surface(grid_x, grid_y, grid_z_2, cmap='turbo', alpha=0.8, edgecolor='none')
bx.set_xlabel("X (cm)", fontsize=10)
bx.set_ylabel("Y (cm)", fontsize=10)
bx.set_zlabel("Spannung $U_H$ (mV)", fontsize=10)
bx.set_title("RBF-Interpolierte Oberfläche", fontsize=12)
ax.view_init(elev=45, azim=200)
plt.colorbar(surf, ax=bx, shrink=0.5, aspect=10)
cx = fig.add_subplot(325, projection='3d')
surf = cx.plot_surface(grid_x, grid_y, grid_z_3, cmap='turbo', alpha=0.8, edgecolor='none')
cx.set_xlabel("X (cm)", fontsize=10)
cx.set_ylabel("Y (cm)", fontsize=10)
cx.set_zlabel("Spannung $U_H$ (mV)", fontsize=10)
cx.set_title("RBF-Interpolierte Oberfläche", fontsize=12)
cx.view_init(elev=45, azim=200)
plt.colorbar(surf, ax=cx, shrink=0.5, aspect=10)
plt.tight_layout()
plt.show()
Importieren der aufgenommene Daten (Kalibration der Hall-Sonde):
data_current_calibration = [0.040,0.123,0.197,0.275,0.352,0.438,0.522,0.607,0.690,0.772]
data_voltage_calibration = [4.88,13.69,21.37,29.25,37.31,45.75,54.38,62.44,70.87,78.75]
Plot der aufgenommene Daten:
plt.figure(figsize=(4, 3))
plt.xlabel('Strom $I_S$ (A)', fontsize=10)
plt.ylabel('Spannung $U_H$ (mV)', fontsize=10)
plt.scatter(data_current_calibration,data_voltage_calibration, marker="x", color="red")
plt.grid(True)
plt.show()
Berechnung von B (Lange Spule):
$$\begin{equation}B(I_{\mathrm{S}}, N, \ell) = \mu_{0}\,\frac{N\,I_{\mathrm{S}}}{\ell},\end{equation}$$
mu_0 = 1.25663706127*10**(-6) # Permittivität
N = 750 # Anzahl an Windungen
l = 0.3 # Länge der Spule (m)
magnetic_field = []
for n in range(len(data_current_calibration)):
a = mu_0 * (N * data_current_calibration[n]) / l
magnetic_field.append(a)
print(80*"-")
for current, field in zip(data_current_calibration, magnetic_field):
print(f"Strom: {current} A, B-Feld: {field:.6e} T")
print(80*"-")
-------------------------------------------------------------------------------- Strom: 0.04 A, B-Feld: 1.256637e-04 T Strom: 0.123 A, B-Feld: 3.864159e-04 T Strom: 0.197 A, B-Feld: 6.188938e-04 T Strom: 0.275 A, B-Feld: 8.639380e-04 T Strom: 0.352 A, B-Feld: 1.105841e-03 T Strom: 0.438 A, B-Feld: 1.376018e-03 T Strom: 0.522 A, B-Feld: 1.639911e-03 T Strom: 0.607 A, B-Feld: 1.906947e-03 T Strom: 0.69 A, B-Feld: 2.167699e-03 T Strom: 0.772 A, B-Feld: 2.425310e-03 T --------------------------------------------------------------------------------
Fehlerfortpflanzung auf B:
$\Delta B = \sqrt{(\dfrac{dB}{dI_S} \Delta I_S)^2 + (\dfrac{dN}{dI_S} \Delta N)^2 + (\dfrac{dB}{dl} \Delta l)^2}$
def calculate_error_propagation(mu_0_value, I_S_value, N_value, l_value, Delta_I_S_value, Delta_N_value, Delta_l_value):
mu_0, I_S, N, l = sp.symbols('mu_0 I_S N l', real=True, positive=True)
Delta_I_S, Delta_N, Delta_l = sp.symbols('Delta_I_S Delta_N Delta_l', real=True, positive=True)
B = mu_0 * (N * I_S) / l
dB_dI_S = sp.diff(B, I_S)
dB_dN = sp.diff(B, N)
dB_dl = sp.diff(B, l)
Delta_B = sp.sqrt((dB_dI_S * Delta_I_S)**2 + (dB_dN * Delta_N)**2 + (dB_dl * Delta_l)**2)
substitutions = {
mu_0: mu_0_value,
I_S: I_S_value,
N: N_value,
l: l_value,
Delta_I_S: Delta_I_S_value,
Delta_N: Delta_N_value,
Delta_l: Delta_l_value
}
Delta_B_value = Delta_B.subs(substitutions)
return Delta_B_value
delta_magnetic_field = []
for n in range(len(data_current_calibration)):
a = calculate_error_propagation(mu_0,data_current_calibration[n],N,l,0.001,7.5,0.005)
delta_magnetic_field.append(a)
print(80*"-")
print("Fehler auf dem B-Feld (T)")
print(delta_magnetic_field)
print(80*"-")
-------------------------------------------------------------------------------- Fehler auf dem B-Feld (T) [3.97935069402167e-6, 8.14115110887727e-6, 1.24326034715574e-5, 1.70832877090328e-5, 2.17220579522065e-5, 2.69288555534005e-5, 3.20285948772546e-5, 3.71972854461230e-5, 4.22494574108314e-5, 4.72441129621145e-5] --------------------------------------------------------------------------------
Plotten der Kalibrationskurve:
plt.figure(figsize=(4, 3))
plt.ylabel('$B$-Feld (T)', fontsize=10)
plt.xlabel('Spannung $U_H$ (mV)', fontsize=10)
plt.scatter(data_voltage_calibration,magnetic_field, marker="x", color="blue")
plt.grid(True)
plt.show()
Fitten der Kalibrationkurve:
def model_calibration(x,k):
return x*k
fit = XYFit(xy_data=[data_voltage_calibration,magnetic_field], model_function=model_calibration)
fit.add_error(axis='x', err_val=0.1)
fit.add_error(axis='y', err_val=0.00005)
fit.do_fit()
fit.model_label
plot = Plot(fit)
plot.x_label = "Spannung $U_H$ (mV)"
plot.y_label = "$B$-Feld (T)"
plot.plot()
print("Fit für die Bestimmung vom Kalibrationsfaktor K")
plt.show()
Fit für die Bestimmung vom Kalibrationsfaktor K
Es gilt:$$\begin{equation}\tag{2}k = \dfrac{B}{U_H} = 3 \times 10^{-5} \dfrac{T}{mV}\end{equation}$$
Berechnung von B (Inneren zweier Helmholtz-Spulen):
$$\begin{equation}\tag{3}B(r=0) = \frac{8}{\sqrt{125}}\,\frac{\mu_{0}\,N\,I_{\mathrm{S}}}{R}.\end{equation}$$
mu_0 = 4*np.pi*10**(-7) # Permittivität
N = 130 # Anzahl an Windungen
R = 0.15 # Länge der Spule (m)
magnetic_field = []
for n in range(len(data_current_o0)):
a = (8/np.sqrt(125)) * (mu_0 * N * data_current_o0[n]) / R
magnetic_field.append(a)
for current, field in zip(data_current_o0, magnetic_field):
print(f"Strom: {current} A, B-Feld: {field:.6e} T")
Strom: 1 A, B-Feld: 7.792861e-04 T Strom: 1.506 A, B-Feld: 1.173605e-03 T Strom: 1.996 A, B-Feld: 1.555455e-03 T
Kalibration aller Werte $U_H$ auf $B$:
k = 3*10**(-5)
voltage_correction = []
for n in range(len(magnetic_field)):
a = (magnetic_field[n]/k)
voltage_correction.append(a)
print(80*"-")
for voltage in zip(voltage_correction):
print(f"Korrekturspannung: {voltage} mV")
print(80*"-")
current_sd = np.linspace(0.1, 3, 100)
magnetic_field_theoretical = (8 / np.sqrt(125)) * mu_0 * N * current_sd
magnetic_field_exp1 = []
for n in range(len(data_current_o1)):
a = (data_current_o1[n]*k)
magnetic_field_exp1.append(a)
magnetic_field_th1 = []
for n in range(len(data_current_o1)):
a = (data_current_o1[n]*(8 / np.sqrt(125)) * mu_0 * N)
magnetic_field_th1.append(a)
magnetic_field_exp2 = []
for n in range(len(data_current_o1)):
a = (data_current_o2[n]*k)
magnetic_field_exp2.append(a)
magnetic_field_th2 = []
for n in range(len(data_current_o1)):
a = (data_current_o2[n]*(8 / np.sqrt(125)) * mu_0 * N)
magnetic_field_th2.append(a)
magnetic_field_exp3 = []
for n in range(len(data_current_o1)):
a = (data_current_o3[n]*k)
magnetic_field_exp3.append(a)
magnetic_field_th3 = []
for n in range(len(data_current_o1)):
a = (data_current_o3[n]*(8 / np.sqrt(125)) * mu_0 * N)
magnetic_field_th3.append(a)
-------------------------------------------------------------------------------- Korrekturspannung: (25.976203805448367,) mV Korrekturspannung: (39.12016293100525,) mV Korrekturspannung: (51.84850279567495,) mV --------------------------------------------------------------------------------
plt.figure(figsize=(8, 4))
plt.plot(current_sd,magnetic_field_theoretical, color="black", label="Theorie", linestyle='--')
plt.scatter(data_current_o1,magnetic_field_exp1, color="red", label="Messwerte (1A)")
plt.scatter(data_current_o2,magnetic_field_exp2, color="red", label="Messwerte (1.5A)")
plt.scatter(data_current_o3,magnetic_field_exp3, color="red", label="Messwerte (2A)")
plt.ylabel('$B$-Feld (T)', fontsize=10)
plt.xlabel('Strom $I$ (A)', fontsize=10)
plt.legend(fontsize=10)
plt.grid(True)
plt.title("Kalibrierte Messdaten und theoretische Kurve")
plt.show()
plt.figure(figsize=(8, 4))
plt.scatter(data_voltage_o1,magnetic_field_th1, color="black", label="Theorie (1A)")
plt.scatter(data_voltage_o1,magnetic_field_exp1, color="red", label="Messwerte (1A)")
plt.scatter(data_voltage_o2,magnetic_field_th2, color="grey", label="Theorie (1.5A)")
plt.scatter(data_voltage_o2,magnetic_field_exp2, color="orange", label="Messwerte (1.5A)")
plt.scatter(data_voltage_o3,magnetic_field_th3, color="black", label="Theorie (2A)")
plt.scatter(data_voltage_o3,magnetic_field_exp3, color="red", label="Messwerte (2A)")
plt.ylabel('$B$-Feld (T)', fontsize=10)
plt.xlabel('Spannung (mV)', fontsize=10)
plt.title("Kalibrierte Messdaten und theoretische Messpunkte")
plt.legend(fontsize=10)
plt.grid(True)
plt.show()
Plot von $B(r_i)\pm\Delta B$:
grid_x, grid_y = np.linspace(-10, 10, 100), np.linspace(-15, 15, 100)
grid_x, grid_y = np.meshgrid(grid_x, grid_y)
rbf_1 = Rbf(data_distance_x, data_distance_y, magnetic_field_exp1, function="inverse_multiquadric")
grid_z_1 = rbf_1(grid_x, grid_y)
rbf_2 = Rbf(data_distance_x, data_distance_y, magnetic_field_exp2, function="inverse_multiquadric")
grid_z_2 = rbf_2(grid_x, grid_y)
rbf_3 = Rbf(data_distance_x, data_distance_y, magnetic_field_exp3, function="inverse_multiquadric")
grid_z_3 = rbf_3(grid_x, grid_y)
fig = plt.figure(figsize=(15, 12))
ax = fig.add_subplot(322, projection='3d')
ax.title.set_text("Datenpunkte (2A)")
ax.set_xlabel("X (cm)", fontsize=10)
ax.set_ylabel("Y (cm)", fontsize=10)
ax.set_zlabel("$B$-Feld (T)", fontsize=10)
ax.view_init(elev=45, azim=240)
scat1 = ax.scatter(data_distance_x, data_distance_y, data_voltage_o1, c=data_voltage_o1, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat1, ax=ax, label="$B$-Feld (T)")
bx = fig.add_subplot(324, projection='3d')
bx.title.set_text("Datenpunkte (1.5A)")
bx.set_xlabel("X (cm)", fontsize=10)
bx.set_ylabel("Y (cm)", fontsize=10)
bx.set_zlabel("$B$-Feld (T)", fontsize=10)
bx.view_init(elev=45, azim=240)
scat2 = bx.scatter(data_distance_x, data_distance_y, data_voltage_o2, c=data_voltage_o2, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat2, ax=bx, label="$B$-Feld (T)")
cx = fig.add_subplot(326, projection='3d')
cx.title.set_text("Datenpunkte (2A)")
cx.set_xlabel("X (cm)", fontsize=10)
cx.set_ylabel("Y (cm)", fontsize=10)
cx.set_zlabel("$B$-Feld (T)", fontsize=10)
cx.view_init(elev=45, azim=240)
scat3 = cx.scatter(data_distance_x, data_distance_y, data_voltage_o3, c=data_voltage_o3, cmap='Spectral', s=100, marker='o')
plt.colorbar(scat3, ax=cx, label="$B$-Feld (T)")
ax = fig.add_subplot(321, projection='3d')
surf = ax.plot_surface(grid_x, grid_y, grid_z_1, cmap='turbo', alpha=0.8, edgecolor='none')
ax.set_xlabel("X (cm)", fontsize=10)
ax.set_ylabel("Y (cm)", fontsize=10)
ax.set_title("RBF-Interpolierte Oberfläche", fontsize=12)
ax.view_init(elev=45, azim=200)
plt.colorbar(surf, ax=ax, shrink=0.5, aspect=10, label="$B$-Feld (T)")
bx = fig.add_subplot(323, projection='3d')
surf = bx.plot_surface(grid_x, grid_y, grid_z_2, cmap='turbo', alpha=0.8, edgecolor='none')
bx.set_xlabel("X (cm)", fontsize=10)
bx.set_ylabel("Y (cm)", fontsize=10)
bx.set_title("RBF-Interpolierte Oberfläche", fontsize=12)
ax.view_init(elev=45, azim=200)
plt.colorbar(surf, ax=bx, shrink=0.5, aspect=10, label="$B$-Feld (T)")
cx = fig.add_subplot(325, projection='3d')
surf = cx.plot_surface(grid_x, grid_y, grid_z_3, cmap='turbo', alpha=0.8, edgecolor='none')
cx.set_xlabel("X (cm)", fontsize=10)
cx.set_ylabel("Y (cm)", fontsize=10)
cx.set_title("RBF-Interpolierte Oberfläche", fontsize=12)
cx.view_init(elev=45, azim=200)
plt.colorbar(surf, ax=cx, shrink=0.5, aspect=10, label="$B$-Feld (T)")
plt.tight_layout()
plt.show()
D I S K U S S I O N
Den Fit für die Bestimmung vom Kalibrationsfaktor liefert einen Wert von $k = (3.038 * 10^{-5} \pm 3.3 * 10^{-7})$ $\dfrac{T}{mV}$.
Die Daten wurden auf eine einfaches Modell angepasst, wo $k$ die Proportionalitätskonstante zwichen dem $B$-Feld und die Spannung $U_H$ ist. Der $\chi^2$-Wert verifiziert den Modell mit einem Betrag von $0.989$, also passen die Daten ausgezeichnet auf diesen.
Sowohl die Gaußsche und die RBF-Interpolation erlauben es nicht, eine homogene Darstellung zu erzeugen. Eine weitere Messkampagne auf verschiedene Winkel würde diesen Problem beheben.
Es ergibt sich jedoch, dass das Magnetfeld des Helmholzspulenpaares nahezu homogen ist in einem Radius von ungefähr 10cm, außerhalb dessen aber abfällt. Dies entspricht dem erwarteten Magnetfeld und genügt auch dem Versuchsaufbau, da in diesem Bereich später die Messung stattfindet.
Weiter fällt auf, dass die Messwerte für das Magnetfeld ungefähr 20%-30% der Theoriewerte, die bei der jeweiligen Stromstärke entstehen sollten, betragen. Dies ist vermutlich auf äußere Faktoren, wie dem thermischen "Energieverlust" und dem nur groben Aufbau zurückzuführen
Aufgabe 1.2: Elektronenbahn im Fadenstrahlrohr¶
- Bestimmen Sie den Durchmesser $d$ der Elektronenbahn im Fadenstrahlrohr in zwei Messreihen:
- Als Funktion der Anodenspannung $U_{\mathrm{A}}$ für zwei verschiedene Spulenströme $I_{\mathrm{S}}$.
- Als Funktion des Spulenstroms $I_{\mathrm{S}}$ für zwei verschiedene Anodenspannungen $U_{\mathrm{A}}$.
- Bestimen Sie $e/m_{\mathrm{e}}$ aus den Daten beider Messreihen.
V E R S U C H S B E S C H R E I B U N G
In diesem Experiment wird der Durchmesser $d$ der Elektronenbahn im Fadenstrahlrohr untersucht. Ziel ist es, $d$ in Abhängigkeit von der Anodenspannung $U_A$ und dem Spulenstrom $I_S$ in zwei separaten Messreihen zu bestimmen.
Für den Aufbau wird die Spule $H_3$ entfernt und das Fadenstrahlrohr gemäß einer vorgegebenen Abbildung angeschlossen. Dabei sind ausschließlich die grau markierten Spannungsanschlüsse und Sicherheitskabel zu verwenden.
Abbildung 3a: Aufbau zur erstellung einer Elektronenbahn im Fadenstrahlrohr aus (1)
Abbildung 3b: Aufbau zur erstellung einer Elektronenbahn im Fadenstrahlrohr (Eigene Darstellung, 2024)
Um Messfehler zu minimieren, wird der Durchmesser d mit Hilfe der Schiebemarker vor dem Fadenstrahlrohr und eines Spiegels hinter dem Fadenstrahlrohr bestimmt. Ein Parallaxenfehler ist hierbei zu vermeiden.
Abbildung 4: Elektronenbahn im Fadenstrahlrohr (Eigene Darstellung, 2024)
L Ö S U N G
Importieren der aufgenommene Daten:
data_current_electron_beam_1 = [1,1,1,1,1,1,2,2,2,2,2,2]
data_voltage_electron_beam_1 = [110.1,130.3,139.5,150.3,160.01,170.7,140,160.4,180,200,190,170]
data_diameter_electron_beam_1 = [94,108,111,120,118,129,47,54,58,66,62,56]
data_current_electron_beam_2 = [1,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2,1,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2]
data_voltage_electron_beam_2 = [140.2,140.2,140.2,140.2,140.2,140.2,140.2,140.2,140.2,140.2,140.2,160.1,160.1,160.1,160.1,160.1,160.1,160.1,160.1,160.1,160.1,160.1]
data_diameter_electron_beam_2 = [106,91,81,75,70,62,59,54,51,47,44,108,95,88,79,74,71,64,62,57,55,51]
Fehlerabschätzung:
$\Delta U_A = \pm \ 5$ V
$\Delta I_S = \pm \ 0.001$ mA
$\Delta l = \pm \ 0.005$ m
Plot der aufgenommene Daten:
plt.figure(figsize=(6, 4))
plt.scatter( data_current_electron_beam_1, data_voltage_electron_beam_1, label="Messreihe 1", color="black", marker=".")
plt.scatter( data_current_electron_beam_2, data_voltage_electron_beam_2, label="Messreihe 2", color="red", marker="x")
plt.xlabel('Strom $I$ (A)', fontsize=10)
plt.ylabel('Spannung $U$ (V)', fontsize=10)
plt.legend(fontsize=10)
plt.grid(True)
plt.show()
plt.figure(figsize=(6, 4))
plt.scatter( data_current_electron_beam_1, data_diameter_electron_beam_1, label="Messreihe 1", color="black", marker=".")
plt.scatter( data_current_electron_beam_2, data_diameter_electron_beam_2, label="Messreihe 2", color="red", marker="x")
plt.xlabel('Strom $I$ (A)', fontsize=10)
plt.ylabel('Diameter $d$ (mm)', fontsize=10)
plt.legend(fontsize=10)
plt.grid(True)
plt.show()
U_I1_eb = []
U_I2_eb = []
for n in range(len(data_voltage_electron_beam_1)):
a = data_voltage_electron_beam_1[n]/data_current_electron_beam_1[n]
U_I1_eb.append(a)
for n in range(len(data_voltage_electron_beam_2)):
a = data_voltage_electron_beam_2[n]/data_current_electron_beam_2[n]
U_I2_eb.append(a)
plt.figure(figsize=(6, 4))
plt.scatter(data_diameter_electron_beam_1, U_I1_eb, label="Messreihe 1", color="black", marker=".")
plt.scatter(data_diameter_electron_beam_2, U_I2_eb, label="Messreihe 2", color="red", marker="x")
plt.xlabel('Durchmesser $d$ (mm)', fontsize=10)
plt.ylabel('$U/I$ (V/A)', fontsize=10)
plt.legend(fontsize=10)
plt.grid(True)
plt.show()
Die ersten Messwerte werden isoliert, da die Messung bei diesen anders vorgenommen wurde.
data_current_electron_beam_1_1 = [1,1,1,1,1,1]
data_voltage_electron_beam_1_1 = [110.1,130.3,139.5,150.3,160.01,170.7]
data_diameter_electron_beam_1_1 = [94,108,111,120,118,129]
data_current_electron_beam_1_2 = [2,2,2,2,2,2]
data_voltage_electron_beam_1_2 = [140,160.4,180,200,190,170]
data_diameter_electron_beam_1_2 = [47,54,58,66,62,56]
U_I1_1_eb = []
for n in range(len(data_voltage_electron_beam_1_1)):
a = data_voltage_electron_beam_1_1[n]/data_current_electron_beam_1_1[n]
U_I1_1_eb.append(a)
U_I1_2_eb = []
for n in range(len(data_voltage_electron_beam_1_2)):
a = data_voltage_electron_beam_1_2[n]/data_current_electron_beam_1_2[n]
U_I1_2_eb.append(a)
plt.figure(figsize=(6, 4))
plt.scatter(data_diameter_electron_beam_1_1, U_I1_1_eb, label="Isolierte Messwerte", color="red", marker="x")
plt.scatter(data_diameter_electron_beam_1_2, U_I1_2_eb, label="Messreihe 1", color="black", marker=".")
plt.scatter(data_diameter_electron_beam_2, U_I2_eb, label="Messreihe 2", color="green", marker=".")
plt.xlabel('Durchmesser $d$ (mm)', fontsize=10)
plt.ylabel('$U/I$ (V/A)', fontsize=10)
plt.legend(fontsize=10)
plt.grid(True)
plt.show()
data_diameter_electron_beam_1_1 = [0.094,0.108,0.111,0.120,0.118,0.129]
data_diameter_electron_beam_1_2 = [0.047,0.054,0.058,0.066,0.062,0.056]
data_diameter_electron_beam_2 = [0.106,0.091,0.081,0.075,0.070,0.062,0.059,0.054,0.051,0.047,0.044,0.108,0.095,0.088,0.079,0.074,0.071,0.064,0.062,0.057,0.055,0.051]
data_current_electron_beam = data_current_electron_beam_1_2 + data_current_electron_beam_2
data_voltage_electron_beam = data_voltage_electron_beam_1_2 + data_voltage_electron_beam_2
data_diameter_electron_beam = data_diameter_electron_beam_1_2 + data_diameter_electron_beam_2
Berechnung vom $B$-Feld:
n = 130
R = 0.15
mu_0 = 4*np.pi*10**(-7)
magnetic_field_1_1 = []
for k in range(len(data_current_electron_beam_1_1)):
a = (4/5)**(3/2)*(mu_0*n*data_current_electron_beam_1_1[k]/R)
magnetic_field_1_1.append(a)
magnetic_field_12 = []
for k in range(len(data_current_electron_beam)):
a = (4/5)**(3/2)*(mu_0*n*data_current_electron_beam[k]/R)
magnetic_field_12.append(a)
print(80*"-")
print("Magnetisches Feld für die Isolierte Messwerte:")
print(magnetic_field_1_1)
print(data_current_electron_beam_1_1)
print(80*"-")
print("Magnetisches Feld für die Messreihe 1+2:")
print(magnetic_field_12)
print(data_current_electron_beam)
print(80*"-")
-------------------------------------------------------------------------------- Magnetisches Feld für die Isolierte Messwerte: [0.0007792861141634515, 0.0007792861141634515, 0.0007792861141634515, 0.0007792861141634515, 0.0007792861141634515, 0.0007792861141634515] [1, 1, 1, 1, 1, 1] -------------------------------------------------------------------------------- Magnetisches Feld für die Messreihe 1+2: [0.001558572228326903, 0.001558572228326903, 0.001558572228326903, 0.001558572228326903, 0.001558572228326903, 0.001558572228326903, 0.0007792861141634515, 0.0008572147255797966, 0.0009351433369961416, 0.0010130719484124867, 0.001091000559828832, 0.0011689291712451769, 0.0012468577826615223, 0.0013247863940778672, 0.0014027150054942126, 0.0014806436169105574, 0.001558572228326903, 0.0007792861141634515, 0.0008572147255797966, 0.0009351433369961416, 0.0010130719484124867, 0.001091000559828832, 0.0011689291712451769, 0.0012468577826615223, 0.0013247863940778672, 0.0014027150054942126, 0.0014806436169105574, 0.001558572228326903] [2, 2, 2, 2, 2, 2, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2] --------------------------------------------------------------------------------
Berechnung von $\dfrac{U}{B^2}:$
magnetic_field_1_1_n = np.power(magnetic_field_1_1,2)
magnetic_field_12_n = np.power(magnetic_field_12,2)
print(magnetic_field_1_1_n)
print(magnetic_field_12_n)
U_B2_1 =[]
for k in range(len(magnetic_field_1_1_n)):
a = (data_voltage_electron_beam_1_1[k]/magnetic_field_1_1_n[k])
U_B2_1.append(a)
U_B2_2 =[]
for k in range(len(magnetic_field_12_n)):
a = (data_voltage_electron_beam[k]/magnetic_field_12_n[k])
U_B2_2.append(a)
print(80*"-")
print("U/B^2 für die Isolierte Messwerte:")
print(U_B2_1)
print(data_voltage_electron_beam_1_1)
print(magnetic_field_1_1_n)
print(80*"-")
print("U/B^2 für die Messreihe 1+2:")
print(U_B2_2)
print(magnetic_field_12_n)
print(80*"-")
[6.07286848e-07 6.07286848e-07 6.07286848e-07 6.07286848e-07 6.07286848e-07 6.07286848e-07] [2.42914739e-06 2.42914739e-06 2.42914739e-06 2.42914739e-06 2.42914739e-06 2.42914739e-06 6.07286848e-07 7.34817086e-07 8.74493061e-07 1.02631477e-06 1.19028222e-06 1.36639541e-06 1.55465433e-06 1.75505899e-06 1.96760939e-06 2.19230552e-06 2.42914739e-06 6.07286848e-07 7.34817086e-07 8.74493061e-07 1.02631477e-06 1.19028222e-06 1.36639541e-06 1.55465433e-06 1.75505899e-06 1.96760939e-06 2.19230552e-06 2.42914739e-06] -------------------------------------------------------------------------------- U/B^2 für die Isolierte Messwerte: [181298179.61958924, 214560879.2409853, 229710227.5834033, 247494245.20276356, 263483394.37720686, 281086278.48377734] [110.1, 130.3, 139.5, 150.3, 160.01, 170.7] [6.07286848e-07 6.07286848e-07 6.07286848e-07 6.07286848e-07 6.07286848e-07 6.07286848e-07] -------------------------------------------------------------------------------- U/B^2 für die Messreihe 1+2: [57633390.433111936, 66031398.75336539, 74100073.41400106, 82333414.90444562, 78216744.15922333, 69983402.66877878, 230862895.3920655, 190795781.31575662, 160321455.13337886, 136605263.54560092, 117787191.52656406, 102605731.28536251, 90180818.51252559, 79883354.80694312, 71253980.05927947, 63950940.55181873, 57715723.848016374, 263631594.52403486, 217877350.8463098, 183077496.1972465, 155995026.3455828, 134505915.57348722, 117169597.56623779, 102981091.61095113, 91222005.02561764, 81367776.08766508, 73028142.52743351, 65907898.631008714] [2.42914739e-06 2.42914739e-06 2.42914739e-06 2.42914739e-06 2.42914739e-06 2.42914739e-06 6.07286848e-07 7.34817086e-07 8.74493061e-07 1.02631477e-06 1.19028222e-06 1.36639541e-06 1.55465433e-06 1.75505899e-06 1.96760939e-06 2.19230552e-06 2.42914739e-06 6.07286848e-07 7.34817086e-07 8.74493061e-07 1.02631477e-06 1.19028222e-06 1.36639541e-06 1.55465433e-06 1.75505899e-06 1.96760939e-06 2.19230552e-06 2.42914739e-06] --------------------------------------------------------------------------------
Fehlerfortpflanzung auf $U/B^2$:
$\Delta B = \sqrt{(\dfrac{dB}{dI_S} \Delta I_S)^2 + (\dfrac{dB}{dR} \Delta R)^2}$
def calculate_error_propagation(mu_0_value, I_S_value, N_value, R_value, Delta_I_S_value, Delta_R_value):
mu_0, I_S, N, l = sp.symbols('mu_0 I_S N l', real=True, positive=True)
Delta_I_S, Delta_N, Delta_l = sp.symbols('Delta_I_S Delta_N Delta_l', real=True, positive=True)
B = mu_0 * (N * I_S) / l
dB_dI_S = sp.diff(B, I_S)
dB_dN = sp.diff(B, N)
dB_dl = sp.diff(B, l)
Delta_B = sp.sqrt((dB_dI_S * Delta_I_S)**2 + (dB_dl * Delta_l)**2)
substitutions = {
mu_0: mu_0_value,
I_S: I_S_value,
N: N_value,
l: R_value,
Delta_I_S: Delta_I_S_value,
Delta_l: Delta_R_value
}
Delta_B_value = Delta_B.subs(substitutions)
return Delta_B_value
delta_magnetic_field = []
for n in range(len(data_current_electron_beam_1_1)):
a = calculate_error_propagation(mu_0,data_current_electron_beam_1_1[n],N,R,0.001,0.005)
delta_magnetic_field.append(a)
for n in range(len(data_current_electron_beam_1_2)):
a = calculate_error_propagation(mu_0,data_current_electron_beam_1_2[n],N,R,0.001,0.005)
delta_magnetic_field.append(a)
for n in range(len(data_current_electron_beam_2)):
a = calculate_error_propagation(mu_0,data_current_electron_beam_2[n],N,R,0.001,0.005)
delta_magnetic_field.append(a)
print(80*"-")
print("Fehler auf dem B-Feld (T)")
print(delta_magnetic_field)
print(80*"-")
-------------------------------------------------------------------------------- Fehler auf dem B-Feld (T) [3.63191810492704e-5, 3.63191810492704e-5, 3.63191810492704e-5, 3.63191810492704e-5, 3.63191810492704e-5, 3.63191810492704e-5, 7.26138645644572e-5, 7.26138645644572e-5, 7.26138645644572e-5, 7.26138645644572e-5, 7.26138645644572e-5, 7.26138645644572e-5, 3.63191810492704e-5, 3.99479816903480e-5, 4.35770295714885e-5, 4.72062676719489e-5, 5.08356552515682e-5, 5.44651624278878e-5, 5.80947667852744e-5, 6.17244511800141e-5, 6.53542022766078e-5, 6.89840095460455e-5, 7.26138645644572e-5, 3.63191810492704e-5, 3.99479816903480e-5, 4.35770295714885e-5, 4.72062676719489e-5, 5.08356552515682e-5, 5.44651624278878e-5, 5.80947667852744e-5, 6.17244511800141e-5, 6.53542022766078e-5, 6.89840095460455e-5, 7.26138645644572e-5] --------------------------------------------------------------------------------
$\Delta (U/B^2) = \sqrt{(\dfrac{d(U/B^2)}{dB} \Delta B)^2 + (\dfrac{d(U/B^2)}{dU} \Delta U)^2}$ = $3.2 \times 10^{6} \dfrac{V}{T^2}$
U = 160.1
B = 0.001558572228326903
delta_B = 7.26138645644572e-5
U_B2 = U / B**2
delta_B_over_B = delta_B / B
delta_U_B2 = U_B2 * delta_B_over_B
delta_U_B2
3070648.3395110494
Fit der Messreihe Isolierte Messwerte:
def model_fadenstrahlrohr(d,e_m):
return (1/8)*(d**2)*e_m
fit = XYFit(xy_data=[data_diameter_electron_beam_1_1,U_B2_1], model_function=model_fadenstrahlrohr)
fit.add_error(axis='x', err_val=0.005)
fit.add_error(axis='y', err_val=3*10**(6))
fit.do_fit()
fit.model_label
plot = Plot(fit)
plot.x_label = "d (m)"
plot.y_label = "$U/B^2$ ($V/T^2$)"
plot.plot()
plt.show()
Wie erwartet, ist der $\chi^2$-Wert mit einem Betrag von $0.674$ sehr schlecht und bestätigt unsere Entscheidung, diese vom rest der Daten zu isolieren.
Fit der Messreihe 1+2:
def model_fadenstrahlrohr(d,e_m):
return (1/8)*(d**2)*e_m
fit = XYFit(xy_data=[data_diameter_electron_beam,U_B2_2], model_function=model_fadenstrahlrohr)
fit.add_error(axis='x', err_val=0.005)
fit.add_error(axis='y', err_val=3.2*10)
fit.do_fit()
plot = Plot(fit)
plot.x_label = "d (m)"
plot.y_label = "$U/B^2$ ($V/T^2$)"
plot.plot()
plt.show()
Der angepasste Modell liefert einen sehr guten Fit. Bei einem $\chi^2$-Wert von $0.995$ passen die Daten ausgezeichnet auf der Modell.
Der Fit liefert den Wert:
$ \frac{e}{m_e} = (1.84\times 10^{11} \pm 1.4) $ $\dfrac{C}{kg}$
e_me_theoretical = 1.75882000838 * 10**11
e_me_theoretical_std = 55
e_me_experiment = 1.84*10**11
e_me_experiment_std = 1.4
print("Abweichung in %")
print((np.absolute(e_me_experiment/e_me_theoretical) -1)*100)
Abweichung in % 4.61559404789651
pull = (e_me_experiment - e_me_theoretical )/np.sqrt(e_me_theoretical_std**2 + e_me_experiment_std**2)
print(pull)
147552190.47231326
D I S K U S S I O N
Die Ergebnisse zeigen, dass der Durchmesser der Elektronenbahn im Fadenstrahlrohr sowohl von der Anodenspannung als auch vom Spulenstrom abhängt.
In der ersten Messreihe wurde deutlich, dass der Durchmesser mit steigender Anodenspannung größer wird. Das liegt daran, dass eine höhere Spannung die Elektronen schneller macht und somit ihre Bahn erweitert. Dies bestätigt das theoretische Modell, das einen direkten Zusammenhang zwischen der Geschwindigkeit der Elektronen und dem Bahnradius vorhersagt.
In der zweiten Messreihe nahm der Durchmesser mit steigendem Spulenstrom ab. Ein stärkerer Strom erzeugt ein stärkeres Magnetfeld, das die Elektronen enger auf ihrer Bahn hält. Auch hier entsprechen die Messergebnisse den Erwartungen, da das Magnetfeld die Lorentzkraft verstärkt und so die Bahn verkleinert.
Die beiden Effekte – die Erweiterung der Bahn durch höhere Anodenspannung und die Verkleinerung durch einen stärkeren Spulenstrom – wirken entgegengesetzt. Sie konnten im Experiment unabhängig voneinander untersucht und bestätigt werden.
Es ergibt sich ein Wert von $ \frac{e}{m_e} = (1.84\times 10^{11} \pm 1.4) $ $\dfrac{C}{kg}$.
Somit liegt der Literaturwert von $\frac{e}{m_e} = 1.75882000838 * 10^{11}\frac{\mathrm C}{\mathrm kg}$ (https://physics.nist.gov/cgi-bin/cuu/Value?esme; Stand: 20:08 10.12.2024) für den Wert außerhalb der Unsicherheit.
Die Berechnung für die Kompabilität ergibt einen Wert von $1.47*10^8$. Damit ist das ermittelte $\dfrac{e}{e_m}$ Wert mit dem Referenzwert nicht kompatiblel. Es sind möglicherweise systematische Fehler nicht berücksichtigt worden.
Mögliche Messfehler könnten durch Parallaxen bei der visuellen Bestimmung des Durchmessers entstanden sein. Die Ergebnisse stimmen jedoch gut mit den theoretischen Vorhersagen überein.
Aufgabe 2: Methode von Busch¶
Aufgabe 2.1: Vorbereitung¶
Machen Sie sich im Rahmen einer Einzelmessung mit dem Verfahren von Busch vertraut.
V E R S U C H S B E S C H R E I B U N G
Es soll später mithilfe der Methode von Busch $\frac{e}{m_e}$ bestimmt werden. Zunächst soll sich mit den Gerätschaften bekannt gemacht werden. Dazu soll der folgende Aufbau nachgebaut werden
Abbildung 5a: Plan zur Beschaltung für die Methode von Busch aus (1)
Dabei werden Elektronen von einer Beschleunigungsspannung $U_B$ in eine Spule geschossen. Dadurch ist die Bewegungsrichtung der Elektronen (z-Richtung) parallel zu den B-Feldlinien und es tritt keine Lorentzkraft auf. Sie treten dann in das E-Feld der parallelen Deflektorplatten am Anfang der Spulen ein.
Das E-Feld, welches orthogonal zu der initialen Bewegungsrichtung der Elektronen verläuft übt eine Kraft auf die Elektronen aus und ihre Bewegungsrichtung wird geändert. Wenn die Deflektorplatten oberhalb und unterhalb der Spule sind erfährt das Elektron eine Kraft in y-Richtung in Richtung der positiven Platte.
Das E-Feld liegt nur am Anfang an und die Elektronen „fliegen“ somit in einer Geraden, würde kein Strom an der Spule anliegen, weiter. Da aber die Spule ein Magnetfeld erzeugt, wird, weil durch die Ablenkung der Elektronen nun nicht mehr der gesamte Bewegungsvektor der Elektronen parallel zu dem B-Feld verläuft eine Lorentzkraft wirken.
Diese wirkt orthogonal zum Anteil der Bewegungsrichtung der Elektronen, welcher orthogonal zu der Richtung des B-Feldes wirkt und dem B-Feld. In dem Beispiel, in dem die Elektronen einen y-Impuls neben dem z-Impuls haben in x-Richtung. Dadurch wird auf der x-y-Ebene eine Kreisbahn durchlaufen, während diese Ebene sich in z-Richtung bewegt.
So entsteht eine Spiralbahn. Je größer hierbei die Deflektorspannung, desto größer der Impuls orthogonal zu der Bewegungsrichtung und somit auch der Radius der Spirale. Nun kann mit einem Schirm der Punkt, an dem der Elektronenstrahl auftrifft, visualisiert werden.
Dadurch, dass eine Wechselspannung als Deflektorspannung anliegt variiert die Position des Punktes im Abstand von der Mitte des Schirms, wobei die Amplitude der Auslenkung des Punktes von dem Maximum der Deflektorspannung und dem Abstand des Schirmes abhängt.
So erscheint ein Punkt, der bei maximaler Spannung am weitesten von dem Zentrum weg ist und dann beim Spannungsabfall der Wechselspannung nach innen wandert.
Erreicht die Deflektorspannung 0, ist der Punkt im Zentrum und wenn die Spannung Richtung wechselt, so wandert der Punkt weiter durch das Zentrum auf die andere Seite weiter bis zum anderen äußersten Punkt, welcher bei dem Maximum der Spannung mit gegenteiliger Richtung wie zuvor erreicht wird. Das menschliche Auge nimmt dabei einen Strich wahr, weil dieser Vorgang sehr schnell vor sich geht.
Wird der Schirm verschoben, wird ein anderer Teil der 2 Kreise (bei positiver/negativer Spannung) beobachtet. Für eine konstante Deflektorspannung wurde bei der Entfernung $z_0$ des Schirmes die Kreisbahn genau einmal durchlaufen. Dort sind alle Punkte am gleichen Ort und es erscheint ein Punkt. Für alle Vielfachen von $z_0$ erscheint auch ein Punkt.
Abbildung 5b: Aufbau für die Methode von Busch (Eigene Darstellung, 2024)
L Ö S U N G
Abbildung 6: Schirm (Eigene Darstellung, 2024)
Abbildung 7: Schirm (Eigene Darstellung, 2024)
Es konnte tatsächlich ein Punkt gefunden werden, an dem sich der Elektronenstrahl weitestgehend konzentriert.
D I S K U S S I O N
Die Gerätschaften sind funktionsfähig und es wurde sich mit deren Funktion vertraut gemacht.
Aufgabe 2.2: Bestimmung von $e/m_{\mathrm{e}}$¶
- Messen Sie für verschiedene Beschleunigungsspannungen $U_{z}$ den nötigen Spulenstrom $I_{\mathrm{S}}$, um auf dem Schirm S der Apparatur einen Signalpunkt zu erzeugen.
- Tragen Sie $U_{z}$ geeignet über $I_{\mathrm{S}}^{2}$ auf und bestimmen Sie daraus $e/m_{\mathrm{e}}$.
V E R S U C H S B E S C H R E I B U N G
Nun soll mithilfe des Aufbaus $\frac{e}{m_e}$ gemessen werden. Grundlage des Versuches ist, dass der Radius der Spirale von 2 Kräften bestimmt wird:
Der Zentrifugalkraft und der Lorentzkraft.
Sind diese Kräfte im Gleichgewicht, wird eine Kreisbahn durchlaufen, sind sie es nicht, dann erfährt das Elektron eine Kraft in die Richtung des Gleichgewichtes.
Über das Gleichsetzen von $F_Z = \mathrm m*\frac{v^2}{r}$ und $F_L = q * v * <B>$ mit $<B>$ als zeitliches Mittel des B-Feldes ergibt sich $q*v*<B> = \mathrm m*\frac{v^2}{r}$
Durch Umstellen entsteht $B = \frac{m v}{r * q}$
Wird nun $K = \frac{B}{I}$ eingesetzt, ergibt sich: $I = \frac{m v}{K * r * q} = \frac{v}{K * r} * \frac{q}{m}$
Der Faktor $\frac{q}{m}$ entspricht $\frac{e}{m_e}$ im Falle eines Elektrons.
L Ö S U N G
Importieren der aufgenommene Daten:
data_Uz_v = [203,224,250,274,300,327,350,375,400,424,450,310,263,346.5,387]
data_IS_v = [0.212,0.222,0.242,0.258,0.263,0.284,0.29,0.304,0.316,0.33,0.34,0.274,0.25,0.291,0.31]
data_Uz_h = [200,225,250,275,300,325,350,375,400,425,450,475,500,525,550]
data_IS_h = [0.169,0.179,0.189,0.199,0.21,0.226,0.235,0.241,0.251,0.258,0.262,0.271,0.284,0.287,0.296]
Fehlerabschätzung:
$\Delta U_z = \pm \ 0.2$ V
$\Delta I_S = \pm \ 1$ mA
Plot der aufgenommene Daten:
plt.figure(figsize=(4, 3))
plt.ylabel('Strom $I_S$(A)', fontsize=10)
plt.xlabel('Spannung $U_z$ (V)', fontsize=10)
plt.scatter(data_Uz_v,data_IS_v, marker="x", color="blue", label="Vertikale Ablenkung")
plt.scatter(data_Uz_h,data_IS_h, marker="x", color="red", label="Horizontale Ablenkung")
plt.legend()
plt.grid(True)
plt.show()
Plot von $I^2_S$ gegen $U_z$:
plt.figure(figsize=(4, 3))
plt.ylabel('Strom $I_S^2$(A)', fontsize=10)
plt.xlabel('Spannung $U_z$ (V)', fontsize=10)
plt.scatter(data_Uz_v,np.power(data_IS_v,2), marker="x", color="blue", label="Vertikale Ablenkung")
plt.scatter(data_Uz_h,np.power(data_IS_h,2), marker="x", color="red", label="Horizontale Ablenkung")
plt.legend()
plt.grid(True)
plt.show()
Berechnung der Unsicherheit auf $B(z,I_S,l)$:
$\Delta l = 0.5$ mm
$\Delta R = 0.5$ mm
$\Delta d1 = 1$ mm
$\Delta d2 = 1$ mm
$B(z, I_{\mathrm{S}}, \ell)=B_{0}\left(0.567\left(\frac{z}{\sqrt{R^{2}+z^{2}}}+\frac{\ell-z}{\sqrt{R^{2}+(\ell-z)^{2}}}\right)\right)$
mit:
$B_{0}(I_{\mathrm{S}}, N, \ell) = \mu_{0}\,\frac{N\,I_{\mathrm{S}}}{\ell}$
Also berechnen wir:
$\Delta B = \sqrt{(\dfrac{\partial B}{\partial z} \Delta z)^2+(\dfrac{\partial B}{\partial I_S} \Delta I_S)^2+(\dfrac{\partial B}{\partial l} \Delta l)^2 + (\dfrac{\partial B}{\partial R} \Delta R)^2 }$
mit:
$\dfrac{\partial B}{\partial z} = B_0 * 0.567 * (\dfrac{R^2}{(R^2+z^2)^{3/2}}+\dfrac{R^2}{(R^2+(l-z)^2)^{3/2}})$
$\dfrac{\partial B}{\partial I_S} = \mu_0 * \dfrac{N}{l} * 0.567 * (\dfrac{z}{(R^2+z^2)^{3/2}}+\dfrac{l-z}{(R^2+(l-z)^2)^{3/2}})$
$\dfrac{\partial B}{\partial I_S} = - \mu_0 * \dfrac{N*I_S}{l^2} * 0.567 * (\dfrac{z}{(R^2+z^2)^{3/2}}+\dfrac{l-z}{(R^2+(l-z)^2)^{3/2}}) + B_0 * 0.567 * \dfrac{R^2}{(R^2+(l-z)^2)^{3/2}}$
$\dfrac{\partial B}{\partial R} = B_0 * 0.567 * (- \dfrac{z*R}{(R^2+z^2)^{3/2}}-\dfrac{(l-z)*R}{(R^2+(l-z)^2)^{3/2}})$
h1 = 0.088
h2 = 0.070
I_S = 0.571
ell = 200
R = 45
N = 3000
delta_h1 = 0.001
delta_h2 = 0.001
delta_I_S = 0.001
delta_ell = 0.0005
delta_R = 0.0005
def calculate_uncertainty(z, I_S, ell, R, N, delta_z, delta_I_S, delta_ell, delta_R):
B_0 = lambda I_S, ell: mu_0 * N * I_S / ell
term1 = lambda z: z / np.sqrt(R**2 + z**2)
term2 = lambda z, ell: (ell - z) / np.sqrt(R**2 + (ell - z)**2)
B = lambda z, I_S, ell: B_0(I_S, ell) * 0.567 * (term1(z) + term2(z, ell))
dB_dz = lambda z, ell: B_0(I_S, ell) * 0.567 * (R**2 / (R**2 + z**2)**(3/2) - R**2 / (R**2 + (ell - z)**2)**(3/2))
dB_dI_S = lambda z, I_S, ell: (mu_0 * N / ell) * 0.567 * (term1(z) + term2(z, ell))
dB_dell = lambda z, I_S, ell: ((-mu_0 * N * I_S / ell**2) * 0.567 * (term1(z) + term2(z, ell)) + B_0(I_S, ell) * 0.567 * (R**2 / (R**2 + (ell - z)**2)**(3/2)))
dB_dR = lambda z, ell: B_0(I_S, ell) * 0.567 * ( -z * R / (R**2 + z**2)**(3/2) - (ell - z) * R / (R**2 + (ell - z)**2)**(3/2))
delta_B = np.sqrt((dB_dz(z, ell) * delta_z)**2+ (dB_dI_S(z, I_S, ell) * delta_I_S)**2+ (dB_dell(z, I_S, ell) * delta_ell)**2+ (dB_dR(z, ell) * delta_R)**2)
return delta_B
delta_B_1 = calculate_uncertainty((150-h1), I_S, ell, R, N, delta_h1, delta_I_S, delta_ell, delta_R)
delta_B_2 = calculate_uncertainty((150-h2), I_S, ell, R, N, delta_h2, delta_I_S, delta_ell, delta_R)
print(f"Die Unsicherheit von B_1 beträgt: {delta_B_1:.6e} T")
print(f"Die Unsicherheit von B_2 beträgt: {delta_B_2:.6e} T")
Die Unsicherheit von B_1 beträgt: 1.818687e-08 T Die Unsicherheit von B_2 beträgt: 1.818570e-08 T
Berechnung von $⟨B⟩$:
Aus den gegebenen tools:
L = 200. # L (mm)
n = 3000 # Anzahl der Windungen
R = 45. # mittlerer Radius (mm)
S = 150. # Bildschirmposition (mm)
d1 = 88. # Abstand Deflektrozentrum 1 vom Bildschirm (mm)
d2 = 70. # Abstand Deflektrozentrum 2 vom Bildschirm (mm)
def MeanField(I, d):
return integrate.quad(Bfield, S-d, S, args=(I))[0]/d
def Bfield(x, I):
return 1000.*mu_0*I*n/L*0.567*(x/np.sqrt(R**2+x**2)+(L-x)/np.sqrt(R**2+(L-x)**2))
fig, ax = plt.subplots(figsize=(6., 6.))
ax.set_xlabel(r"$z\,[\mathrm{mm}]$")
ax.set_ylabel(r"$B\,[\mathrm{mT}]$")
ax.set_xlim(0., 200.)
ax.set_ylim(0., 15.)
ax.grid(axis='both', linewidth=1, linestyle="--", color='lightgray')
df = pd.read_csv("Busch-Magnetfeld-observed.csv")
B143,=ax.plot(df["a"], df["B143"], linewidth=0, color="darkblue" , marker="o", label=r"$I_{\mathrm{S}}=143\,\mathrm{mA}$")
B286,=ax.plot(df["a"], df["B286"], linewidth=0, color="darkmagenta", marker="^", label=r"$I_{\mathrm{S}}=286\,\mathrm{mA}$")
B429,=ax.plot(df["a"], df["B429"], linewidth=0, color="darkcyan" , marker="v", label=r"$I_{\mathrm{S}}=429\,\mathrm{mA}$")
B571,=ax.plot(df["a"], df["B571"], linewidth=0, color="darkgreen" , marker="s", label=r"$I_{\mathrm{S}}=571\,\mathrm{mA}$")
B714,=ax.plot(df["a"], df["B714"], linewidth=0, color="goldenrod" , marker="D", label=r"$I_{\mathrm{S}}=714\,\mathrm{mA}$")
x = np.linspace(10., 190., 180)
ax.plot(x, Bfield(x, 143), linewidth=1, linestyle=(0., (5., 2.5)), color="darkblue" )
ax.plot(x, Bfield(x, 286), linewidth=1, linestyle=(0., (5., 2.5)), color="darkmagenta")
ax.plot(x, Bfield(x, 429), linewidth=1, linestyle=(0., (5., 2.5)), color="darkcyan" )
ax.plot(x, Bfield(x, 571), linewidth=1, linestyle=(0., (5., 2.5)), color="darkgreen" )
ax.plot(x, Bfield(x, 714), linewidth=1, linestyle=(0., (5., 2.5)), color="goldenrod" )
dashed_line=mlines.Line2D([], [], color="gray", linestyle=(0., (5., 2.5)), label="Erwartung")
ax.legend(
handles=[B143, B286, B429, B571, B714, dashed_line],
bbox_to_anchor=(0., 1., 1., 0.2),
loc="lower left",
mode="expand",
ncol=3
)
plt.show()
B_x = MeanField(571, d1)
B_y = MeanField(571, d2)
print(80*"-")
print("Mittleres B-Feld (571 mA, Position d1):", "{:0<6.5} mT".format(B_x))
print("Mittleres B-Feld (571 mA, Position d2):", "{:0<6.5} mT".format(B_y))
print(80*"-")
-------------------------------------------------------------------------------- Mittleres B-Feld (571 mA, Position d1): 10.949 mT Mittleres B-Feld (571 mA, Position d2): 10.959 mT --------------------------------------------------------------------------------
Berechnung der Unsicherheit von ⟨B⟩:
$\Delta ⟨B⟩ = \sqrt{(\dfrac{\partial B}{\partial dh_i} \Delta dh_i)^2 + \int_{d_i}^{d_S}[(\dfrac{\partial B}{\partial z} \Delta z)^2+(\dfrac{\partial B}{\partial I_S} \Delta I_S)^2+(\dfrac{\partial B}{\partial l} \Delta l)^2 + (\dfrac{\partial B}{\partial R} \Delta R)^2 ]dz}$
Hier wird die Berechnung des mittleren B-Feld duch eine alternative Implementation verifiziert. Schlussendlich wird die Unsicherheit bestimmt.
dS = 0.150
h1 = 0.088
h2 = 0.070
ell = 0.200
R = 0.045
N = 3000
I_S = 0.571
delta_h = 0.001
delta_I_S = 0.001
delta_ell = 0.0005
delta_R = 0.0005
def calculate_mean_field_and_uncertainty(dS, d_i, I_S, ell, R, d_h, N, delta_I_S, delta_ell, delta_R, delta_h):
B_0 = lambda I_S, ell: mu_0 * N * I_S / ell
term1 = lambda z: z / np.sqrt(R**2 + z**2)
term2 = lambda z, ell: (ell - z) / np.sqrt(R**2 + (ell - z)**2)
B = lambda z, I_S, ell: B_0(I_S, ell) * 0.567 * (term1(z) + term2(z, ell))
dB_dI_S = lambda z, I_S, ell: (mu_0 * N / ell) * 0.567 * (term1(z) + term2(z, ell))
dB_dell = lambda z, I_S, ell: ((-mu_0 * N * I_S / ell**2) * 0.567 * (term1(z) + term2(z, ell))+ B_0(I_S, ell) * 0.567 * (R**2 / (R**2 + (ell - z)**2)**(3/2)))
dB_dR = lambda z, ell: B_0(I_S, ell) * 0.567 * (-z * R / (R**2 + z**2)**(3/2)- (ell - z) * R / (R**2 + (ell - z)**2)**(3/2))
integrand = lambda z: B(z, I_S, ell)
integral_B, _ = integrate.quad(integrand, dS-d_i, dS)
mean_B = integral_B / d_h
dMeanB_d_dh = -mean_B / d_h**2 + B(dS-d_i, I_S, ell) / d_h
delta_B = np.sqrt((dMeanB_d_dh * delta_h)**2 +integrate.quad(lambda z: ((dB_dI_S(z, I_S, ell) * delta_I_S)**2 +(dB_dell(z, I_S, ell) * delta_ell)**2 +(dB_dR(z, ell) * delta_R)**2), d_i, dS)[0])
return mean_B, delta_B
mean_B_1, delta_B_1 = calculate_mean_field_and_uncertainty(
dS, h1, I_S, ell, R, h1, N, delta_I_S, delta_ell, delta_R, delta_h
)
mean_B_2, delta_B_2 = calculate_mean_field_and_uncertainty(
dS, h2, I_S, ell, R, h2, N, delta_I_S, delta_ell, delta_R, delta_h
)
print(f"Die mittlere Feldstärke <B> beträgt: {mean_B_1:.6e} T")
print(f"Die Unsicherheit von <B> beträgt: {delta_B_1:.6e} T")
print(f"Die mittlere Feldstärke <B> beträgt: {mean_B_2:.6e} T")
print(f"Die Unsicherheit von <B> beträgt: {delta_B_2:.6e} T")
Die mittlere Feldstärke <B> beträgt: 1.094867e-02 T Die Unsicherheit von <B> beträgt: 1.291800e-03 T Die mittlere Feldstärke <B> beträgt: 1.095942e-02 T Die Unsicherheit von <B> beträgt: 2.079027e-03 T
Den Resultat wurde erfolgreich bestätigt.
$⟨B⟩_x = 11 \pm 1.3 $ mT
$⟨B⟩_y = 11 \pm 2.1$ mT
Berechnung von $K$:
K_x = B_x / 571
K_y = B_y / 571
delta_K_x = delta_B_1/ 571
delta_K_y = delta_B_2/ 571
print(80*"-")
print(K_x)
print(delta_K_x)
print(80*"-")
print(K_y)
print(delta_K_y)
print(80*"-")
-------------------------------------------------------------------------------- 0.019174547141174114 2.26234717856472e-06 -------------------------------------------------------------------------------- 0.019193385997911296 3.6410280622884997e-06 --------------------------------------------------------------------------------
$K_x = (0.01918 \pm 2.26 * 10^{-6})$ T
$K_y = (0.01919 \pm 3.64 * 10^{-6})$ T
def model_busch_x(Uz,e_me,offset):
return (8*Uz*np.pi**2)/(e_me*K_x**2*(S-d1)**2)+offset
fit = XYFit(xy_data=[data_Uz_v,10**-6 * np.power(data_IS_v,2)], model_function=model_busch_x)
fit.add_error(axis='x', err_val=0.002)
fit.add_error(axis='y', err_val=0.01*10**-6)
fit.do_fit()
fit.model_label
plot = Plot(fit)
plot.x_label = "Spannung $U_H$ (V)"
plot.y_label = "Strom $(mI)^2$ (A)"
plot.plot()
plt.show()
def model_busch_y(Uz,e_me,offset):
return (8*Uz*np.pi**2)/(e_me*K_y**2*(S-d2)**2)+offset
fit = XYFit(xy_data=[data_Uz_h,10**-6 * np.power(data_IS_h,2)], model_function=model_busch_y)
fit.add_error(axis='x', err_val=0.002)
fit.add_error(axis='y', err_val=0.01*10**-6)
fit.do_fit()
fit.model_label
plot = Plot(fit)
plot.x_label = "Spannung $U_H$ (V)"
plot.y_label = "Strom $(mI)^2$ (A)"
plot.plot()
plt.show()
$\dfrac{e}{m_e} = (1.97*10^{11} \pm 2.8*10^{10})$ $\dfrac{C}{kg}$
e_me_theoretical = 1.75882000838 * 10**11
e_me_theoretical_std = 55
e_me_experiment = 1.97*10**11
e_me_experiment_std = 2.8*10**10
print("Abweichung in %")
print((np.absolute(e_me_experiment/e_me_theoretical) -1)*100)
Abweichung in % 12.006913192584845
pull = (e_me_experiment - e_me_theoretical )/np.sqrt(e_me_theoretical_std**2 + e_me_experiment_std**2)
print(pull)
0.7542142557857143
D I S K U S S I O N
Es ergibt sich ein $\frac{e}{m_e}$ Quotient von $1.97*10^{11}\frac{\mathrm C}{\mathrm kg} \pm 2.5*10^{10}\frac{\mathrm C}{\mathrm kg}$ (bei horizontalen Deflektorplatten) bzw. $\pm 2.8*10^{10}\frac{\mathrm C}{\mathrm kg} $(bei vertikalen Deflektorplatten).
Somit liegt der Literaturwert von $\frac{e}{m_e} = 1.75882000838 * 10^{11}\frac{\mathrm C}{\mathrm kg}$ (https://physics.nist.gov/cgi-bin/cuu/Value?esme; Stand: 20:08 10.12.2024) für beide Werte innerhalb der Unsicherheit.
Die Berechnung für die Kompabilität ergibt einen Wert von $0.754$. Damit ist das ermittelte $\dfrac{e}{e_m}$ Wert mit dem Referenzwert kompatiblel.
Das spricht zusammen mit den $\chi^2$-Werten von 1 für ein akkurates Ergbnis innerhalb des Aufbaus. Quelle der Abweichung von 12% des Wertes $1.97*10^{11}$ vom Literaturwert dürfte sein, dass Teil der Messreihe ist, den Punkt zu wählen, an dem der Elektronenstrahl am konzentriertesten ist, was aufgrund der Gerätschaften, die an keinen Punkte den Elektronenstrahl perfekt bündeln, schwierig ist.
Beurteilung¶
- Nach Abschluss des Versuchs haben Sie die Möglichkeit diesen Versuch individuell zu beurteilen.
- Folgen Sie zur Beurteilung dieses Versuchs diesem Link.
- Beachten Sie, dass jede:r Studierende nur einmal pro Versuch eine Beurteilung abgeben kann.
- Wir empfehlen die Beurteilung nach der Besprechung Ihrer Versuchsauswertung mit Ihrem:r Tutor:in auszufüllen.