def plot_caesium_absorber():
depth, events, slabs = np.loadtxt("data/caesium_bleiabschirmung.txt",
unpack=True)
error_depth = np.sqrt(slabs) * 0.1
error_events = np.sqrt(events + 1)
plt.clf()
plt.minorticks_on()
plt.errorbar(depth, events, xerr=error_depth, yerr=error_events, fmt=',')
plt.xlabel("Tiefe / mm")
plt.ylabel("ln(Anzahl)")
plt.savefig("out/caesium_absorber_nolog." + SAVETYPE)
ln_events = np.log(events)
error_ln_events = np.abs(1 / events) * error_events
depth /= 10 # mm=>cm
error_depth /= 10
plt.clf()
plt.minorticks_on()
func = lambda x, mu, lnI0: -x * mu + lnI0
fit = Fit(func)
fit.set_data(xdata=depth,
ydata=ln_events,
xerrors=error_depth,
yerrors=error_ln_events)
fit.set_labels(xlabel="Tiefe / cm", ylabel="ln(Anzahl)")
fit.iterative_fit(5)
fit.plot(box="tr", units={"mu": "1/cm"})
plt.savefig("out/caesium_absorber_fit." + SAVETYPE)
plt.clf()
plt.minorticks_on()
fit.plot_residual(box="tr")
plt.savefig("out/caesium_absorber_residual." + SAVETYPE)
plt.clf()
plt.minorticks_on()
fit = fit.filtered(depth <= 2)
fit.iterative_fit(5)
fit.plot(box="tr", units={"mu": "1/cm"})
plt.savefig("out/caesium_absorber_fit2." + SAVETYPE)
plt.clf()
plt.minorticks_on()
fit.plot_residual(box="tr")
plt.savefig("out/caesium_absorber_residual2." + SAVETYPE)
mu = fit.uvalue("mu")
print("Absorptionskoeffizient:", mu, "1/cm")
mu1 = mu / ufloat(11.342, 0.001)
print("Massenabsorptionskoeffizient:", mu1, "cm^2/g")
def plot_yag_lifetime():
time, voltage = _load_oscilloscope_csv("data/ALL0010/F0010CH2.CSV")
time *= 1E6 # us
voltage *= 1000 # mV
error_voltage = voltage[time < 0].std()
print("Fehler:", error_voltage, "mV")
fit = Fit(EXPONENTIAL_DECAY)
fit.set_data(xdata=time, ydata=voltage, yerrors=error_voltage)
fit.set_labels(xlabel="Zeit / us", ylabel="Spannung / mV")
fit = fit.filtered(np.logical_and(time > 0, time < 1500))
fit.set_params(A=0.1, offset=0.20, T=250)
fit.iterative_fit(1)
print("Lebensdauer:", formatUFloat(fit.uvalue("T"), "us"), "- Chi^2:",
fit.chi2, "- ndf:", fit.ndf, "- Chi^2/ndf:", fit.chi2ndf)
plt.clf()
fit.plot(box="tr", units={"T": "us", "A": "mV", "offset": "mV"})
plt.savefig("out/yag_lifetime." + SAVETYPE)
def plot_strontium():
m = {
0: 0,
5: 0.03,
6: 0.04,
7: 0.05,
8: 0.08,
9: 0.10,
10: 0.17,
11: 0.25,
12: 0.37,
13: 0.50,
14: 0.64,
15: 0.83,
16: 1.01,
17: 1.23,
18: 1.39,
19: 1.57,
20: 1.88,
21: 2.29,
22: 2.79,
23: 3.46,
}
nr, count = np.loadtxt("data/strontium_alu.txt", unpack=True)
absorb = np.zeros_like(nr)
for i, x in enumerate(nr):
absorb[i] = m[x] / 10
scale = 1 / count[0]
error_count = np.sqrt(count + 1)
error_absorb = 0.01 / 10
count *= scale
error_count *= scale
func = lambda x, A, mu, offset: A * np.exp(-x * mu) + offset
fit = Fit(func)
fit.set_data(xdata=absorb,
ydata=count,
xerrors=error_absorb,
yerrors=error_count)
fit.set_params(A=1, mu=1, offset=0)
fit.set_labels(xlabel="Dicke / cm", ylabel="Anteil")
fit.iterative_fit(5)
plt.clf()
plt.minorticks_on()
plt.xlim(0, .35)
fit.plot(box="tr", units={"mu": "1/cm"})
plt.savefig("out/strontium_fit." + SAVETYPE)
plt.clf()
plt.minorticks_on()
fit.plot_residual(box="tr")
plt.savefig("out/strontium_residual." + SAVETYPE)
rho = ufloat(2.7, 0.1)
mu = fit.uvalue("mu")
print("Absorptionskoeffizient:", mu, "1/cm")
mu1 = mu / rho
print("Massenabsorptionskoeffizient:", mu1, "cm^2/g")
E = umath.pow(17 / mu1, 1 / 1.14)
print("Maximalenergie:", E, "MeV")
R1 = 0.412 * umath.pow(E, 1.265 - 0.0954 * umath.log(E))
R = R1 / rho
print("Reichweite:", R1, "g/cm^2")
print("Reichweite:", R, "cm")
def plot_ionisation_raw():
distances, voltages, error_voltages = np.loadtxt(
"data/radium_ionisationskammer.txt", unpack=True)
# discard 38.80cm
distances = distances[:-1]
voltages = voltages[:-1]
error_voltages = error_voltages[:-1]
for distance, voltage, error_voltage in zip(distances, voltages,
error_voltages):
distance = ufloat(distance, 0.05)
voltage = ufloat(voltage, error_voltage)
print("$({:L}) \\unit{{cm}}$ & $({:L}) \\unit{{mV}}$ \\\\".format(
distance, voltage))
plt.clf()
plt.minorticks_on()
plt.errorbar(distances, voltages, xerr=0.05, yerr=error_voltages, fmt=',')
plt.xlabel("Distanz / cm")
plt.ylabel("Spannung / mV")
plt.savefig("out/radium_ionisation_raw." + SAVETYPE)
plt.clf()
plt.minorticks_on()
currents = []
error_currents = []
for voltage, error_voltage in zip(voltages, error_voltages):
current = ufloat(voltage, error_voltage) #+ ufloat(5, 3)
currents.append(current.n)
error_currents.append(current.s)
currents = np.array(currents)
error_currents = np.array(error_currents)
distances -= 39
plt.clf()
plt.minorticks_on()
plt.errorbar(distances, currents, xerr=0.05, yerr=error_currents, fmt=',')
plt.xlabel("Distanz / cm")
plt.ylabel("Strom / nA")
plt.savefig("out/radium_ionisation." + SAVETYPE)
plt.clf()
plt.minorticks_on()
x = distances[1:] + np.abs(np.diff(distances) / 2)
y = -np.diff(currents) / np.diff(distances)
plt.plot(x, y, 's-')
plt.xlabel("Distanz / cm")
plt.ylabel("- Änderung des Stromes / nA / cm")
plt.savefig("out/radium_ionisation_diff." + SAVETYPE)
plt.clf()
plt.minorticks_on()
fit = Fit(LINEAR)
fit.set_data(xdata=(7.42, 6.92, 6.42),
ydata=currents[9:12],
xerrors=0.25,
yerrors=error_currents[9:12])
fit.set_labels(xlabel="Distanz / cm", ylabel="Strom / nA")
fit.iterative_fit(5)
fit.plot(box="tr", units={"slope": "nA/cm", "offset": "nA"})
plt.savefig("out/radium_ionisation_po_fit." + SAVETYPE)
plt.clf()
plt.minorticks_on()
fit.plot_residual(box="tl")
plt.savefig("out/radium_ionisation_po_residual." + SAVETYPE)
middle = (ufloat(currents[9], error_currents[9]) +
ufloat(currents[11], error_currents[11])) / 2
print("Middle:", middle, "nA")
r = (middle - fit.uvalue("offset")) / fit.uvalue("slope")
print("Range:", r, "cm")
def calc_radium_range():
peak = {
35: (1100, 1800),
35.5: (1000, 1700),
36: (900, 1600),
36.5: (800, 1500),
37: (600, 1400),
37.5: (500, 1200),
38: (300, 1000),
38.5: (100, 700)
}
distances = []
error_distances = []
integrals = []
error_integrals = []
for distanceStr in ("35_0", "35_5", "36_0", "36_5", "37_0", "37_5", "38_0",
"38_5"):
filename = "data/Radium%s.TKA" % distanceStr
distance = ufloat(float(distanceStr.replace("_", ".")), 0.05)
tka = TkaFile(filename)
lower, upper = peak[distance.n]
data = tka.data[lower:upper]
distance = distance - 35 + ufloat(3.17, 0.17)
integral = ufloat(data.sum(), math.sqrt((data + 1).sum()))
integral_fixed = integral * distance**2
print(
"$({:L}) \\unit{{cm}}$ & {:d} & {:d} & ${:dL}$ & ${:dL} \\unit{{cm^2}}$ \\\\"
.format(distance, lower, upper, integral, integral_fixed))
distances.append(distance.n)
error_distances.append(distance.s)
integrals.append(integral_fixed.n)
error_integrals.append(integral_fixed.s)
distances = np.array(distances)
integrals = np.array(integrals)
error_distances = np.array(error_distances)
error_integrals = np.array(error_integrals)
plt.clf()
plt.minorticks_on()
plt.errorbar(distances,
integrals,
xerr=error_distances,
yerr=error_integrals,
fmt="s")
#plt.plot(distances, integrals, 's')
plt.xlabel("Distanz / cm")
plt.ylabel("korrigierte Summe / cm^2")
plt.ylim(0, plt.ylim()[1])
plt.savefig("out/radium_range." + SAVETYPE)
#plt.show()
plt.clf()
plt.minorticks_on()
scale = 1 / integrals[0:3].mean()
fit = Fit(LINEAR)
fit.set_params(offset=1, slope=-0.5)
fit.set_data(xdata=distances[1:],
ydata=integrals[1:] * scale,
xerrors=error_distances[1:],
yerrors=error_integrals[1:] * scale)
fit.set_labels(xlabel="Distanz / cm", ylabel="Intensität")
fit.iterative_fit(5)
fit.plot(plot_data=True, plot_fit=True, box="bl", units={"slope": "1/cm"})
plt.ylim(0, plt.ylim()[1])
plt.savefig("out/radium_range_fit." + SAVETYPE)
plt.clf()
plt.minorticks_on()
fit.plot_residual(box="tr")
plt.savefig("out/radium_range_residual." + SAVETYPE)
r = (0.5 - fit.uvalue("offset")) / fit.uvalue("slope")
print("Range:", r, "cm")