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