diff --git a/tem/auswertung/figs/gold_hires/profile_1.pdf b/tem/auswertung/figs/gold_hires/profile_1.pdf index a524fc4..691b797 100644 Binary files a/tem/auswertung/figs/gold_hires/profile_1.pdf and b/tem/auswertung/figs/gold_hires/profile_1.pdf differ diff --git a/tem/auswertung/figs/gold_hires/profile_10.pdf b/tem/auswertung/figs/gold_hires/profile_10.pdf index 4211ab2..44c0ebb 100644 Binary files a/tem/auswertung/figs/gold_hires/profile_10.pdf and b/tem/auswertung/figs/gold_hires/profile_10.pdf differ diff --git a/tem/auswertung/figs/gold_hires/profile_4.pdf b/tem/auswertung/figs/gold_hires/profile_4.pdf index 63b7dc1..39e3e35 100644 Binary files a/tem/auswertung/figs/gold_hires/profile_4.pdf and b/tem/auswertung/figs/gold_hires/profile_4.pdf differ diff --git a/tem/auswertung/figs/gold_hires/profile_6.pdf b/tem/auswertung/figs/gold_hires/profile_6.pdf index 8ad07b9..3d705b9 100644 Binary files a/tem/auswertung/figs/gold_hires/profile_6.pdf and b/tem/auswertung/figs/gold_hires/profile_6.pdf differ diff --git a/tem/auswertung/gold_diffr.ipynb b/tem/auswertung/gold_diffr.ipynb new file mode 100644 index 0000000..e11c0db --- /dev/null +++ b/tem/auswertung/gold_diffr.ipynb @@ -0,0 +1,259 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [ + "from utility import *\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [ + "profile = load_profiles('../messungen/gold_diffr/peaks.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n )" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%matplotlib qt5\n", + "plot_diffr_profile(profile)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "data": { + "image/png": [ + "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\n" + ], + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "candidates, d_candidates, sigma_candidates = analyze_diffr_profile(profile, limits=[100, -1], distance=15, prominence=.001)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([ 4, 4, 9, 11, 13, 23, 28, 31, 40]), array([[0.4365859 , 0.00314502, 0.03385928],\n", + " [0.38654813, 0.00246542, 0.01311343],\n", + " [0.39925472, 0.00175345, 0.0193526 ],\n", + " [0.39935277, 0.00158683, 0.00165195],\n", + " [0.4097683 , 0.00153681, 0.02061948],\n", + " [0.40763549, 0.00114339, 0.02000247],\n", + " [0.40854715, 0.00104092, 0.0108266 ],\n", + " [0.4080742 , 0.00098699, 0.00785981],\n", + " [0.40573231, 0.00085894, 0.01187421]]), array([0.0287859 , 0.02125187, 0.00854528, 0.00844723, 0.0019683 ,\n", + " 0.00016451, 0.00074715, 0.0002742 , 0.00206769]))\n" + ] + } + ], + "source": [ + "hypothesis = evaluate_hypothesis(np.array([candidates, d_candidates, sigma_candidates]).T, maximum=80)\n", + "print(hypothesis)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\(\\sqrt{4}\\) & 0.4366 & 0.0031 & 0.0339 & 0.029 \\\\\n", + "\\(\\sqrt{4}\\) & 0.3865 & 0.0025 & 0.0131 & 0.021 \\\\\n", + "\\(\\sqrt{9}\\) & 0.3993 & 0.0018 & 0.0194 & 0.009 \\\\\n", + "\\(\\sqrt{11}\\) & 0.3994 & 0.0016 & 0.0017 & 0.008 \\\\\n", + "\\(\\sqrt{13}\\) & 0.4098 & 0.0015 & 0.0206 & 0.002 \\\\\n", + "\\(\\sqrt{23}\\) & 0.4076 & 0.0011 & 0.02 & 0.000 \\\\\n", + "\\(\\sqrt{28}\\) & 0.4085 & 0.001 & 0.0108 & 0.001 \\\\\n", + "\\(\\sqrt{31}\\) & 0.4081 & 0.001 & 0.0079 & 0.000 \\\\\n", + "\\(\\sqrt{40}\\) & 0.4057 & 0.0009 & 0.0119 & 0.002 \\\\\n", + "\n" + ] + } + ], + "source": [ + "print(generate_hypethsesis_table(*hypothesis))" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 730.29050427 4120.30484636 2244.84475614 95331.69131926\n", + " 2037.07066904 2236.39955377 7100.34700268 12776.96536546\n", + " 6167.76634145]\n" + ] + } + ], + "source": [ + "a, d_a, sigma_a = determine_lattice_constant(hypothesis)" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.4011, 0.0027, 0.0051)" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scientific_round(a, d_a, sigma_a)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "argv": [ + "/usr/bin/python3", + "-m", + "ipykernel_launcher", + "-f", + "{connection_file}" + ], + "display_name": "Python 3", + "env": null, + "interrupt_mode": "signal", + "language": "python", + "metadata": null, + "name": "python3" + }, + "name": "gold_diffr.ipynb" + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tem/auswertung/Untitled.ipynb b/tem/auswertung/hrtem.ipynb similarity index 98% rename from tem/auswertung/Untitled.ipynb rename to tem/auswertung/hrtem.ipynb index cddb373..87c6a45 100644 --- a/tem/auswertung/Untitled.ipynb +++ b/tem/auswertung/hrtem.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 4, "metadata": { "autoscroll": false, "collapsed": false, @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 5, "metadata": { "autoscroll": false, "collapsed": false, @@ -111,7 +111,24 @@ }, { "cell_type": "code", - "execution_count": 293, + "execution_count": 8, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [ + "hypothesis = evaluate_hypothesis(analyzed)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, "metadata": { "autoscroll": false, "collapsed": false, @@ -135,8 +152,80 @@ } ], "source": [ - "print(generate_hypethsesis_table(*evaluate_hypothesis(analyzed)))" + "print(generate_hypethsesis_table(*hypothesis))" ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.4131417242218807, 0.009111543899908446, 0.007970106548602144)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = determine_lattice_constant(hypothesis)\n", + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.413, 0.009, 0.008)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scientific_round(*a)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "autoscroll": false, + "collapsed": false, + "ein.hycell": false, + "ein.tags": "worksheet-0", + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [] } ], "metadata": { @@ -155,7 +244,7 @@ "metadata": null, "name": "python3" }, - "name": "Untitled.ipynb" + "name": "hrtem.ipynb" }, "nbformat": 4, "nbformat_minor": 2 diff --git a/tem/auswertung/utility.py b/tem/auswertung/utility.py index 97ca9dc..29d33ca 100644 --- a/tem/auswertung/utility.py +++ b/tem/auswertung/utility.py @@ -42,6 +42,9 @@ def load_profiles(path): def scientific_round(val, *err): """Scientifically rounds the values to the given errors.""" val, err = np.asarray(val), np.asarray(err) + if len(err.shape) == 1: + err = np.array([err]) + err = err.T err = err.T if err.size == 1 and val.size > 1: @@ -74,7 +77,7 @@ def scientific_round(val, *err): return rounded, rounded_err else: prec = prec[0] - return smart_round(val, prec), smart_round(err, prec)[0] + return smart_round(val, prec), *smart_round(err, prec)[0] ############################################################################### # Plot Porn # @@ -131,25 +134,55 @@ def save_fig(fig, title, folder='unsorted', size=(5, 4)): \end{figure} ''') -def plot_profile(profile, **pyplot_args): +def plot_profile_common(profile, **pyplot_args): x, amp = profile.T fig, ax = set_up_plot() ax.step(x, amp, label='Intensität', **pyplot_args) ax.set_xlim([x[0], x[-1]]) ax.set_ylabel('relative Intensit\"a') - ax.set_xlabel('x [nm]') - ax.legend() return fig, ax -def analyze_profile(profile, limits=(0, -1), save=None): +def plot_profile(profile, **pyplot_args): + fig, ax = plot_profile_common(profile, **pyplot_args) + + ax.set_xlabel('x [nm]') + + return fig, ax + +def plot_diffr_profile(profile, **pyplot_args): + fig, ax = plot_profile_common(profile, **pyplot_args) + + ax.set_xlabel('x [1/nm]') + + return fig, ax + +def analyze_diffr_profile(profile, limits, save=None, **peak_args): + x, amp = profile.T + fig, ax = plot_diffr_profile(profile) + + peaks, peak_info = find_peaks(amp[limits[0]:limits[1]], width=0, **peak_args) + + peaks += limits[0] + + ax.plot(x[peaks], amp[peaks], "x", label='Peaks') + ax.axvspan(x[limits[0]], x[limits[1]], color='gray', zorder=-1, alpha=.2, + label='Auswertungsbereich') + ax.legend() + + candidates = 1/x[peaks] + d_candidates = candidates**2*(x[1]-x[0]) + sigma_candidates = candidates**2*peak_info['widths']*(x[1]-x[0]) + return candidates, d_candidates, sigma_candidates + +def analyze_profile(profile, limits=(0, -1), save=None, **peak_args): x, amp = profile.T fig, ax = plot_profile(profile) - peaks, _ = find_peaks(amp[limits[0]:limits[1]]) + peaks, _ = find_peaks(amp[limits[0]:limits[1]], **peak_args) peaks += limits[0] ax.plot(x[peaks], amp[peaks], "x", label='Peaks') @@ -182,10 +215,25 @@ def evaluate_hypothesis(analyzed, maximum=10, gold=.4078): def generate_hypethsesis_table(squared, analyzed, residues): out = '' for square, value, residue in zip(squared, analyzed, residues): - #value = scientific_round(*value) - val, err = scientific_round(value[0], [value[1]], [value[2]]) + value = np.array(scientific_round(*value)) - out += rf'\(\sqrt{{{square}}}\) & {val} & ' \ - + ' & '.join(err.astype(str)) + f' & {residue:.3f} \\\\\n' + out += rf'\(\sqrt{{{square}}}\) & ' \ + + ' & '.join(value.astype(str)) + f' & {residue:.3f} \\\\\n' return out + +def determine_lattice_constant(hypothesis): + """ + Calculate the weighted mean and standard deviation by using the + combined deviation as weights. + + The systemic deviation is calculated by error propagation. + """ + a_s = hypothesis[1][:,0] + syst_err = hypothesis[1][:,1] + hypothesis[1][:,2] + weights = 1/syst_err**2 + a = np.average(a_s, weights=weights) + d_a = np.sqrt(1/np.sum(weights)) + sigma_a = np.sqrt(np.average((a_s-a)**2, weights=weights)) + + return a, d_a, sigma_a