r_h = 0.147 n_h = 124 # Data of the induction coil n_i = 4000 A_i = 41.7 * sc.centi**2 # Measured values # Resistance and maximum allowed supply voltage I_max = 5.0 I_test = 1.83 d_I_test = 0.01 U_test = 2.2 d_U_test = 0.1 R_sp = U_test / I_test d_R_sp = R_sp * ms.sqrt((d_U_test / U_test)**2 + (d_I_test / I_test)**2) U_max = R_sp * I_max # Frequency and induced voltage at constant current I1 = 8.0 / 2 d_I1 = 0.1 / 2 f1 = npf([3.0, 5.6, 9.3, 11.93, 14.90]) d_f1 = npf([0.1, 0.1, 0.1, 0.40, 0.40]) U1_i = npf([0.81, 2.40, 5.08, 6.96, 9.04]) / 2 d_U1_i = npf([0.02, 0.03, 0.04, 0.01, 0.01]) / 2 # Current, voltage and induced voltage at constant frequency f2 = 9.96 d_f2 = 0.05 I2 = npf([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]) d_I2 = npf([0.1, 0.1, 0.1, 0.2, 0.1, 0.1, 0.1, 0.1, 0.1])
ms.plt.rc('text', usetex=True)
ms.plt.rc('font', family='serif')
titles = [
r'Abhängigkeit der Energie $E_\alpha$ der $K_\alpha$-Strahlung der Elemente in Abhängigkeit der Kernladungszahl $Z$.',
r'Abhängigkeit der Energie $E_\beta$ der $K_\beta$-Strahlung der Elemente in Abhängigkeit der Kernladungszahl $Z$.'
]
# Determination of the Rydberg-energy and the screening constant for the K_α-Radiation
Z1 = npf([26, 29, 47, 22, 40, 30, 28, 42])
E_alpha = npf([6.42, 8.05, 21.93, 4.64, 15.80, 8.65, 7.48, 17.47
]) * cs.kilo * cs.e
d_E_alpha = npf([0.15, 0.17, 0.20, 0.16, 0.17, 0.17, 0.17, 0.18
]) * cs.kilo * cs.e
sr_E_alpha = sqrt(E_alpha)
d_sr_E_alpha = d_E_alpha / (2 * sr_E_alpha)
ms.pltext.initplot(num=1,
title=titles[0],
xlabel=r'$Z$',
ylabel=r'$\sqrt{E_\alpha} / \sqrt{\mathrm{eV}}$',
fignum=True)
s1, d_s1, b1, d_b1 = ms.linreg(Z1,
sr_E_alpha / sqrt(cs.e),
d_sr_E_alpha / sqrt(cs.e),
plot=True)
s1 *= sqrt(cs.e)
d_s1 *= sqrt(cs.e)
b1 *= sqrt(cs.e)
d_b1 *= sqrt(cs.e)
r'Bestimmung der Lagen der $K_\alpha$, $K_\beta$-Peaks durch Gaussfits an die Zählraten-Winkel-Abhängigkeit des LiF-Kristalls.',
r'Zählrate $n$ in Abhängigkeit der Spannung der Röntgenröhre $U$ bei einem konstanten Winkel von 7.5$^\circ$',
r'Bestimmung der Lagen der $K_\alpha$, $K_\beta$-Peaks durch Gaussfits an die Zählraten-Winkel-Abhängigkeit des NaCl-Kristalls.'
]
# Constants
d_LiF = 201.4 * cs.pico
rho_NaCl = 2.164 * cs.gram / cs.centi**3
M_NaCl = 58.44 * cs.gram
# (1) Analysis of the spectrum of the LiF-crystal
# Determination of planck's constant
U1 = 35.0 * cs.kilo
t1 = 5.0
beta1, n1 = np.loadtxt('data/255/data1.txt', unpack=True)
d_n1 = sqrt(n1 * t1) / t1
n1_0 = ms.mv(n1[0:7])
d_n1_0 = ms.dsto_mv(n1[0:7])
ms.pltext.initplot(num=1, title=titles[0], xlabel=r'$\beta$ / $^\circ$', ylabel=r'$n$ / (1/s)', fignum=True)
s1, d_s1, b1, d_b1 = ms.linreg(beta1[:20], n1[:20], d_n1[:20], fit_range=range(10, 13), plot=True)
beta1_G = (n1_0 - b1) / s1
d_beta1_G = beta1_G * sqrt((d_n1_0**2 + d_b1**2) / (n1_0 - b1)**2 + (d_s1 / s1)**2)
beta1_G *= cs.degree
d_beta1_G *= cs.degree
ld1_G = 2 * d_LiF * sin(beta1_G)
d_ld1_G = 2 * d_LiF * cos(beta1_G) * d_beta1_G
h1 = (cs.e * U1 / cs.c) * ld1_G
d_h1 = (cs.e * U1 / cs.c) * d_ld1_G
beta1_G2 = arcsin(ld1_G / d_LiF)
d_beta1_G2 = d_ld1_G / sqrt(d_LiF**2 - ld1_G**2)
U8_A = npfarray(
[1.36, 1.36, 1.36, 1.36, 1.26, 0.98, 0.68, 0.27, 0.140, 0.83, 0.33]) / 2
d_U8_A = npfarray(
[0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.004, 0.02, 0.02]) / 2
R9_G = 48.7 * cs.kilo
C9_E = 47 * cs.nano
U9_G = 1.0 / 2
f9 = npfarray([0.3, 0.6, 1.0, 3.0, 6.0, 10.0, 20.0]) * cs.kilo
U9_E = npfarray([832, 832, 832, 848, 848, 840, 848]) * cs.milli / 20.0
d_U9_E = npfarray([8, 8, 8, 8, 8, 8, 8]) * cs.milli / 20.0
U9_A = npfarray([0.388, 0.680, 0.936, 1.34, 1.38, 1.36, 1.26]) / 2
d_U9_A = npfarray([0.004, 0.004, 0.004, 0.02, 0.02, 0.02, 0.02]) / 2
V5 = U5_A / U5_E
d_V5 = V5 * sqrt((d_U5_A / U5_A)**2 + (d_U5_E / U5_E)**2)
V6 = U6_A / U6_E
d_V6 = V6 * sqrt((d_U6_A / U6_A)**2 + (d_U6_E / U6_E)**2)
V7 = U7_A / U7_E
d_V7 = V7 * sqrt((d_U7_A / U7_A)**2 + (d_U7_E / U7_E)**2)
V8 = U8_A / U8_E
d_V8 = V8 * sqrt((d_U8_A / U8_A)**2 + (d_U8_E / U8_E)**2)
V9 = U9_A / U9_E
d_V9 = V9 * sqrt((d_U9_A / U9_A)**2 + (d_U9_E / U9_E)**2)
ms.pltext.initplot(num=3,
title=titles[2],
xlabel=r'$f$ / Hz',
ylabel=r'$V$',
scale='loglog',
fignum=True)
# measure version 1.8.11s
from measure import sqrt, val, npfarray, pltext, plt, linreg, pi, dev, arccos, cos, curve_fit, nplinspace, deg_to_rad, rad_to_deg
# Daten für Spule
r_h = 0.295 / 2
s_h = 0.147
N_h = 124
N_i = 4000
A_i = 41.7e-4
# Aufgabe 2a
I_2a = 4.00
I_2a_dsys = sqrt(0.02**2 + 0.005**2 + (0.012 * I_2a)**2)
f_2a = npfarray([3.1, 6.1, 8.8, 11.8, 14.9])
f_2a_dsys = npfarray([0.02, 0.10, 0.10, 0.10, 0.10])
Vss_2a = npfarray([0.88, 2.70, 4.80, 7.00, 9.30])
Vss_2a_dsys = npfarray([0.02, 0.05, 0.10, 0.10, 0.10])
Uind_2a = Vss_2a / 2
Uind_2a_dsys = Vss_2a_dsys / 2
pltext.initplot(
num=1,
title='Abbildung : Induktionsspannung als Funktion der Frequenz',
xlabel='Drehfrequenz in Hz',
ylabel='Induktionsspannung in V')
[slope_2a, dslope_2a] = linreg(f_2a,
Uind_2a,
Uind_2a_dsys,
f_2a_dsys,
# measure version 1.8.7
from measure import npfarray, sqrt, ln, exp, arctan, lst, tbl, sig, val, mv, dsto_mv, dsys_mv, dtot_mv, plt, pltext, expreg, pi, curve_fit
# Aufgabe 1
R_A1 = npfarray([1, 10, 1]) * 1e3
R_A1_dsys = 0.05 * R_A1
C_A1 = npfarray([470, 4.7, 47]) * 1e-9
C_A1_dsys = 0.10 * C_A1
g_thalb = npfarray([312, 32.6, 32.6]) * 1e-6
g_thalb_dsys = npfarray([4, 0.6, 0.6]) * 1e-6
tau = R_A1 * C_A1
tau_dsys = sqrt((R_A1 * C_A1_dsys)**2 + (R_A1_dsys * C_A1)**2)
b_thalb = ln(2) * tau
b_thalb_dsys = ln(2) * tau_dsys
print()
print('Aufgabe 1:\n')
print(
tbl([
lst(R_A1, R_A1_dsys, 'R'),
lst(C_A1, C_A1_dsys, 'C'),
lst(tau, tau_dsys, 'Tau')
]))
print(
tbl([
lst(b_thalb, b_thalb_dsys, 'T_1/2 (b)'),
lst(g_thalb, g_thalb_dsys, 'T_1/2 (g)'), ['Abw'] + [
sig('', b_thalb[i], b_thalb_dsys[i], g_thalb[i], g_thalb_dsys[i])
for i in range(len(b_thalb))
]
print()
# Constants
rho_Pb = 11.34 * cs.gram / cs.centi**3
rho_Al = 2.699 * cs.gram / cs.centi**3
# Measurements of the counter tube
r_c = 14 * cs.milli / 2
l_c = 4 * cs.centi
U0_c = 520
d_U0_c = 10
# Measurement of the background
t0 = 5 * cs.minute
n0 = 122
d_n0 = sqrt(n0) / t0
n0 = n0 / t0
print(ms.val("n0", n0, d_n0, unit='1/s', prefix=False))
# Measurement of β-Radiation absorption, Sr 90, GS 527
A_Sr = 74 * cs.kilo
a_Sr = 60 * cs.milli
d_a_Sr = 2 * cs.milli
t1_Sr = 30
t2_Sr = 2 * cs.minute
t3_Sr = 5 * cs.minute
n_Sr = npf([1136, 665, 412, 273, 180, 110, 306, 208, 131, 76, 60, 42])
d_n_Sr = sqrt(n_Sr)
n_Sr = np.append(n_Sr[:6] / t1_Sr, n_Sr[6:] / t2_Sr)
d_n_Sr = np.append(d_n_Sr[:6] / t1_Sr, d_n_Sr[6:] / t2_Sr)
rh_m_air = 26.116e-3
rh_m_arg = 26.006e-3
rh_m_dsys = 0.002e-3
rh_2r_air = 15.95e-3
rh_2r_arg = 15.97e-3
rh_2r_dsys = 0.02e-3
rh_p = 994.15e2
rh_p_dsys = 0.15e2
k_air_lit = 0.78 * 1.401 + 0.21 * 1.398 + 0.01 * 1.648
k_arg_lit = 1.648
# Clément & Desormes
h1 = cd_h1r - cd_h1l
h3 = cd_h3r - cd_h3l
hi_dsys = sqrt(2) * cd_hix_dsys
cd_k = h1 / (h1 - h3)
cd_k_dsys = hi_dsys / (h1 - h3) * sqrt((1 + h1 / (h1 - h3))**2 +
(1 / (h1 - h3))**2)
cd_k_mv = mv(cd_k)
cd_k_dsto_mv = dsto_mv(cd_k)
cd_k_dsys_mv = dsys_mv(cd_k_dsys)
cd_k_dtot = sqrt(cd_k_dsto_mv**2 + cd_k_dsys_mv**2)
print()
print('Clément & Desormes:')
print()
print(tbl(['h1', 'h3', 'k'], [h1, h3, cd_k], [hi_dsys, hi_dsys, cd_k_dsys]))
print()
roh_w = 998.0 roh_w_dsys = 1.0 U_mot = 24.0 U_mot_dsys = 0.1 I_mot = 2.3 I_mot_dsys = 0.1 km_U_heiz = 5.58 km_U_heiz_dsys = 0.04 km_I_heiz = 1.14 * 5 km_I_heiz_dsys = 0.02 * 5 km_f = 325.2 / 60. km_f_dsys = 0.1 / 60. km_dT = 22.1 - 18.65 km_dT_dsys = sqrt(0.25**2 + 0.1**2) km_Vps = npfarray([199.5,198.4,200.7,200.1,200.5]) / 6e7 km_Vps_mv = mv(km_Vps) km_Vps_dsys = dsto_mv(km_Vps) gf_t = 180. gf_t_dsys = 15. gf_V = 1e-6 gf_V_dsys = 0.5e-6 gf_f = 306.5 / 60. gf_f_dsys = 0.1 / 60. wk_l = 0.250 wk_l_dsys = 0.005 wk_Vps = 199.0 / 6e7 wk_Vps_dsys = 1.5 / 6e7
# measure version 1.8.12s
from measure import plt, pltext, npfarray, linreg, sqrt, val, dev, exp, pi, spcurvefit, nplinspace, tbl
from numpy import loadtxt
from scipy.special import gamma
# Aufgabe 2
U = npfarray([420, 445, 470, 495, 520, 545, 570])
N = npfarray([1887, 2330, 2337, 2359, 2407, 2374, 2310])
N_dsto = sqrt(N)
pltext.initplot(num=1,
title='Abbildung : Zählrohrcharakteristik',
xlabel='Spannung in V',
ylabel='Ereignisse')
pltext.plotdata(U, N, N_dsto, label='Messwerte')
[slope, dslope] = linreg(U[1:],
N[1:],
N_dsto[1:],
plot=True,
prange=(410, 580))[0:2]
pltext.set_layout(xlim=(410, 580), ylim=(1800, 2500))
U0 = 510
print('\nAufgabe 2\n')
print(val(slope, dslope, name='Steigung'))
# Aufgabe 3
U = [510, 610]
N1min = npfarray([9838, 9871])
N1min_dsto = sqrt(N1min)
# Wellenlängen 1. Nebenserie
ns1 = [819e-9]
m = 3
Eryd = -13.605
E3p = Eryd / m**2 - h / e * c / ns1[0]
for m in range(4,13):
ns1.append(h / e * c / (Eryd * m**-2 - E3p))
print()
print(lst("Wellenlängen 1. Nebenserie", ns1, [0.3e-9 for i in range(len(ns1))]))
# Wellenlängen 2. Nebenserie
ns2 = 589e-9
E3s = E3p - h / e * c / ns2
sCorr = 3 - sqrt(Eryd / E3s)
ns2 = []
for m in range(5,10):
ns2.append(h / e * c / (Eryd * (m - sCorr)**-2 - E3p))
print()
print(lst("Wellenlängen 2. Nebenserie", ns2, [0.3e-9 for i in range(len(ns2))]))
# Hauptserie
pCorr = 3 - sqrt(Eryd / E3p)
hs = []
for m in range(4,6):
hs.append(h / e * c / (Eryd * (m - pCorr)**-2 - E3s))
fig=1,
scale='linlog')
dampingplot.plt.grid(False)
dampingplot.plotdata(t, f, df)
dampingplot.plotfunc(t, f0 * exp(-D * t), label='line of best fit')
dampingplot.plotfunc(t, (f0 + df0) * exp(-(D + dD) * t),
label='line of uncertanty')
print()
print(val('damping constant', D, dD))
print(val('half value time', t_hv, t_hv_dsys))
# moment of anertia Iz with precession
f_m1x15 = moa_umin_1x15 / 120. * (1. + exp(-D * moa_Tp_1x15))
df_m1x15 = 1. / 120. * sqrt((moa_dumin * (1. + exp(-D * moa_Tp_1x15)))**2 +
(moa_umin_1x15 * exp(-D * moa_Tp_1x15))**2 *
((D * moa_dTp)**2 + (dD * moa_Tp_1x15)**2))
f_m1x20 = moa_umin_1x20 / 120. * (1. + exp(-D * moa_Tp_1x20))
df_m1x20 = 1. / 120. * sqrt((moa_dumin * (1. + exp(-D * moa_Tp_1x20)))**2 +
(moa_umin_1x20 * exp(-D * moa_Tp_1x20))**2 *
((D * moa_dTp)**2 + (dD * moa_Tp_1x20)**2))
f_m2x15 = moa_umin_2x15 / 120. * (1. + exp(-D * moa_Tp_2x15))
df_m2x15 = 1. / 120. * sqrt((moa_dumin * (1. + exp(-D * moa_Tp_2x15)))**2 +
(moa_umin_2x15 * exp(-D * moa_Tp_2x15))**2 *
((D * moa_dTp)**2 + (dD * moa_Tp_2x15)**2))
f_m2x20 = moa_umin_2x20 / 120. * (1. + exp(-D * moa_Tp_2x20))
df_m2x20 = 1. / 120. * sqrt((moa_dumin * (1. + exp(-D * moa_Tp_2x20)))**2 +
(moa_umin_2x20 * exp(-D * moa_Tp_2x20))**2 *
((D * moa_dTp)**2 + (dD * moa_Tp_2x20)**2))
moaplot = plot(title='precession period as function of the rotation frequency',
def g_fit(f, V, Omg1, Omg2, n1, n2):
return V / sqrt((1 + (Omg1 / f)**(2 * n1)) * (1 + (f / Omg2)**(2 * n2)))
r' in Abhängigkeit des Widerstandes $R$', r'Frequenzgang des Messsystems.',
r'Differenz der Quadrate der effektiven Rauschspannung $U_N$ und der zusätzlichen Rauschspannung $U_V$ des Verstärkers'
'\n'
r'geteilt durch den Widerstand $R$ in Abhängigkeit der absoluten Temperatur $T$'
]
# Measurement of the noise voltage in dependency of the resistance
rd_V = 0.003
rd_R = 0.005 # maximal
# (1) Measurement of the noise voltage in dependency of the resistance
R1 = np.arange(5, 35, 5) * cs.kilo
d_R1 = rd_R * R1
n1 = fa([103, 196, 104, 104, 105, 106])
U1 = fa([2.4233, 3.1416, 3.7295, 4.238, 4.6961, 5.1225]) * cs.milli
d_U1 = fa([0.01, 0.0113, 0.0149, 0.0165, 0.0173, 0.0171]) * cs.milli / sqrt(n1)
d_U1 = sqrt(d_U1**2 + (rd_V * U1)**2)
T1 = 23.4 + cs.zero_Celsius
d_T1 = 0.1
# (2) Measurement of the inherent noise voltage of the multiplier
n2 = 104
U2 = 1.3698 * cs.milli
d_U2 = 0.00544 * cs.milli / sqrt(n2)
d_U2 = sqrt(d_U2**2 + (rd_V * U2)**2)
U2_diff = U1**2 - U2**2
d_U2_diff = sqrt((2 * U1 * d_U1)**2 + (2 * U2 * d_U2)**2)
ms.pltext.initplot(num=2,
title=titles[0],
# measure version 1.9.2s
from measure import plt, pltext, linreg, sqrt, val, sin, cos, h as h_lit, NA as NA_lit, c, e, deg_to_rad, rad_to_deg, dev, arcsin, spcurvefit, exp, pi, nplinspace, ln, tbl, lst, npfarray, mv, dtot_mv, loadtxt
# Aufgabe 1a
alpha, rate = loadtxt('data/255_1a.txt', unpack=True)
rate_err = sqrt(rate)
pltext.initplot(num=1,
title='Abbildung : Zählrate als Funktion des Winkels (LiF)',
xlabel='Winkel in deg',
ylabel='Zählrate in 1/s')
pltext.plotdata(alpha, rate, rate_err, label='Messwerte', connect=True)
pltext.set_layout(xlim=(2, 22.5), ylim=(-0.1e3, 1.6e3))
pltext.initplot(num=2,
title='Abbildung : Zählrate als Funktion des Winkels (LiF)',
xlabel='Winkel in deg',
ylabel='Zählrate in 1/s')
pltext.plotdata(alpha, rate, rate_err, label='Messwerte')
[slope, slope_err, yitc, yitc_err] = linreg(alpha[12:18],
rate[12:18],
rate_err[12:18],
plot=True,
prange=(4, 7))
pltext.set_layout(xlim=(4, 7), ylim=(-100, 400))
a1_uncorr = -yitc / slope * deg_to_rad
a1_uncorr_err = 1 / slope * sqrt(yitc_err**2 +
(yitc / slope * slope_err)**2) * deg_to_rad
Ug = mv(rate[0:12])
# measure version 1.8.6
from measure import plt, np, npfarray, sqrt, pltext, curve_fit, val, c, h, sig
Z = npfarray([26, 42, 29, 22, 47, 40, 30, 28])
# Literaturwerte
sqrt_Er_lit = sqrt(13.6e-3)
sig12_lit = 1
p0 = npfarray([sqrt_Er_lit, sig12_lit])
print()
print(val('Literaturwert sqrt(Er)', sqrt_Er_lit))
# K_alpha
K_alpha = npfarray([6.42, 17.47, 8.08, 4.49, 21.90, 15.79, 8.68, 7.51])
Delta_K_alpha = npfarray([0.16, 0.17, 0.15, 0.16, 0.20, 0.17, 0.16, 0.15])
sqrt_K_alpha = sqrt(K_alpha)
Delta_sqrt_K_alpha = 1 / 2 * 1 / sqrt(K_alpha) * Delta_K_alpha
pltext.initplot(num=1,
title=r'$\sqrt{E_\alpha}$ als Funktion von $Z$',
xlabel=r'$Z$',
ylabel=r'$\sqrt{E_\alpha}$ in $\sqrt{keV}$')
pltext.plotdata(x=Z, y=sqrt_K_alpha, dy=Delta_sqrt_K_alpha)
n1 = 1
n2 = 2
def fit_func_alpha(x, sqrt_Er, sig12):
return sqrt_Er * (x - sig12) * sqrt(1 / n1**2 - 1 / n2**2)
def gauss(x, A, mu, sig, Ug):
return A / (sqrt(2 * pi) * sig) * exp(-(x - mu)**2 / (2 * sig**2)) + Ug
def fit_func_beta(x, sqrt_Er, sig12):
return sqrt_Er * (x - sig12) * sqrt(1 / n1**2 - 1 / n2**2)
pltext.initplot(num=1,
title='Bewegung des Teilchens',
xlabel='x in m',
ylabel='y in m')
plt.plot(x, y, marker='s')
plt.savefig('fig1.pdf', format='pdf')
# mittleres Verschiebungsquadrat
r_sqr = dx**2 + dy**2
r_sqr_mv = mv(r_sqr)
r_sqr_dsto = dsto_mv(r_sqr)
dt_mv = mv(dt)
dt_dsto = dsto_mv(dt)
hist_D = r_sqr_mv / (4. * dt_mv)
hist_D_dtot = 1. / (4. * dt_mv) * sqrt(r_sqr_dsto**2 +
(r_sqr_mv * dt_dsto / dt_mv)**2)
hist_kB = 6. * pi * nu * r_k * hist_D / T_mv
hist_kB_dtot = 6. * pi / T_mv * sqrt((nu_dsys * r_k * hist_D)**2 +
(nu * r_k_dsys * hist_D)**2 +
(nu * r_k * hist_D_dtot)**2 +
(nu * r_k * hist_D * T_dtot / T_mv)**2)
print()
print('Mittelung:')
print(val('mittleres Verschiebungsquadrat', r_sqr_mv, r_sqr_dsto))
print(val('mittlerer Zeitabschnitt', dt_mv, dt_dsto))
print(val('Diffusionskonstante D', hist_D, hist_D_dtot))
print(val('Bolatzmannkonstante k', hist_kB, hist_kB_dtot))
# Histogramm
d_all = 1e6 * np.append(dx, dy)
# Measure series reduction
dT = ms.std_dev_m(T) / 20
T = ms.mean_value(T) / 20
dT1 = ms.std_dev_m(T1) / 15
T1 = ms.mean_value(T1) / 15
dT2 = ms.std_dev_m(T2) / 10
T2 = ms.mean_value(T2) / 10
print()
print(ms.val("T0", T, dT))
print(ms.val("T1", T1, dT1))
print(ms.val("T2", T2, dT2))
# Damping constant calculated with time of half amplitude
t1 = n1 * T1
dt1 = ms.sqrt((n1 * dT1)**2 + (T1 * dn1)**2)
t2 = n2 * T2
dt2 = ms.sqrt((n2 * dT2)**2 + (T2 * dn2)**2)
delta_ha1 = ms.ln(2) / t1
dDelta_ha1 = ms.ln(2) / t1**2 * dt1
delta_ha2 = ms.ln(2) / t2
dDelta_ha2 = ms.ln(2) / t2**2 * dt2
print()
print(ms.val("t1", t1, dt1))
print(ms.val("t2", t2, dt2))
print()
print(ms.val("detla_ha1", delta_ha1, dDelta_ha1))
print(ms.val("detla_ha2", delta_ha2, dDelta_ha2))
# Damping constant calculated with full width at half maximum
# measure version 1.8.4
from measure import npfarray, np, exp, sqrt, ln, mv, dsto_mv, dsys_mv, dtot, val, tbl, lst, T0, p0, plt, pltext, linreg, sig, curve_fit
# Messwerte
wl_sa = npfarray([-36, 0, 200, 404, 706]) * 1e-6
wl_sa_dsys = npfarray([10, 10, 10, 10, 10]) * 1e-6
wl_se = npfarray([2930, 2951, 3155, 3370, 3677]) * 1e-6
wl_se_dsys = npfarray([10, 10, 10, 10, 10]) * 1e-6
wl_m = npfarray([11165, 11136, 11134, 11163, 11170])
wl_m_dsys = npfarray([2, 2, 2, 2, 2])
wl_lit = 532e-9
wl_lit_dsys = 1e-9
bi_T = mv([23.3, 23.4]) + T0
bi_T_dtot = sqrt(2) * 0.1
bi_a = 50e-3
bi_a_dsys = 0.05e-3
bi_m1 = npfarray([0, 5, 10, 15, 20, 25, 30, 35])
bi_m2 = npfarray([0, 5, 10, 15, 20, 25, 30, 35])
bi_m3 = npfarray([0, 5, 10, 15, 20, 25, 30, 35])
bi_p1 = npfarray([540, 470, 395, 320, 245, 175, 100, 25]) * 101325 / 760
bi_p1_dsys = npfarray([5, 5, 5, 5, 5, 5, 5, 5]) * 101325 / 760
bi_p2 = npfarray([700, 625, 555, 480, 410, 340, 265, 190]) * 101325 / 760
bi_p2_dsys = npfarray([5, 5, 5, 5, 5, 5, 5, 5]) * 101325 / 760
bi_p3 = npfarray([630, 550, 485, 410, 335, 265, 190, 115]) * 101325 / 760
bi_p3_dsys = npfarray([5, 5, 5, 5, 5, 5, 5, 5]) * 101325 / 760
bi_n0_lit = 1.00028
kl_t = npfarray([
-2.9599994e-02, -2.9399995e-02, -2.9199995e-02, -2.8999995e-02,
-2.8799992e-02, -2.8599992e-02, -2.8399993e-02, -2.8199993e-02,
# measure version 1.8.4
from measure import plt, pltext, np, npfarray, linreg, sqrt, val, curve_fit
laser = 635e-9
schirmabstand = 1
# Eichung
links = npfarray([554.48, 584.99, 616.35, 644.31, 677.36])
rechts = npfarray([446.01, 413.80, 383.30, 355.33, 322.28])
diff = links - rechts
diff_err = sqrt(2) * 3 * diff / diff
sbreite = 2e-3 / 100 * npfarray([43, 70, 90, 104, 132])
sbreite_err = 1e-3 / 100 * sbreite / sbreite
pltext.initplot(num=0, title='Eichung', xlabel='Pixel', ylabel='Meter')
[mpp, dmpp, itc, ditc] = linreg(x=diff,
y=sbreite,
dx=diff_err,
dy=sbreite_err,
plot=True)
print()
print(val('Meter pro Pixel', mpp, dmpp))
# Einzelspaltbreite
lage_es_hmax = 499.79
lage_es_min = (npfarray([529.91, 561.26, 590.92, 623.13, 653.63]) -
lage_es_hmax) * mpp
lage_es_max = (lage_es_hmax -
npfarray([456.82, 424.68, 394.69, 363.78, 333.80])) * mpp
lage_es_d = npfarray([3, 3, 3, 3, 3]) * mpp
n_es = npfarray([1, 2, 3, 4, 5])
U1g = npfarray([-0.2,-0.15,-0.10,-0.05,0.04,0.08,0.12,0.18]) U1g_dsys = npfarray([3,1,1,1,1,1,1,1])*1e-3 Uag_48k7 = npfarray([3.32,2.60,1.80,1.00,-0.4,-1.0,-1.7,-2.7]) Uag_48k7_dsys = npfarray([50,10,10,10,1,10,100,100])*1e-3 Uag_274k = npfarray([14.6,14.4,9.6,5.0,-3.2,-6.90,-10.8,-12.8]) Uag_274k_dsys = npfarray([0.1,0.1,0.01,0.01,0.01,0.1,0.1,0.1]) U1w = npfarray([1.0,0.852,0.748,0.500,0.300,0.150]) / 10 U1w_dsys = npfarray([10,5,5,5,5,3])*1e-3 / 10 Uaw_274k = npfarray([8.76,7.48,6.46,4.38,2.61,1.28]) Uaw_274k_dsys = npfarray([0.05,0.05,0.03,0.03,0.02,0.02]) Uaw_680k = npfarray([21.9,18.7,16.1,10.8,6.52,3.25]) Uaw_680k_dsys = npfarray([0.1,0.1,0.1,0.1,0.05,0.02]) V_eg_48k7 = -1 * Uag_48k7 / U1g V_eg_48k7_dsys = 1/abs(U1g) * sqrt(Uag_48k7_dsys**2 + (Uag_48k7 * U1g_dsys / U1g)**2) V_eg_48k7_mv = mv(V_eg_48k7) V_eg_48k7_mv_dtot = dtot_mv(V_eg_48k7,V_eg_48k7_dsys) V_eg_274k = -1 * Uag_274k / U1g V_eg_274k_dsys = 1/abs(U1g) * sqrt(Uag_274k_dsys**2 + (Uag_274k * U1g_dsys / U1g)**2) V_eg_274k_mv = mv(V_eg_274k) V_eg_274k_mv_dtot = dtot_mv(V_eg_274k,V_eg_274k_dsys) V_ew_274k = Uaw_274k / U1w V_ew_274k_dsys = 1/U1w * sqrt(Uaw_274k_dsys**2 + (Uaw_274k * U1w_dsys / U1w)**2) V_ew_274k_mv = mv(V_ew_274k) V_ew_274k_mv_dtot = dtot_mv(V_ew_274k,V_ew_274k_dsys) V_ew_680k = Uaw_680k / U1w V_ew_680k_dsys = 1/U1w * sqrt(Uaw_680k_dsys**2 + (Uaw_680k * U1w_dsys / U1w)**2)
# measure version 1.9s
from measure import mv, dsto_mv, val, sqrt, pltext, plt, exp, spcurvefit, tbl, expreg, ln, dev, chi2stat, nplinspace
from numpy import loadtxt, arange
# Untergrund
unterg = loadtxt('data/252_untergrund.dat', usecols=[1])
# Silber
n1 = loadtxt('data/252_n1.dat', usecols=[1])
n2 = loadtxt('data/252_n2.dat', usecols=[1])
n3 = loadtxt('data/252_n3.dat', usecols=[1])
n4 = loadtxt('data/252_n4.dat', usecols=[1])
N_ag = n1 + n2 + n3 + n4
N_ag_err = sqrt(N_ag)
t = arange(5, 405, 10)
unterg_ag_mv = mv(4 * unterg)
unterg_ag_mv_dsto = dsto_mv(4 * unterg, ddof=0)
def fitfunc(x, A1, l1, A2, l2):
return A1 * exp(-l1 * x) + A2 * exp(-l2 * x) + unterg_ag_mv
def fitfunc_pf(x, A1, l1, A2, l2):
return A1 * exp(-l1 * x) + A2 * exp(
-l2 * x) + unterg_ag_mv + unterg_ag_mv_dsto
def fitfunc_mf(x, A1, l1, A2, l2):
# Measurement series reduction
dT1 = ms.std_dev_m(T1) / 20
T1 = ms.mean_value(T1) / 20
dT2 = ms.std_dev_m(T2) / 20
T2 = ms.mean_value(T2) / 20
dT = [ms.std_dev_m(T[i]) / 20 for i in range(len(T))]
T = [ms.mean_value(T[i]) / 20 for i in range(len(T))]
# 1.1 Determination of the deflecting force by torque-deflection angle-dependency measurement
M = []
dM = []
for i in range(len(m)):
M.append(m[i] * g * r)
dM.append(
ms.sqrt((m[i] * g * dr)**2 + (m[i] * r * dg)**2 + (g * r * dm[i])**2))
Dt = ms.reg_grad(phi, M, dPhi, dM) * 180.0 / ms.pi
dDt = ms.reg_grad_err(phi, M, dPhi, dM) * 180.0 / ms.pi
#ms.ple("torque", M, dM)
#ms.pve("deflection force", Dt, dDt)
#ms.ps("linreg vs graph", 0.0217, 0.0004, Dt, dDt)
# 1.2 Deflecting force determination by period time measurement
Jd = md / 2.0 * rd**2
dJd = rd * ms.sqrt((0.5 * rd * dmd)**2 + (md * drd)**2)
Dp = 4.0 * ms.pi**2 * Jd / (T2**2 - T1**2)
dDp = 4.0 * ms.pi**2 / (T2**2 - T1**2) * ms.sqrt(dJd**2 +
((2.0 * Jd * T1 * dT1)**2 +
# (1) Determination of the response time of a RC-element
C1 = npfarray([470, 4.7, 47]) * cs.nano
d_C1 = 0.10 * C1
R1 = npfarray([1, 10, 1]) * cs.kilo
d_R1 = 0.05 * R1
T1_12 = npfarray([0.32, 0.04, 0.04]) * cs.milli
d_T1_12 = npfarray([0.03, 0.01, 0.01]) * cs.milli
f1 = npfarray([110, 600, 600])
U1_pp = npfarray([0.95, 0.95, 0.95])
d_U1_pp = npfarray([0.02, 0.02, 0.02])
tau1_O = T1_12 / ln(2)
d_tau1_O = d_T1_12 / ln(2)
tau1_T = R1 * C1
d_tau1_T = tau1_T * sqrt((d_R1 / R1)**2 + (d_C1 / C1)**2)
print()
print('1. Determination of the response time of a RC-element:')
print(ms.tbl([ms.lst(C1, d_C1, name='C', unit='F'),
ms.lst(R1, d_R1, name='R', unit='Ω'),
ms.lst(tau1_O, d_tau1_O, name='τ', unit='s'),
ms.lst(tau1_T, d_tau1_T, name='τ', unit='s'), ms.dev(tau1_O, d_tau1_O, tau1_T, d_tau1_T, name='τ')]))
# (3) Frequency and phase of a RC-element
R3 = cs.kilo
d_R3 = 0.05 * R3
C3 = 47 * cs.nano
d_C3 = 0.10 * C3
f3_G_low = 3.0 * cs.kilo
d_f3_G_low = 0.3 * cs.kilo
# measure version 1.9.1s
from measure import npfarray, pltext, plt, sqrt, expreg, val, linreg, tbl, lst, exp, mv, dtot_mv
# Aufgabe 2
ug_5min = 120
ug_5min_err = sqrt(ug_5min)
ug_1s = ug_5min / (5 * 60)
ug_1s_err = ug_5min_err / (5 * 60)
print('\nAufgabe 2:\n')
print(val(ug_1s, ug_1s_err, name='Untergrund / s'))
# Aufgabe 3
t = npfarray(
[30, 30, 30, 30, 30, 30, 30, 60, 120, 120, 120, 120, 120, 120, 300])
d = npfarray(
[0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4, 2.7, 3.0, 3.3, 3.6, 3.9, 4.9])
N = npfarray(
[1196, 677, 449, 289, 189, 143, 78, 86, 123, 91, 61, 68, 65, 42, 131])
N_err = sqrt(N)
N_t_ratio = N / t - ug_1s
N_t_ratio_err = sqrt((N_err / t)**2 + ug_1s_err**2)
pltext.initplot(num=1,
title=r'Abbildung : Absoprtion $\beta$-Strahlung',
xlabel='Dicke in mm',
ylabel='Ereignisse pro Sekunde',
scale='linlog')
pltext.plotdata(d, N_t_ratio, N_t_ratio_err, label='Messwerte')
pltext.set_layout(xlim=(-0.2, 5.2), ylim=(1e-2, 6e1))
t = 982.89
n = 500
s = [8e-3, 16e-3, 21e-3, 26e-3, 34e-3, 38e-3, 42e-3, 48e-3, 50e-3, 54e-3, 58e-3, 60e-3, 64e-3, 67e-3, 70e-3, 73e-3, 76e-3, 78e-3, 81e-3, 84e-3, 85e-3]
ds = [3e-3 for i in range(len(s))]
sn = 119e-3
dsn = 1e-3
sa = 852e-3
dsa = 3e-3
# Preparation
lp = [lpo[i] - lpu[i] for i in range(len(lpo))]
dlp = ms.std_dev_m(lp) # "+" ms.sqrt(2) * dlp # If one uses the addition of the systematic and statistic uncertainty, it must be quadratic
lp = ms.mean_value(lp)
l = lp - rk
dl = ms.sqrt(dlp**2 + drk**2)
dt = ms.std_dev_e(t0)
T0 = ms.mean_value(t0) / n0
n1 = 2 * l * dt / (0.3 * T0 * dl)
print()
print(ms.val("n1", int(n1 + 0.5)))
print()
print(ms.val("gl", gl, dgl))
# Simple calculation
T = t / n
dT = dt / n
gs = 4 * ms.pi**2 * l / T**2
dgs = 4 * ms.pi**2 / T**2 * ms.sqrt(dl**2 + (2 * l * dT / T)**2)
print()
def gauss(x, mu, sigma, A): return A / sqrt(2 * pi * sigma**2) * exp(-(x - mu)**2 / (2 * sigma**2))
def fitfunc(f, V, W1, W2, n1, n2):
return V / (np.sqrt(1 + 1 /
(f / W1)**(2 * n1)) * np.sqrt(1 + (f / W2)**(2 * n2)))
V = 1000
W1 = 1000
W2 = 50000
n1 = 5
n2 = 5
p0 = (V, W1, W2, n1, n2)
popt, pcov = curve_fit(fitfunc, f[15:-43], g[15:-43], p0)
print()
print(val(popt[0], sqrt(pcov[0][0]), 'V'))
print(val(popt[1], sqrt(pcov[1][1]), 'W1'))
print(val(popt[2], sqrt(pcov[2][2]), 'W2'))
print(val(popt[3], sqrt(pcov[3][3]), 'n1'))
print(val(popt[4], sqrt(pcov[4][4]), 'n2'))
pltext.initplot(num=2,
title='Abbildung : Frequenzgang (Fit)',
xlabel='Frequenz in Hz',
ylabel='g(f)',
scale='loglog')
pltext.plotdata(f[17:-45], g[17:-45], label='Messwerte')
f_array = nplinspace(4e2, 1.2e5)
plt.plot(f_array, fitfunc(f_array, *popt), label='Fit')
pltext.set_layout(legend=True, xlim=(4e2, 1.2e5), ylim=(1e1, 2e3))
