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))