diff --git a/01 GaAs Nanowire - Data Inspection - Preprocessing - Unsupervised Machine Learning.ipynb b/01 GaAs Nanowire - Data Inspection - Preprocessing - Unsupervised Machine Learning.ipynb
index 7ba4b0d..613e8c7 100644
--- a/01 GaAs Nanowire - Data Inspection - Preprocessing - Unsupervised Machine Learning.ipynb
+++ b/01 GaAs Nanowire - Data Inspection - Preprocessing - Unsupervised Machine Learning.ipynb
@@ -25,7 +25,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "This functionaility has been checked to run in pyxem-0.9.0 (July 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
+ "This functionaility has been checked to run in pyxem-0.10.0 (November 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
]
},
{
@@ -246,7 +246,8 @@
"metadata": {},
"outputs": [],
"source": [
- "dp.center_direct_beam(radius_start=2,\n",
+ "dp.center_direct_beam(method='cross_correlate',\n",
+ " radius_start=2,\n",
" radius_finish=5,\n",
" square_width=10)"
]
diff --git a/02 GaAs Nanowire - Phase Mapping - Orientation Mapping.ipynb b/02 GaAs Nanowire - Phase Mapping - Orientation Mapping.ipynb
index 0309521..c2d709d 100644
--- a/02 GaAs Nanowire - Phase Mapping - Orientation Mapping.ipynb
+++ b/02 GaAs Nanowire - Phase Mapping - Orientation Mapping.ipynb
@@ -25,7 +25,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "This functionaility has been checked to run in pyxem-0.9.0 (July 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
+ "This functionaility has been checked to run in pyxem-0.10.0 (November 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
]
},
{
@@ -302,9 +302,10 @@
"metadata": {},
"outputs": [],
"source": [
- "from diffsims.generators.structure_library_generator import StructureLibraryGenerator\n",
+ "from diffsims.libraries.structure_library import StructureLibrary\n",
"from diffsims.generators.diffraction_generator import DiffractionGenerator\n",
"from diffsims.generators.library_generator import DiffractionLibraryGenerator\n",
+ "from diffsims.utils.sim_utils import rotation_list_stereographic\n",
"\n",
"from pyxem.generators.indexation_generator import IndexationGenerator"
]
@@ -330,18 +331,14 @@
"outputs": [],
"source": [
"structure_zb = diffpy.structure.loadStructure('./GaAs_mp-2534_conventional_standard.cif')\n",
- "structure_wz = diffpy.structure.loadStructure('./GaAs_mp-8883_conventional_standard.cif')\n",
- "\n",
- "phase_descriptions = [('ZB', structure_zb, 'cubic'),\n",
- " ('WZ', structure_wz, 'hexagonal')]\n",
- "phase_names = [phase[0] for phase in phase_descriptions]"
+ "structure_wz = diffpy.structure.loadStructure('./GaAs_mp-8883_conventional_standard.cif')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Initialize a structure library generator for the specified phases"
+ "Create a basic rotations list. "
]
},
{
@@ -350,7 +347,8 @@
"metadata": {},
"outputs": [],
"source": [
- "struc_lib_gen = StructureLibraryGenerator(phase_descriptions)"
+ "rot_list_cubic = rotation_list_stereographic(structure_zb,(0, 0, 1),(1, 0, 1),(1, 1, 1),np.linspace(0, 2*np.pi, 360/10),np.deg2rad(10))\n",
+ "rot_list_hex = rotation_list_stereographic(structure_wz,(0, 0, 0, 1), (1, 0, -1, 0), (1, 1, -2, 0),np.linspace(0, 2*np.pi, 360/10),np.deg2rad(10))"
]
},
{
@@ -366,11 +364,9 @@
"metadata": {},
"outputs": [],
"source": [
- "inplane_rotations = [[0], [0]] # The library only needs the base in-plane rotation. The other ones are generated\n",
- "rotation_list_resolution = 1\n",
- "\n",
- "struc_lib = struc_lib_gen.get_orientations_from_stereographic_triangle(\n",
- " inplane_rotations, rotation_list_resolution)"
+ "struc_lib = StructureLibrary(['ZB','WZ'],\n",
+ " [structure_zb,structure_wz],\n",
+ " [rot_list_cubic,rot_list_hex])"
]
},
{
@@ -450,7 +446,7 @@
"metadata": {},
"outputs": [],
"source": [
- "diff_lib.pickle_library('./GaAs_cubic_hex_1deg.pickle')"
+ "diff_lib.pickle_library('./GaAs_cubic_hex.pickle')"
]
},
{
@@ -468,7 +464,7 @@
"source": [
"from diffsims.libraries.diffraction_library import load_DiffractionLibrary\n",
"\n",
- "diff_lib = load_DiffractionLibrary('./GaAs_cubic_hex_1deg.pickle', safety=True)"
+ "diff_lib = load_DiffractionLibrary('./GaAs_cubic_hex.pickle', safety=True)"
]
},
{
@@ -948,20 +944,6 @@
"source": [
"crystal_map.save_mtex_map('vector_match_results.csv')"
]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
}
],
"metadata": {
@@ -980,7 +962,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.7.1"
+ "version": "3.7.3"
}
},
"nbformat": 4,
diff --git a/03 Reference Standards - Dimension Calibrations - Rotation Calibrations.ipynb b/03 Reference Standards - Dimension Calibrations - Rotation Calibrations.ipynb
index 65bbcca..e30bcf8 100644
--- a/03 Reference Standards - Dimension Calibrations - Rotation Calibrations.ipynb
+++ b/03 Reference Standards - Dimension Calibrations - Rotation Calibrations.ipynb
@@ -18,7 +18,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "This functionaility was introduced in pyxem-0.9.0 (July 2019) and has been checked to run. Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
+ "This functionaility has been checked to run in pyxem-0.10.0 (November 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
]
},
{
diff --git a/04 Simulate Data - Phase Mapping - Orientation Mapping.ipynb b/04 Simulate Data - Phase Mapping - Orientation Mapping.ipynb
index edd6700..a3597d7 100644
--- a/04 Simulate Data - Phase Mapping - Orientation Mapping.ipynb
+++ b/04 Simulate Data - Phase Mapping - Orientation Mapping.ipynb
@@ -25,7 +25,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "This functionaility has been checked to run in pyxem-0.9.0 (July 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
+ "This functionaility has been checked to run in pyxem-0.10.0 (November 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
]
},
{
@@ -65,14 +65,14 @@
"metadata": {},
"outputs": [],
"source": [
- "%matplotlib tk\n",
+ "%matplotlib qt\n",
"import numpy as np\n",
"import hyperspy.api as hs\n",
"import pyxem as pxm\n",
"import diffpy.structure\n",
"from matplotlib import pyplot as plt\n",
"\n",
- "from diffsims.generators.structure_library_generator import StructureLibraryGenerator\n",
+ "from diffsims.utils.sim_utils import rotation_list_stereographic\n",
"from diffsims.libraries.structure_library import StructureLibrary\n",
"from diffsims.generators.diffraction_generator import DiffractionGenerator\n",
"from diffsims.generators.library_generator import DiffractionLibraryGenerator, VectorLibraryGenerator\n",
@@ -222,12 +222,19 @@
"metadata": {},
"outputs": [],
"source": [
- "structure_library_generator = StructureLibraryGenerator(\n",
- " [('Si', si, 'cubic'),\n",
- " ('Ga', ga, 'hexagonal')])\n",
- "structure_library = structure_library_generator.get_orientations_from_stereographic_triangle(\n",
- " [(0,), (0,)], # In-plane rotations\n",
- " 5) # Angular resolution of the library"
+ "rot_list_cubic = rotation_list_stereographic(si,(0, 0, 1),(1, 0, 1),(1, 1, 1),np.linspace(0, 2*np.pi, 360/10),np.deg2rad(10))\n",
+ "rot_list_hex = rotation_list_stereographic(ga,(0, 0, 0, 1), (1, 0, -1, 0), (1, 1, -2, 0),np.linspace(0, 2*np.pi, 50),np.deg2rad(3))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "structure_library = StructureLibrary(['si','ga'],\n",
+ " [si,ga],\n",
+ " [rot_list_cubic,rot_list_hex])"
]
},
{
@@ -255,7 +262,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Correlate with the patterns contained in the library with the test data. At this stage the top 3 (`n_largest`) matching results are retained. Test all in-plane rotations at 5 degree increments from 0 to 360."
+ "Correlate with the patterns contained in the library with the test data. At this stage the top 3 (`n_largest`) matching results are retained."
]
},
{
@@ -265,7 +272,7 @@
"outputs": [],
"source": [
"indexer = IndexationGenerator(test_data, template_library)\n",
- "match_results = indexer.correlate(n_largest=3, inplane_rotations=np.arange(0, 360, 5))"
+ "match_results = indexer.correlate(n_largest=3)"
]
},
{
diff --git a/05 Simulate Data - Strain Mapping.ipynb b/05 Simulate Data - Strain Mapping.ipynb
index 5e3ee74..50fb6d2 100644
--- a/05 Simulate Data - Strain Mapping.ipynb
+++ b/05 Simulate Data - Strain Mapping.ipynb
@@ -25,7 +25,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "All functionality has been checked to run using pyxem-0.9.0"
+ "This functionaility has been checked to run in pyxem-0.10.0 (November 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
]
},
{
@@ -351,8 +351,8 @@
"metadata": {},
"outputs": [],
"source": [
- "spg = SubpixelrefinementGenerator(dp,np.asarray([x_peak,y_peak]))\n",
- "Vs = spg.center_of_mass_method(6)"
+ "spg = SubpixelrefinementGenerator(dp, np.asarray([x_peak,y_peak]))\n",
+ "Vs = spg.center_of_mass_method(20)"
]
},
{
@@ -388,6 +388,13 @@
"source": [
"strain_map.plot(cmap='seismic',vmax=0.04,vmin=-0.04)"
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
}
],
"metadata": {
diff --git a/06 Nanocrystal segmentation in SPED data - Demonstration on partly overlapping MgO cubes.ipynb b/06 Nanocrystal segmentation in SPED data - Demonstration on partly overlapping MgO cubes.ipynb
new file mode 100644
index 0000000..97f4dd5
--- /dev/null
+++ b/06 Nanocrystal segmentation in SPED data - Demonstration on partly overlapping MgO cubes.ipynb
@@ -0,0 +1,1432 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Introduction"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This notebook demonstrates two approaches to nanocrystal segmentation:\n",
+ "1. Virtual dark-field (VDF) imaging-based segmentation\n",
+ "2. Non-negative matrix factorisation (NMF)-based segmentation\n",
+ "\n",
+ "The segmentation is demonstrated on a SPED dataset of partly overlapping MgO nanoparticles, where some of the particles share the same orientation. The SPED data can be found in [1]. An article including explanation of the methods and discussions of the results is under review. \n",
+ "\n",
+ "[1] T Bergh. (2019) *Scanning precession electron diffraction data of partly overlapping magnesium oxide nanoparticles.* doi: 10.5281/zenodo.3382874."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This functionaility was introduced in pyxem-0.10.0 (November 2019) and has been checked to run. Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Contents"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "1. Setting up, Loading Data, Pre-processing\n",
+ "2. Virtual Image Based Segmentation\n",
+ "3. NMF Based Segmentation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 1. Setting up, Loading Data, Pre-processing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Import pyxem and other required libraries"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:silx.opencl.common:Unable to import pyOpenCl. Please install it from: http://pypi.python.org/pypi/pyopencl\n"
+ ]
+ }
+ ],
+ "source": [
+ "%matplotlib qt\n",
+ "import numpy as np\n",
+ "import hyperspy.api as hs\n",
+ "import matplotlib.pyplot as plt\n",
+ "import pyxem as pxm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Load demonstration data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp = pxm.load_hspy('SPED_MgO.hdf5',\n",
+ " lazy=False,\n",
+ " assign_to='electron_diffraction2d')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot data to inspect"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp.plot(cmap='magma_r')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Remove the background"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "f033ba65df37428ebdcb23b6d8a18f47",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "sigma_min = 1.7\n",
+ "sigma_max = 13.2\n",
+ "\n",
+ "dp_rb = dp.remove_background('gaussian_difference', \n",
+ " sigma_min=sigma_min, \n",
+ " sigma_max=sigma_max)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the background subtracted data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp_rb.plot(cmap='magma_r')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Find the position of the direct beam in the background subtracted data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "80b9d858833d4a64bd1afd14597d04d8",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "c2c713da2c9541339225f8757283db86",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "shifts = dp_rb.center_direct_beam(method='cross_correlate',\n",
+ " square_width=15,\n",
+ " return_shifts=True,\n",
+ " radius_start=2,\n",
+ " radius_finish=6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Apply the same shifts to the raw data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "d223d1e620e54c79bd7772afca614725",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "dp.align2D(shifts=shifts, crop=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Set calibrations"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scale = 0.03246 \n",
+ "scale_real = 3.03\n",
+ "dp.set_diffraction_calibration(scale)\n",
+ "dp.set_scan_calibration(scale_real)\n",
+ "\n",
+ "dp_rb.set_diffraction_calibration(scale)\n",
+ "dp_rb.set_scan_calibration(scale_real)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 2. Virtual Image Based Segmentation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.1. Peak Finding & Refinement"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Find all diffraction peaks for all PED patterns. \n",
+ "The parameters were found by interactive peak finding:\n",
+ "\n",
+ "`peaks = dp_rb.find_peaks_interactive(imshow_kwargs={'cmap': 'magma_r'})`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "807e87a7dff5433992a971214c118866",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/hremadmin/anaconda3/envs/pyxem/lib/python3.7/site-packages/skimage/feature/blob.py:125: RuntimeWarning: invalid value encountered in double_scalars\n",
+ " r1 = blob1[-1] / blob2[-1]\n",
+ "/home/hremadmin/anaconda3/envs/pyxem/lib/python3.7/site-packages/skimage/feature/blob.py:126: RuntimeWarning: divide by zero encountered in true_divide\n",
+ " pos1 = blob1[:ndim] / (max_sigma * root_ndim)\n",
+ "/home/hremadmin/anaconda3/envs/pyxem/lib/python3.7/site-packages/skimage/feature/blob.py:127: RuntimeWarning: divide by zero encountered in true_divide\n",
+ " pos2 = blob2[:ndim] / (max_sigma * root_ndim)\n",
+ "/home/hremadmin/anaconda3/envs/pyxem/lib/python3.7/site-packages/skimage/feature/blob.py:129: RuntimeWarning: invalid value encountered in subtract\n",
+ " d = np.sqrt(np.sum((pos2 - pos1)**2))\n",
+ "WARNING:hyperspy.signal:The function you applied does not take into account the difference of units and of scales in-between axes.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "f3a33dbf3e3341a3b203edcc155d6db2",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "peaks = dp_rb.find_peaks(method='laplacian_of_gaussians', \n",
+ " min_sigma=0.7,\n",
+ " max_sigma=10,\n",
+ " num_sigma=30, \n",
+ " threshold=0.046, \n",
+ " overlap=0.5, \n",
+ " log_scale=False,\n",
+ " exclude_border=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Visualise the number of diffraction peaks found at each probe position"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:hyperspy.signal:The function you applied does not take into account the difference of units and of scales in-between axes.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "0f139b6b2e824f2d97c70271b2731fde",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "diff_map = peaks.get_diffracting_pixels_map()\n",
+ "diff_map.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Exclude peaks too close to the detector edge for sub-pixel refinement. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:hyperspy.signal:The function you applied does not take into account the difference of units and of scales in-between axes.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a3670132312c48deb3f6ab8b5636b00d",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "peaks_filtered = peaks.filter_vectors_detector_edge(exclude_width=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Refine the peak positions using center of mass"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:hyperspy.signal:The function you applied does not take into account the difference of units and of scales in-between axes.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "f87a6469dd084bbaa6d52d25a9933c57",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "4f8e9eeb7d04464aa6d5583c41e37f67",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=12426), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "from pyxem.generators.subpixelrefinement_generator import SubpixelrefinementGenerator\n",
+ "from pyxem.signals.diffraction_vectors import DiffractionVectors\n",
+ "\n",
+ "\n",
+ "refine_gen = SubpixelrefinementGenerator(dp_rb, peaks_filtered)\n",
+ "\n",
+ "peaks_refined = DiffractionVectors(refine_gen.center_of_mass_method(square_size=4))\n",
+ "\n",
+ "peaks_refined.axes_manager.set_signal_dimension(0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.2. Determine Unique Peaks"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Determine the unique diffraction peaks by clustering"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "54 unique vectors were found.\n"
+ ]
+ }
+ ],
+ "source": [
+ "distance_threshold = scale*0.89\n",
+ "min_samples = 10\n",
+ "\n",
+ "unique_peaks = peaks_refined.get_unique_vectors(method='DBSCAN',\n",
+ " distance_threshold=distance_threshold,\n",
+ " min_samples=min_samples)\n",
+ "print(np.shape(unique_peaks.data)[0], ' unique vectors were found.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Visualise the detected unique peaks by plotting them on the maximum of the signal. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "radius_px = dp_rb.axes_manager.signal_shape[0]/2\n",
+ "reciprocal_radius = radius_px * scale"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "unique_peaks.plot_diffraction_vectors(\n",
+ " method='DBSCAN',\n",
+ " unique_vectors=unique_peaks,\n",
+ " distance_threshold=distance_threshold,\n",
+ " xlim=reciprocal_radius,\n",
+ " ylim=reciprocal_radius,\n",
+ " min_samples=min_samples,\n",
+ " image_to_plot_on=dp_rb.max(),\n",
+ " image_cmap='magma_r',\n",
+ " plot_label_colors=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Visualise both the clusters and the unique peaks obtained after DBSCAN clustering. \n",
+ "\n",
+ "*NB The cluster colors are randomly generated, so run it again if it is hard to discern two close clusters.*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "peaks_refined.plot_diffraction_vectors(\n",
+ " method='DBSCAN',\n",
+ " xlim=reciprocal_radius, \n",
+ " ylim=reciprocal_radius,\n",
+ " unique_vectors=unique_peaks, \n",
+ " distance_threshold=distance_threshold,\n",
+ " min_samples=min_samples, \n",
+ " image_to_plot_on=dp_rb.max(), \n",
+ " image_cmap='gray_r',\n",
+ " plot_label_colors=True, \n",
+ " distance_threshold_all=scale*0.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Filter the unique vectors by magnitude in order to exclude the direct beam from the following analysis"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "50 unique vectors.\n"
+ ]
+ }
+ ],
+ "source": [
+ "Gs = unique_peaks.filter_vectors_magnitudes(min_magnitude=10*scale,\n",
+ " max_magnitude=np.inf)\n",
+ "print(np.shape(Gs)[0], ' unique vectors.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the unique vectors"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Gs.plot_diffraction_vectors(unique_vectors=Gs,\n",
+ " distance_threshold=distance_threshold,\n",
+ " xlim=reciprocal_radius,\n",
+ " ylim=reciprocal_radius,\n",
+ " min_samples=min_samples,\n",
+ " image_to_plot_on=dp_rb.max(),\n",
+ " image_cmap='magma',\n",
+ " plot_label_colors=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Optionally save and load the unique peaks"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "np.save('peaks.npy', Gs.data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "Gs = np.load('peaks.npy', allow_pickle=True)\n",
+ "Gs = pxm.DiffractionVectors(Gs)\n",
+ "Gs.axes_manager.set_signal_dimension(0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.3. Virtual Imaging & Segmentation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Calculate VDF images for all unique peaks"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pyxem.generators.vdf_generator import VDFGenerator\n",
+ "\n",
+ "radius=scale*2\n",
+ "\n",
+ "vdfgen = VDFGenerator(dp_rb, Gs)\n",
+ "VDFs = vdfgen.get_vector_vdf_images(radius=radius)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the VDF images for inspection"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "VDFs.plot(cmap='magma', scalebar=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "First find adequate parameters by looking at watershed segmentation of a single VDF image."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pyxem.utils.segment_utils import separate_watershed"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "min_distance = 5.5\n",
+ "min_size = 10\n",
+ "max_size = np.inf\n",
+ "max_number_of_grains = np.inf\n",
+ "marker_radius = 2\n",
+ "exclude_border = 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "i = 25\n",
+ "sep_i = separate_watershed(\n",
+ " VDFs.inav[i].data, min_distance=min_distance, min_size=min_size,\n",
+ " max_size=max_size, max_number_of_grains=max_number_of_grains,\n",
+ " exclude_border=exclude_border, marker_radius=marker_radius,\n",
+ " threshold=True, plot_on=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Perform segmentation on all the VDF images"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "043b8c862ae74e4b9d914f70433dd439",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "163 segments were found.\n"
+ ]
+ }
+ ],
+ "source": [
+ "segs = VDFs.get_vdf_segments(min_distance=min_distance,\n",
+ " min_size=min_size,\n",
+ " max_size = max_size,\n",
+ " max_number_of_grains = max_number_of_grains,\n",
+ " exclude_border=exclude_border,\n",
+ " marker_radius=marker_radius,\n",
+ " threshold=True)\n",
+ "\n",
+ "print(np.shape(segs.segments)[0],' segments were found.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the segments for inspection"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "segs.segments.plot(cmap='magma_r')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Calculate normalised cross-correlations between all VDF image segments to identify those that are related to the same crystal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ncc_vdf = segs.get_ncc_matrix()\n",
+ "ncc_vdf.plot(scalebar=False, cmap='RdBu')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If the correlation value exceeds *corr_threshold* for certain segments, those segments are summed. These segments are discarded if the number of these segments are below *vector_threshold*, as this number corresponds to the number of detected diffraction peaks associated with the single crystal. The *vector_threshold* criteria is included to avoid including segment images resulting from noise or incorrect segmentation. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "corr_threshold=0.7\n",
+ "vector_threshold=5\n",
+ "segment_threshold=4"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/163 [00:01,\n",
+ " ,\n",
+ " ,\n",
+ " ,\n",
+ " ,\n",
+ " ,\n",
+ " ]"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hs.plot.plot_images(corrsegs.segments, cmap='magma_r', axes_decor='off',\n",
+ " per_row=np.shape(corrsegs.segments)[0],\n",
+ " suptitle='', scalebar=False, scalebar_color='white',\n",
+ " colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})\n",
+ "hs.plot.plot_images(virtual_sig, cmap='magma_r', axes_decor='off',\n",
+ " per_row=np.shape(corrsegs.segments)[0],\n",
+ " suptitle='', scalebar=False, scalebar_color='white',\n",
+ " colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right': 0.78})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 3. NMF Based Segmentation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 3.1. NMF Decomposition"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create a signal mask so that the region in the centre of each PED pattern, including the direct beam, can be excluded in the machine learning. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dpm = pxm.Diffraction2D(dp.inav[0,0])\n",
+ "signal_mask = dpm.get_direct_beam_mask(radius=10)\n",
+ "signal_mask.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Perform single value decomposition (SVD)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp.change_dtype('float32')\n",
+ "dp.decomposition(algorithm='svd',\n",
+ " normalize_poissonian_noise=True,\n",
+ " centre='variables',\n",
+ " signal_mask=signal_mask.data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp.plot_decomposition_results()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Investigate the scree plot and use it as a guide to determine the number of components"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "num_comp=11\n",
+ "\n",
+ "ax = dp.plot_explained_variance_ratio(n=200, threshold=num_comp,\n",
+ " hline=True, xaxis_labeling='ordinal',\n",
+ " signal_fmt={'color':'k', 'marker':'.'}, \n",
+ " noise_fmt={'color':'gray', 'marker':'.'})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Perform NMF decomposition with specified number of components"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp.decomposition(normalize_poissonian_noise=True,\n",
+ " algorithm='nmf',\n",
+ " output_dimension=num_comp,\n",
+ " centre = 'variables',\n",
+ " signal_mask=signal_mask.data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp_nmf = dp.get_decomposition_model(components=np.arange(num_comp))\n",
+ "factors = dp_nmf.get_decomposition_factors()\n",
+ "loadings = dp_nmf.get_decomposition_loadings()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the NMF results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hs.plot.plot_images(loadings, cmap='magma_r', axes_decor='off', per_row=11,\n",
+ " suptitle='', scalebar=False, scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})\n",
+ "hs.plot.plot_images(factors, cmap='magma_r', axes_decor='off', per_row=11,\n",
+ " suptitle='', scalebar=False, scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Discard the components related to background (\\#0) and to the carbon film (\\#4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from hyperspy.signals import Signal2D"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "factors = Signal2D(np.delete(factors.data, [0, 4], axis = 0))\n",
+ "loadings = Signal2D(np.delete(loadings.data, [0, 4], axis = 0))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hs.plot.plot_images(factors, cmap='magma_r', axes_decor='off',\n",
+ " per_row=9, suptitle='', scalebar=False,\n",
+ " scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})\n",
+ "\n",
+ "hs.plot.plot_images(loadings, cmap='magma_r', axes_decor='off',\n",
+ " per_row=9, suptitle='', scalebar=False,\n",
+ " scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 3.2. Correlate NMF Loading Maps"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "NMF often leads to splitting of some crystals into several components. Therefore the correlation between loadings and between component patterns are calculated, and if both the correlation values for loadings and factors exceed threshold values, those loadings and factors are summed. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Calculate the matrix of normalised cross-correlation for both the loadings and patterns first, to find suitable correlation threshold values. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pyxem.signals.segments import LearningSegment\n",
+ "learn = LearningSegment(factors=factors, loadings=loadings)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ncc_nmf = learn.get_ncc_matrix()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ncc_nmf.plot(scalebar=False, cmap='RdBu')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "corr_th_factors = 0.45\n",
+ "corr_th_loadings = 0.3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Perform correlation and summation of the factors and loadings"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "learn_corr = learn.correlate_learning_segments(corr_th_factors=corr_th_factors,\n",
+ " corr_th_loadings=corr_th_loadings)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the NMF reuslts after correlation and summation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hs.plot.plot_images(learn_corr.loadings, cmap='magma_r', axes_decor='off',\n",
+ " per_row=7, suptitle='', scalebar=False,\n",
+ " scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})\n",
+ "hs.plot.plot_images(learn_corr.factors, cmap='magma_r', axes_decor='off',\n",
+ " per_row=7, suptitle='', scalebar=False,\n",
+ " scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2(c) Watershed segmentation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Since one single loading map can contain several crystals, watershed segmentation is performed on the correlated loadings. \n",
+ "\n",
+ "First investigate how the parameters influence the segmentation on\n",
+ "one single loading map."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pyxem.utils.segment_utils import separate_watershed"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "min_distance = 10\n",
+ "min_size = 50\n",
+ "max_size = None\n",
+ "max_number_of_grains = np.inf\n",
+ "marker_radius = 2\n",
+ "exclude_border = 1\n",
+ "threshold = True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "i =1\n",
+ "sep_i = separate_watershed(\n",
+ " learn_corr.loadings.data[i], min_distance=min_distance,\n",
+ " min_size=min_size, max_size=max_size, \n",
+ " max_number_of_grains=max_number_of_grains,\n",
+ " exclude_border=exclude_border, \n",
+ " marker_radius=marker_radius, threshold=True, plot_on=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Set a threshold for the minimum intensity value that a loading segment must contain in order to be kept. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "min_intensity_threshold = 10000"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "learn_corr_seg = learn_corr.separate_learning_segments(\n",
+ " min_intensity_threshold=min_intensity_threshold,\n",
+ " min_distance = min_distance, min_size = min_size,\n",
+ " max_size = max_size, \n",
+ " max_number_of_grains = max_number_of_grains,\n",
+ " exclude_border = exclude_border,\n",
+ " marker_radius = marker_radius, threshold = True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the final results from the NMF-based segmentation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hs.plot.plot_images(learn_corr_seg.loadings, \n",
+ " cmap='magma_r', axes_decor='off',\n",
+ " per_row=10, suptitle='', scalebar=False,\n",
+ " scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})\n",
+ "\n",
+ "hs.plot.plot_images(learn_corr_seg.factors, \n",
+ " cmap='magma_r', axes_decor='off',\n",
+ " per_row=10, suptitle='', scalebar=False,\n",
+ " scalebar_color='white', colorbar=False,\n",
+ " padding={'top': 0.95, 'bottom': 0.05,\n",
+ " 'left': 0.05, 'right':0.78})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/07 Azimuthal Integration Using pyFAI Detector.ipynb b/07 Azimuthal Integration Using pyFAI Detector.ipynb
new file mode 100644
index 0000000..773c785
--- /dev/null
+++ b/07 Azimuthal Integration Using pyFAI Detector.ipynb
@@ -0,0 +1,376 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Azimuthal Integral Tutorial"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Introduction"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This tutorial demonstrates how to acquire an azimuthal integral profile from a multidimensional data set in pyXem. \n",
+ "\n",
+ "The data set is a 10x10x256x256 data set of a polycrystalline gold film acquired using a Medipix3 256 by 256 pixel detector. \n",
+ "\n",
+ "This functionality has been checked to run in pyxem-0.10.0 (November 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Contents"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "1. Loading & Inspection\n",
+ "2. Creating a Detector Object\n",
+ "3. Calculation Calibration Parameters\n",
+ "4. Performing Azimuthal Integration"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Import pyxem and other required libraries"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib tk\n",
+ "import pyxem as pxm\n",
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 1. Loading and Inspection"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Load polycrystalline SED data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp = pxm.load_hspy('ai-demo-data.hspy',\n",
+ " assign_to='electron_diffraction2d')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Check the data size and type"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Apply an affine distortion correction"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp.apply_affine_transformation(\n",
+ " np.array([[0.99978285, 0.00341758, 0.],\n",
+ " [0.00341758, 0.94621262, 0.],\n",
+ " [0., 0., 1.]]),keep_dtype=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "calib = 0.009197\n",
+ "dp.set_diffraction_calibration(calib)\n",
+ "dp.set_scan_calibration(5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the data for inspection"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dp.plot(vmax=1000)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 2. Creating a Detector Object"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To get an azimuthal integral, it is important to characterise the detector, particularly in case it is not well represented by a flat-field approximation. To do this, we use the PyFAI Detector class. For example, here we create a Medipix256x256 Detector object from pyXem. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pyxem.detectors import Medipix256x256Detector"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "detector = Medipix256x256Detector()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "detector"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.1. Generic Detector Object"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "pyXem also defines a generic detector object which can be used if you're uncertain about certain detector parameters, or need a temporary fix for something."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pyxem.detectors import GenericFlatDetector"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "detector2 = GenericFlatDetector(256,256)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The 256, 256 refers to the size of the detector in its two dimensions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 3. Calculating Calibration Parameters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In addition to specifying the detector, to accurately calculate the curvature of the Ewald Sphere, it is important to specify a calibration. In addition, the wavelength is specified to do that calculation.\n",
+ "\n",
+ "The calibration is calculated by knowing the camera length. Alternatively, by assuming a no curvature in the detector, it is possible to calculate the camera length from an \"inverse angstroms per pixel\" calibration value. We suggest calibrating to a gold pattern for a calibration value and using the latter (for electron microscopy)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "wavelength = 2.5079e-12 # in metres for 200 kV"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 3.1 By knowing the camera length accurately"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "camera_length = 0.24 #in metres"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 3.2 By calculating the camera length from a calibration value"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pix_size = 55e-6 #change to 1 if using the GenericFlatDetector()\n",
+ "camera_length = pix_size / (wavelength * calib * 1e10)\n",
+ "print('Camera Length:', camera_length)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 4. Performing Azimuthal Integration"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Specify the origin (in pixels) as a list [x y]. If the origin moves, instead an array of origins can be passed instead."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "origin = [127.5, 127.5]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Get the azimuthal integral selecting 181 effective pixels in 1D"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ai = dp.get_azimuthal_integral(origin=origin,\n",
+ " detector_distance=camera_length,\n",
+ " detector=detector, \n",
+ " wavelength=wavelength,\n",
+ " size_1d=181)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Inspect the integrated data. Plotted after cropping direct beam."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ai.isig[0.2:].plot()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/08 Pair Distribution Function Analysis.ipynb b/08 Pair Distribution Function Analysis.ipynb
new file mode 100644
index 0000000..96ee50e
--- /dev/null
+++ b/08 Pair Distribution Function Analysis.ipynb
@@ -0,0 +1,467 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# PDF Analysis Tutorial"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Introduction"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This tutorial demonstrates how to acquire a multidimensional pair distribution function (PDF) from both a flat field electron diffraction pattern and a scanning electron diffraction data set."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The data is from an open-source paper by Shanmugam et al. [1] that is used as a reference standard. It is an\n",
+ "Amorphous 18nm SiO2 film. The scanning electron diffraction data set is a scan of a polycrystalline gold reference standard with 128x128 real space pixels and 256x256 diffraction space pixels. The implementation also initially followed Shanmugam et al.\n",
+ "\n",
+ "\n",
+ "\n",
+ "[1] Shanmugam, J., Borisenko, K. B., Chou, Y. J., & Kirkland, A. I. (2017). eRDF Analyser: An interactive GUI for electron reduced density function analysis. SoftwareX, 6, 185-192."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This functionality has been checked to run in pyxem-0.10.0 (November 2019). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Contents"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "1. Loading & Inspection\n",
+ "2. Acquiring a radial profile\n",
+ "3. Acquiring a Reduced Intensity\n",
+ "4. Damping the Reduced Intensity\n",
+ "5. Acquiring a PDF"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Import pyXem and other required libraries"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib tk\n",
+ "import pyxem as pxm\n",
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 1. Loading and Inspection"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Load the diffraction data line profile"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rp = pxm.load_hspy('./Amorphous_SiO2_azav_0.00167.hspy',\n",
+ " assign_to='electron_diffraction1d')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For now, the code requires navigation dimensions in the reduced intensity signal, two size 1 ones are created."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rp = pxm.ElectronDiffraction1D([[rp.data]])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Set the diffraction pattern calibration. Note that pyXem uses a calibration to $s = \\frac{1}{d} = 2\\frac{\\sin{\\theta}}{\\lambda}$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "calibration = 0.00167\n",
+ "\n",
+ "rp.set_diffraction_calibration(calibration=calibration)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Plot the radial profile "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rp.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 3. Acquiring a Reduced Intensity"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Acquire a reduced intensity (also called a structure factor) from the radial profile. The structure factor is what will subsequently be transformed into a PDF through a fourier transform.\n",
+ "\n",
+ "The structure factor $\\phi(s)$ is acquired by fitting a background scattering factor to the data, and then transforming the data by: \n",
+ "\n",
+ "$$\\phi(s) = \\frac{I(s) - N\\Delta c_{i}f_{i}^{2}}{N\\Delta c_{i}^{2}f_{i}^{2}}$$\n",
+ "\n",
+ "where s is the scattering vecot, $c_{i}$ and $f_{i}$ the atomic fraction and scattering factor respectively of each element in the sample, and N is a fitted parameter to the intensity."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To acquire the reduced intensity, we first initialise a ReducedIntensityGenerator1D object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "rigen = pxm.ReducedIntensityGenerator1D(rp)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We then fit an electron scattering factor to the profile. To do this, we need to define a list of elements and their respective atomic fractions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "elements = ['Si','O']\n",
+ "fracs = [0.333,0.667]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Then we will fit a background scattering factor. The scattering factor parametrisation used here is that specified by Lobato and Van Dyck [2]. The plot_fit parameter ensures we check the fitted profile.\n",
+ "\n",
+ "[2] Lobato, I., & Van Dyck, D. (2014). An accurate parameterization for scattering factors, electron densities and electrostatic potentials for neutral atoms that obey all physical constraints. Acta Crystallographica Section A: Foundations and Advances, 70(6), 636-649."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rigen.fit_atomic_scattering(elements,fracs,scattering_factor='lobato',plot_fit=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "That's clearly a terrible fit! This is because we're trying to fit the beam stop. To avoid this, we specify to fit to the 'tail end' of the data by specifying a minimum and maximum scattering angle range. This is generally recommended, as electron scattering factors tend to not include inelastic scattering, which means the factors are rarely perfect fits."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rigen.set_s_cutoff(s_min=1.5,s_max=4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rigen.fit_atomic_scattering(elements,fracs,scattering_factor='lobato',plot_fit=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "That's clearly much much better. Always inspect your fit."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally, we calculate the reduced intensity itself."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ri = rigen.get_reduced_intensity()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ri.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If it seems like the reduced intensity is not oscillating around 0 at high s, you should try fitting with a larger s_min. This generally speaking solves the issue."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 4. Damping the Reduced Intensity"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The reduced intensity acquired above does not go to zero at high s as it should because the maximum acquired scattering vector is not very high.\n",
+ "\n",
+ "This would result in significant oscillation in the PDF due to a discontinuity in the fourier transformed data. To combat this, the reduced intensity is damped. In the X-ray community a common damping functions are the Lorch function and an exponential damping function. Both are supported here.\n",
+ "\n",
+ "It is worth noting that damping does reduce the resolution in r in the PDF."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ri.damp_exponential(b=0.1)\n",
+ "ri.plot()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ri.damp_lorch(s_max=4)\n",
+ "ri.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Additionally, it is recommended to damp the low s regime. We use an error function to do that "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ri.damp_low_q_region_erfc(offset=4)\n",
+ "ri.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If the function ends up overdamped, you can simply reacquire the reduced intensity using:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ri = rigen.get_reduced_intensity()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 5. Acquiring a PDF"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally, a PDF is acquired from the damped reduced intensity. This is done by a fourier sine transform. \n",
+ "To ignore parts of the scattering data that are too noisy, you can set a minimum and maximum scattering angle for the transform.\n",
+ "\n",
+ "First, we initialise a PDFGenerator1D object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdfgen = pxm.PDFGenerator1D(ri)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Secify a minimum and maximum scattering angle. The maximum must be equivalent to the Lorch function s_max if the Lorch function is used to damp. Otherwise the Lorch function damping can cause artifact in the PDF."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "s_min = 0.\n",
+ "s_max = 4."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally we get the PDF. r_max specifies the maximum real space distance we want to interpret."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf = pdfgen.get_pdf(s_min=s_min, s_max=s_max, r_max=10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The PDF can then be saved."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf.save('Demo-PDF.hspy')"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}