def g2_fit_partial4(f, V, Omg1, Omg2, n1, n2):
return -(2 * V**2 * ln(Omg1 / f) *
(Omg1 / f)**(2 * n1)) / (((Omg1 / f)**(4 * n1) + 2 *
(Omg1 / f)**(2 * n1) + 1) *
(f / Omg2)**(2 * n2) +
(Omg1 / f)**(4 * n1) + 2 *
(Omg1 / f)**(2 * n1) + 1)
ms.pltext.set_axis(3)
[mu4_p1, sigma4_p1, A4_p1], [d_mu4_p1, d_sigma4_p1, d_A4_p1] = ms.fit(beta4_p1, n4_p1, d_n4_p1, gauss, p0=[20.7, 0.15, 100], plot=True, fit_range=range(4, 9))
ld1_p1 = 2 * d_LiF * sin(mu1_p1 * cs.degree)
d_ld1_p1 = 2 * d_LiF * cos(mu1_p1 * cs.degree) * sigma1_p1 * cs.degree
ld2_p1 = 2 * d_LiF * sin(mu2_p1 * cs.degree)
d_ld2_p1 = 2 * d_LiF * cos(mu2_p1 * cs.degree) * sigma2_p1 * cs.degree
ld3_p1 = d_LiF * sin(mu3_p1 * cs.degree)
d_ld3_p1 = d_LiF * cos(mu3_p1 * cs.degree) * sigma3_p1 * cs.degree
ld4_p1 = d_LiF * sin(mu4_p1 * cs.degree)
d_ld4_p1 = d_LiF * cos(mu4_p1 * cs.degree) * sigma4_p1 * cs.degree
print(ms.val("β1", mu1_p1, sigma1_p1, unit='°', prefix=False))
print(ms.val("β2", mu2_p1, sigma2_p1, unit='°', prefix=False))
print(ms.val("β3", mu3_p1, sigma3_p1, unit='°', prefix=False))
print(ms.val("β4", mu4_p1, sigma4_p1, unit='°', prefix=False))
print(ms.val("Δβ_2", 2 * sqrt(2 * ln(2)) * sigma2_p1, 2 * sqrt(2 * ln(2)) * d_sigma2_p1, unit='°', prefix=False))
print()
print(ms.val("λ1", ld1_p1, d_ld1_p1, unit='m'))
print(ms.val("λ2", ld2_p1, d_ld2_p1, unit='m'))
print(ms.val("λ3", ld3_p1, d_ld3_p1, unit='m'))
print(ms.val("λ4", ld4_p1, d_ld4_p1, unit='m'))
print()
print(ms.sig("λ_α1,l", ld2_p1, d_ld2_p1, 71.1e-12, perc=True))
print(ms.sig("λ_α2,l", ld4_p1, d_ld4_p1, 71.1e-12, perc=True))
print(ms.sig("λ_β1,l", ld1_p1, d_ld1_p1, 63.1e-12, perc=True))
print(ms.sig("λ_β2,l", ld3_p1, d_ld3_p1, 63.1e-12, perc=True))
print(ms.sig("λ_α", ld2_p1, d_ld2_p1, ld4_p1, d_ld4_p1, perc=True))
print(ms.sig("λ_β", ld1_p1, d_ld1_p1, ld3_p1, d_ld3_p1, perc=True))
print()
# Counting rate - Voltage dependency Measurement
if abs(kl_U[n]) >= np.max([abs(kl_U[j]) for j in range(n, len(kl_U))]):
U_top.append(abs(kl_U[n]))
t_top.append(kl_t[n])
def gauss(x, A, mu, sigma):
return A * exp(-(x - mu)**2 / (2. * sigma**2))
popt, pcov = curve_fit(gauss, t_top, U_top)
sigma = popt[2]
sigma_dtot = sqrt(pcov[2][2])
t_int = npfarray([0.1e-2 * n for n in range(-30, 91)])
pltext.initplot(num=2,
title='Signalverlauf LED',
xlabel='Zeit in s',
ylabel='Spannung in V')
plt.plot(kl_t, kl_U, label='Messwerte')
plt.plot(t_int, gauss(t_int, popt[0], popt[1], popt[2]), label='Gaußfit')
L = 2. * kl_v * sigma * 2. * sqrt(2. * ln(2.))
L_dtot = 2. * kl_v * sigma_dtot * 2. * sqrt(2. * ln(2.))
print()
print('Kohärenzlänge LED:')
print(val('sigma', sigma, sigma_dtot))
print(val('L', L, L_dtot))
plt.show()
d_n_CoA = sqrt((d_n_CoA / t_CoA)**2 + d_n0**2) / eps_CoA
print("Activity of γ-Radiation:")
print(ms.tbl([ms.lst(n_CoA, d_n_CoA, name='n', unit='1/s', prefix=False)]))
mu_abs_CoA = mu_rho_Co * rho_abs_CoA
d_mu_abs_CoA = d_mu_rho_Co * rho_abs_CoA
A_CoA = 4 * n_CoA * a_CoA**2 / r_c**2
d_A_CoA = A_CoA * sqrt((d_n_CoA / n_CoA)**2 + (2 * d_a_CoA / a_CoA)**2)
A1_CoA = 4 * n_CoA * (a_CoA + l_c / 2)**2 / r_c**2
d_A1_CoA = A1_CoA * sqrt((d_n_CoA / n_CoA)**2 + (2 * d_a_CoA /
(a_CoA + l_c / 2))**2)
A2_CoA = A1_CoA * exp(-mu_abs_CoA * d_abs_CoA)
d_A2_CoA = A2_CoA * sqrt((d_A1_CoA / A1_CoA)**2 +
(d_abs_CoA * d_mu_abs_CoA)**2)
A_l_CoA = A_N_CoA * exp(-ln(2) * T_CoA / T_H_CoA)
k1_CoA = A1_CoA / A_CoA
k2_CoA = A2_CoA / A1_CoA
print(
ms.tbl([
ms.lst(A_CoA, d_A_CoA, name='A', unit='Bq'),
ms.lst(A1_CoA, d_A1_CoA, name='A1', unit='Bq'),
ms.lst(A2_CoA, d_A2_CoA, name='A2', unit='Bq')
]))
print(ms.tbl([ms.lst(k1_CoA, name='k1'), ms.lst(k2_CoA, name='k2')]))
print(ms.val("T", T_CoA / cs.year, unit='yr'))
print(ms.val("A", A_l_CoA, unit='Bq'))
print(
ms.tbl([
# 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))
]
rate_2o_err = sqrt(rate_2o)
def gauss(x, A, mu, sig, Ug):
return A / (sqrt(2 * pi) * sig) * exp(-(x - mu)**2 / (2 * sig**2)) + Ug
l_kb_lit = 63.1e-12
l_ka_lit = 71.1e-12
p_opt_kb1o, p_err_kb1o = spcurvefit(gauss, alpha_1o[5:14], rate_1o[5:14],
rate_1o_err[5:14], [100, 9, 0.1, 300])
p_opt_ka1o, p_err_ka1o = spcurvefit(gauss, alpha_1o[-15:-5], rate_1o[-15:-5],
rate_1o_err[-15:-5], [400, 10, 0.1, 200])
fwhm_kb1o = 2 * sqrt(2 * ln(2)) * p_opt_kb1o[2]
fwhm_kb1o_err = 2 * sqrt(2 * ln(2)) * p_err_kb1o[2]
fwhm_ka1o = 2 * sqrt(2 * ln(2)) * p_opt_ka1o[2]
fwhm_ka1o_err = 2 * sqrt(2 * ln(2)) * p_err_ka1o[2]
l_kb1o = 2 * d * sin(p_opt_kb1o[1] * deg_to_rad)
l_kb1o_err = 2 * d * cos(
p_opt_kb1o[1] * deg_to_rad) * p_err_kb1o[1] * deg_to_rad
l_ka1o = 2 * d * sin(p_opt_ka1o[1] * deg_to_rad)
l_ka1o_err = 2 * d * cos(
p_opt_ka1o[1] * deg_to_rad) * p_err_ka1o[1] * deg_to_rad
p_opt_kb2o, p_err_kb2o = spcurvefit(gauss, alpha_2o[2:15], rate_2o[2:15],
rate_2o_err[2:15], [20, 18.3, 0.1, 60])
p_opt_ka2o, p_err_ka2o = spcurvefit(gauss, alpha_2o[-15:-3], rate_2o[-15:-3],
rate_2o_err[-15:-3], [60, 20.7, 0.1, 50])
# Complex calculation mk = rhoe * 4 / 3 * ms.pi * rk**3 dmk = rhoe * 4 * ms.pi * rk**2 * drk # Wrong uncertainty calculation mf = rhoe * ms.pi * rf**2 * (lp - 2 * rk) dmf = rhoe * ms.pi * rf**2 * ms.sqrt(dlp**2 + 4 * drk**2) ts = [50 * T * i for i in range(len(s))] dts = [50 * i * dT for i in range(len(ts))] # Wrong uncertainty calculation s = [sn - s[i] for i in range(len(s))] ds = [ms.sqrt(dsn**2 + ds[i]**2) for i in range(len(ds))] phi = [ms.arctan(s[i] / sa) for i in range(len(s))] dphi = [1 / (s[i]**2 + sa**2) * ms.sqrt((s[i] * dsa)**2 + (sa * ds[i])**2) for i in range(len(s))] phi0 = ms.mean_value(phi) dphi0 = ms.std_dev_m(phi) # I do not think one should calculate the uncertainty like that, because the deviation of the values is naturally very high lnphi = [ms.ln(phi[i]) for i in range(len(s))] dlnphi = [abs(dphi[i] / phi[i]) for i in range(len(s))] # The uncertainty here is just to be calculated with gaussian uncertainty propagation [delta, dDelta, tmp, tmp] = ms.linreg(ts, lnphi, dlnphi, dts) delta *= -1 ms.plot_linreg(ts, lnphi, dlnphi, dts) omega0 = 2 * ms.pi / T dOmega0 = 2 * ms.pi / T**2 * dT rhol = pl / pln * rholn drhol = dpl / pln * rholn drhol = ms.sqrt(drhol**2 + ((25.0 + 273.15) / (20.0 + 273.15) * rhol - rhol)**2) gc = 4 * ms.pi**2 * l / T**2 * (1 + 2 / 5 * (rk / l)**2 + rhol / rhoe - mf / (6 * mk) + (delta / omega0)**2 + phi0**2 / 8) dgc = 4.0 * ms.pi**2 * l / T**2 * ms.sqrt((1.0 + 2.0 / 5.0 * (rk / l)**2 + rhol / rhoe - mf / (6.0 * mk) + (delta / omega0)**2 + phi0**2 / 8.0)**2 * ((dl / l)**2 + (2.0 * dT / T)**2) + (4.0 / 5.0 * (rk / l)**2)**2 * ((drk / rk)**2 + (dl / l)**2)
titles = [
r'Phasenverschiebung $\varphi$ eines Hochpassfilters ($C = 47$ nF, $R = 1$ k$\Omega$) in Abhängigkeit der Frequenz $f$.'
]
# (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
t,
N_ag,
p0=[500, 0.02, 50, 0.001],
yerr=N_ag_err)
p_opt_pf, p_err_pf = spcurvefit(fitfunc_pf,
t,
N_ag,
p0=[500, 0.02, 50, 0.001],
yerr=N_ag_err)
p_opt_mf, p_err_mf = spcurvefit(fitfunc_mf,
t,
N_ag,
p0=[500, 0.02, 50, 0.001],
yerr=N_ag_err)
Thalb_Ag110 = ln(2) / p_opt[1]
Thalb_Ag110_dsys = ln(2) * p_err[1] / p_opt[1]**2
Thalb_Ag108 = ln(2) / p_opt[3]
Thalb_Ag108_dsys = ln(2) * p_err[3] / p_opt[3]**2
Thalb_Ag110_lit = 24.6
Thalb_Ag108_lit = 2.41 * 60
chi2_ = chi2stat.chi2(N_ag, N_ag_err, fitfunc(t, *p_opt))
chi2_red = chi2stat.chi2_red(chi2_, len(N_ag), ddof=4)
prob = chi2stat.fit_prob(chi2_, len(N_ag), ddof=4)
chi2_pf = chi2stat.chi2(N_ag, N_ag_err, fitfunc_pf(t, *p_opt_pf))
chi2_red_pf = chi2stat.chi2_red(chi2_pf, len(N_ag), ddof=4)
prob_pf = chi2stat.fit_prob(chi2_pf, len(N_ag), ddof=4)
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
wl1 = 2 * ms.pi * fl1 / fg
dwl1 = 2 * ms.pi * dfl1 / fg
wr1 = 2 * ms.pi * fr1 / fg
cf_10u = np.array([17, 16, 20, 22, 23, 25, 29, 20, 17, 15], dtype='float')
cf_d10u = np.array([1 for i in range(10)], dtype='float')
nut_umin_n = np.array([670, 1025, 570, 300, 420, 475, 655, 720, 380, 330],
dtype='float')
nut_dumin_n = np.array([10, 25, 10, 10, 10, 10, 10, 10, 10, 10], dtype='float')
nut_umin_f = np.array([720, 1120, 620, 320, 450, 520, 710, 770, 410, 360],
dtype='float')
nut_dumin_f = np.array([10, 25, 10, 10, 10, 10, 10, 10, 10, 10], dtype='float')
# damping
f = damping_umin / 60.
df = damping_dumin / 60.
t = damping_t
[slope, dslope, yitc, dyitc] = linreg(x=t, y=ln(f), dy=df / f)
D = -1. * slope
dD = dslope
f0 = exp(yitc)
df0 = exp(yitc) * dyitc
t_hv = ln(2.) / D
t_hv_dsys = ln(2.) * dD / D**2
dampingplot = plot(title='Linear regression of the damping constant',
xlabel='t / s',
ylabel='f / Hz',
fig=1,
scale='linlog')
dampingplot.plt.grid(False)
dampingplot.plotdata(t, f, df)
N_Ag = N_Ag / (4 * ΔT_Ag)
N_Ag = N_Ag - n0_m
d_N_Ag = sqrt(d_N_Ag**2 + d_n0_m**2)
cut = 0
for i in range(len(N_Ag)):
if N_Ag[i] / d_N_Ag[i] < 3.0:
cut = i
break
[A1_Ag, λ1_Ag, A2_Ag,
λ2_Ag], pcov = curve_fit(f_Ag,
t_Ag[:cut],
N_Ag[:cut],
sigma=d_N_Ag[:cut],
p0=[30,
ln(2) / 24.6, 5,
ln(2) / (2.41 * cs.minute)])
[d_A1_Ag, d_λ1_Ag, d_A2_Ag, d_λ2_Ag] = sqrt(np.diag(pcov))
t_Ag_fit = np.linspace(t_Ag[0], t_Ag[-1], 1000)
N_Ag_fit = f_Ag(t_Ag_fit, A1_Ag, λ1_Ag, A2_Ag, λ2_Ag)
ms.pltext.initplot(
num=1,
title=
r'Mittelwert der Zerfallsrate $A$ aus 4 Messungen von $^{108}$Ag und $^{110}$Ag zu der Zeit $t$',
xlabel=r'$t$ / s',
ylabel=r'$A$ / Bq',
fignum=True)
ms.pltext.plotdata(t_Ag, N_Ag, d_N_Ag, color='gray')
ms.plt.plot(t_Ag_fit, N_Ag_fit)
