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_diode_kennlinie():
current, power = np.loadtxt("data/kennlinie_diode.txt", unpack=True)
error_current = 1 / math.sqrt(12)
error_power = 1 / math.sqrt(12)
plt.clf()
plt.errorbar(current,
power,
xerr=error_current,
yerr=error_power,
fmt=',',
color="black")
plt.xlabel("Strom / mA")
plt.ylabel("Leistung / mW")
plt.savefig("out/kennlinie_diode_raw." + SAVETYPE)
fit_indices_list = []
fit_indices_list.append(current > 200)
valid = current > 200
valid[current > 410] = False
fit_indices_list.append(valid)
valid = current > 410
fit_indices_list.append(valid)
zero_power = power[current < 150]
background = zero_power.mean()
print("Background:", background, "mW")
power -= background
func = lambda x, slope, threshold: (x - threshold) * slope
fit = Fit(func)
fit.set_params(slope=0.85, threshold=190)
fit.set_data(xdata=current,
ydata=power,
xerrors=error_current,
yerrors=error_power)
fit.set_labels(xlabel="Strom / mA", ylabel="Leistung / mW")
for i, fit_indices in enumerate(fit_indices_list):
subfit = fit.filtered(fit_indices)
plt.clf()
plt.errorbar(current,
power,
xerr=error_current,
yerr=error_power,
fmt=',',
color="black")
subfit.iterative_fit(5)
#plt.axhline(background, color="blue")
#plt.axvline(subfit.value("threshold"), color="blue")
print("Threshold:", formatUFloat(subfit.uvalue("threshold"),
unit="mA"))
print("Slope:", formatUFloat(subfit.uvalue("slope"), unit="W/A"))
print("Chi^2/ndf:", subfit.chi2ndf)
print("===")
subfit.plot(range=(subfit.value("threshold"), current.max()),
color="black",
plot_fit=False,
plot_data=True,
fmt="s")
subfit.plot(range=(subfit.value("threshold"), current.max()),
box="tl",
color="red",
plot_data=False,
units={
"threshold": "mA",
"slope": "W/A"
})
plt.savefig("out/kennlinie_diode_%d_fit." % i + SAVETYPE)
plt.clf()
subfit.plot_residual(box="br", color="black", fmt="s")
plt.savefig("out/kennlinie_diode_%d_residual." % i + SAVETYPE)
def plot_qswitch():
frequency, error_frequency, power = np.loadtxt("data/frequenz_qswitch.txt",
unpack=True)
error_power = 1 / math.sqrt(12)
power /= 1000
error_power /= 1000
plt.clf()
plt.errorbar(frequency,
power,
xerr=error_frequency,
yerr=error_power,
fmt=',',
color="black")
plt.xlabel("Frequenz / Hz")
plt.ylabel("Leistung / mW")
plt.savefig("out/qswitch_raw." + SAVETYPE)
#power -= power[0]
fit = Fit(POLY3)
fit.set_data(xdata=frequency,
ydata=power,
xerrors=error_frequency,
yerrors=error_power)
fit.set_params(a0=380, a1=0.005, a2=-7e-8)
fit.set_labels(xlabel="Frequenz / Hz", ylabel="Leistung / mW")
subfit = fit.filtered(np.logical_and(frequency < 20e3, frequency > 1e3))
subfit.iterative_fit(5)
plt.clf()
subfit.plot(box="br",
units={
"a3": "mW/Hz^3",
"a2": "mW/Hz^2",
"a1": "mW/Hz",
"a0": "mW"
})
plt.savefig("out/qswitch_power_fit." + SAVETYPE)
plt.clf()
subfit.plot_residual(box="tr")
plt.savefig("out/qswitch_power_residual." + SAVETYPE)
plt.clf()
time, voltage = _load_oscilloscope_csv("data/ALL0023/F0023CH2.CSV")
time *= 1E6
time -= -935
plt.plot(time, voltage, ".", color="black")
pause = np.logical_and(time > 300, time < 900)
one_period = np.logical_and(time > 0, time < 1000)
print(one_period, one_period.sum())
mean_voltage = ufloat(voltage[one_period].mean(),
voltage[pause].std() / math.sqrt(one_period.sum()))
peak_voltage = ufloat(voltage[one_period].max(), voltage[pause].std())
print("ErrorL:", voltage[pause].std())
print("Mean voltage:", mean_voltage, "V")
print("Peak voltage:", peak_voltage, "V")
frequency = 1.01798e3 # Hz
mean_power = subfit.ueval(frequency)
print("Mean power:", mean_power * 1000, "uW")
peak_power = mean_power * peak_voltage / mean_voltage
print("Peak power:", peak_power * 1000, "uW")
plt.axhline(mean_voltage.n, color="red", linewidth=2)
plt.axhline(peak_voltage.n, color="red", linewidth=2)
plt.xlabel("Zeit / us")
plt.ylabel("Spannung / V")
plt.savefig("out/qswitch_osci." + SAVETYPE)
def plot_ktp():
current, power, error_power = np.loadtxt("data/ktp_kristall.txt",
unpack=True)
error_current = 1 / math.sqrt(12)
# uW -> mW
power /= 1000
error_power /= 1000
plt.clf()
plt.errorbar(current,
power,
xerr=error_current,
yerr=error_power,
fmt=',',
color="black")
plt.xlabel("Strom / mA")
plt.ylabel("Leistung mit KTP / mW")
plt.xlim(0, 700)
plt.savefig("out/ktp_raw." + SAVETYPE)
lower = np.logical_and(current > 182.10, current < 410)
upper = current >= 410
diode_power, error_diode_power = current2diode_power(
current, error_current)
plt.clf()
plt.errorbar(diode_power,
power,
xerr=error_diode_power,
yerr=error_power,
fmt=',',
color="black")
plt.xlabel("Diodenleistung / mW")
plt.ylabel("Laserleistung mit KTP / mW")
plt.savefig("out/ktp_raw2." + SAVETYPE)
yag_power, error_yag_power = diode_power2yag_power(diode_power,
error_diode_power)
plt.clf()
plt.errorbar(yag_power,
power,
xerr=error_yag_power,
yerr=error_power,
fmt=',',
color="black")
plt.xlabel("Laserleistung ohne KTP / mW")
plt.ylabel("Laserleistung mit KTP / mW")
plt.xlim(0, 10)
plt.savefig("out/ktp_raw3." + SAVETYPE)
plt.clf()
fit = Fit(POLY2)
fit.set_data(xdata=yag_power,
ydata=power,
xerrors=error_yag_power,
yerrors=error_power)
fit.set_labels(xlabel="Laserleistung ohne KTP / mW",
ylabel="Laserleistung mit KTP / mW")
fit = fit.filtered(yag_power > 2)
fit.iterative_fit(5)
fit.plot(box="tl", units={"a2": "1/mW", "a0": "mW"})
plt.savefig("out/ktp_fit." + SAVETYPE)
plt.clf()
fit.plot_residual(box="tl")
plt.savefig("out/ktp_residual." + SAVETYPE)