02 GaAs Nanowire - Phase Mapping - Orientation Mapping.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial demonstrates how to achieve phase and orientation mapping via scanning electron diffraction using both pattern and vector matching."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data was acquired from a GaAs nanowire displaying polymorphism between zinc blende and wurtzite structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This functionaility has been checked to run in pyxem-0.13.0 (Feb 2021). 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": [
    "1. <a href='#loa'> Load & Inspect Data</a>\n",
    "2. <a href='#pre'> Pre-processing</a>\n",
    "3. <a href='#tem'> Template matching</a>\n",
    "    1. <a href='#tema'> [Build Template Library]</a>\n",
    "    2. <a href='#temb'>[Indexing]</a>\n",
    "4. <a href='#vec'> Vector Matching</a>\n",
    "    1. <a href='#veca'> [Build Vector Library]</a>\n",
    "    2. <a href='#vecb'>[Indexing Vectors]</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import pyxem and other required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib qt\n",
    "\n",
    "import numpy as np\n",
    "import diffpy.structure\n",
    "import pyxem as pxm\n",
    "import hyperspy.api as hs\n",
    "\n",
    "accelarating_voltage = 200  # kV\n",
    "camera_length = 0.2  # m\n",
    "diffraction_calibration = 0.032  # px / Angstrom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='loa'></a> 1. Loading and Inspection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the demo data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp = hs.load('./data/02/polymorphic_nanowire.hdf5')\n",
    "dp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crop a subset of the data to be analyzed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp = dp.inav[90:110, 30:75]\n",
    "dp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set data type, scale intensity range and set calibration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.data = dp.data.astype('float64')\n",
    "dp.data *= 1 / dp.data.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inspect metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot an interactive virtual image to inspect data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "roi = hs.roi.CircleROI(cx=72, cy=72, r_inner=0, r=2)\n",
    "dp.plot_integrated_intensity(roi=roi, cmap='viridis')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='pre'></a> 2. Pre-processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply affine transformation to correct for off axis camera geometry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scale_x = 0.995\n",
    "scale_y = 1.031\n",
    "offset_x = 0.631\n",
    "offset_y = -0.351\n",
    "dp.apply_affine_transformation(np.array([[scale_x, 0, offset_x],\n",
    "                                         [0, scale_y, offset_y],\n",
    "                                         [0, 0, 1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform difference of gaussian background subtraction with various parameters on one selected diffraction pattern and plot to identify good parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyxem.utils.expt_utils import investigate_dog_background_removal_interactive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp_test_area = dp.inav[0, 0]\n",
    "\n",
    "gauss_stddev_maxs = np.arange(2, 12, 0.2) # min, max, step\n",
    "gauss_stddev_mins = np.arange(1, 4, 0.2) # min, max, step\n",
    "\n",
    "investigate_dog_background_removal_interactive(dp_test_area,\n",
    "                                               gauss_stddev_maxs,\n",
    "                                               gauss_stddev_mins)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove background using difference of gaussians method with parameters identified above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp = dp.subtract_diffraction_background('difference of gaussians',\n",
    "                          min_sigma=2, max_sigma=8,\n",
    "                          lazy_result=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform further adjustments to the data ranges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.data -= dp.data.min()\n",
    "dp.data *= 1 / dp.data.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set diffraction calibration and scan calibration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp = pxm.signals.ElectronDiffraction2D(dp) #this is needed because of a bug in the code\n",
    "dp.set_diffraction_calibration(diffraction_calibration)\n",
    "dp.set_scan_calibration(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='tem'></a> 3. Pattern Matching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pattern matching generates a database of simulated diffraction patterns and then compares all simulated patterns against each experimental pattern to find the best match"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import generators required for simulation and indexation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from diffsims.libraries.structure_library import StructureLibrary\n",
    "from diffsims.generators.diffraction_generator import DiffractionGenerator\n",
    "from diffsims.generators.library_generator import DiffractionLibraryGenerator\n",
    "\n",
    "from diffsims.generators.zap_map_generator import get_rotation_from_z_to_direction\n",
    "from diffsims.generators.rotation_list_generators import get_grid_around_beam_direction\n",
    "\n",
    "from pyxem.generators.indexation_generator import TemplateIndexationGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1. Define Library of Structures & Orientations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the crystal phases to be included in the simulated library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "structure_zb = diffpy.structure.loadStructure('./data/02/GaAs_mp-2534_conventional_standard.cif')\n",
    "structure_wz = diffpy.structure.loadStructure('./data/02/GaAs_mp-8883_conventional_standard.cif')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a basic rotations list.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "za110c = get_rotation_from_z_to_direction(structure_zb, [1,1,0])\n",
    "rot_list_cubic = get_grid_around_beam_direction(beam_rotation=za110c, resolution=1, angular_range=(0,180))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "za110h = get_rotation_from_z_to_direction(structure_wz, [1,1,0])\n",
    "rot_list_hex = get_grid_around_beam_direction(beam_rotation=za110h, resolution=1, angular_range=(0,180))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construct a StructureLibrary defining crystal structures and orientations for which diffraction will be simulated "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struc_lib = StructureLibrary(['ZB','WZ'],\n",
    "                             [structure_zb,structure_wz],\n",
    "                             [rot_list_cubic,rot_list_hex])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='temb'></a> 3.2. Simulate Diffraction for all Structures & Orientations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a diffsims DiffractionGenerator with diffraction simulation parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff_gen = DiffractionGenerator(accelerating_voltage=accelarating_voltage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize a diffsims DiffractionLibraryGenerator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lib_gen = DiffractionLibraryGenerator(diff_gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calulate library of diffraction patterns for all phases and unique orientations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_pattern_dimension_pixels = dp.axes_manager.signal_shape[0]\n",
    "half_size = target_pattern_dimension_pixels // 2\n",
    "reciprocal_radius = diffraction_calibration*(half_size - 1)\n",
    "\n",
    "diff_lib = lib_gen.get_diffraction_library(struc_lib,\n",
    "                                           calibration=diffraction_calibration,\n",
    "                                           reciprocal_radius=reciprocal_radius,\n",
    "                                           half_shape=(half_size, half_size),\n",
    "                                           max_excitation_error=1/10,\n",
    "                                           with_direct_beam=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optionally, save the library for later use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff_lib.pickle_library('./GaAs_cubic_hex.pickle')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If saved, the library can be loaded as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from diffsims.libraries.diffraction_library import load_DiffractionLibrary\n",
    "\n",
    "diff_lib = load_DiffractionLibrary('./GaAs_cubic_hex.pickle', safety=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='temb'></a> 3.3. Pattern Matching Indexation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize `TemplateIndexationGenerator` with the experimental data and diffraction library and perform correlation, returning the `n_largest` matches with highest correlation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\"><b>Note:</b> This workflow has been changed from previous version, make sure you have pyxem 0.13.0 or later installed</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indexer = TemplateIndexationGenerator(dp, diff_lib)\n",
    "indexation_results = indexer.correlate(n_largest=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the solutions via a plotting (can be slow, so we don't run by default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "    indexation_results.plot_best_matching_results_on_signal(dp, diff_lib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get crystallographic map from indexation results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crystal_map = indexation_results.to_crystal_map()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "crystal_map is now a CrystalMap object, which comes from orix, see their documentation for details. Below we lift their code to plot a phase map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "from orix import plot\n",
    "\n",
    "fig, ax = plt.subplots(subplot_kw=dict(projection=\"plot_map\"))\n",
    "im = ax.plot_map(crystal_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='vec'></a> 4. Vector Matching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\"><b>Note:</b> This workflow is less well developed than the template matching one, and may well be broken</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vector matching generates a database of vector pairs (magnitues and inter-vector angles) and then compares all theoretical values against each measured diffraction vector pair to find the best match"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import generators required for simulation and indexation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from diffsims.generators.library_generator import VectorLibraryGenerator\n",
    "from diffsims.libraries.structure_library import StructureLibrary\n",
    "from diffsims.libraries.vector_library import load_VectorLibrary\n",
    "\n",
    "from pyxem.generators.indexation_generator import VectorIndexationGenerator\n",
    "\n",
    "from pyxem.generators.subpixelrefinement_generator import SubpixelrefinementGenerator\n",
    "from pyxem.signals.diffraction_vectors import DiffractionVectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='veca'></a> 4.1. Define Library of Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define crystal structure for which to determine theoretical vector pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "structure_zb = diffpy.structure.loadStructure('./data/02/GaAs_mp-2534_conventional_standard.cif')\n",
    "structure_wz = diffpy.structure.loadStructure('./data/02/GaAs_mp-8883_conventional_standard.cif')\n",
    "\n",
    "structure_library = StructureLibrary(['ZB', 'WZ'],\n",
    "                                     [structure_zb, structure_wz],\n",
    "                                     [[], []])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize VectorLibraryGenerator with structures to be considered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vlib_gen = VectorLibraryGenerator(structure_library)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Determine VectorLibrary with all vectors within given reciprocal radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reciprocal_radius = diffraction_calibration*(half_size - 1)\n",
    "\n",
    "vec_lib = vlib_gen.get_vector_library(reciprocal_radius)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optionally, save the library for later use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_lib.pickle_library('./GaAs_cubic_hex_vectors.pickle')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_lib = load_VectorLibrary('./GaAs_cubic_hex_vectors.pickle',\n",
    "                             safety=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2. Find Diffraction Peaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tune peak finding parameters interactively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.find_peaks(interactive=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform peak finding on the data with parameters from above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peaks = dp.find_peaks(method='difference_of_gaussian',\n",
    "                      min_sigma=0.005,\n",
    "                      max_sigma=5.0,\n",
    "                      sigma_ratio=2.0,\n",
    "                      threshold=0.06,\n",
    "                      overlap=0.8,\n",
    "                      interactive=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "coaxing peaks back into a DiffractionVectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peaks = DiffractionVectors(peaks).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`peaks` now contain the 2D positions of the diffraction spots on the detector. The vector matching method works in 3D coordinates, which are found by projecting the detector positions back onto the Ewald sphere. Because the methods that follow are slow, we constrain ourselves to looking at a smaller subset of the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peaks = peaks.inav[:2,:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peaks.calculate_cartesian_coordinates?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peaks.calculate_cartesian_coordinates(accelerating_voltage=accelarating_voltage,\n",
    "                                      camera_length=camera_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='vecb'></a> 4.3. Vector Matching Indexation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize `VectorIndexationGenerator` with the experimental data and vector library and perform indexation using `n_peaks_to_index` and returning the `n_best` indexation results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\"><b>Alert: This code no longer works on this example, and may even be completely broken. Caution is advised.</b> </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indexation_generator = VectorIndexationGenerator(peaks, vec_lib)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indexation_results = indexation_generator.index_vectors(mag_tol=3*diffraction_calibration,\n",
    "                                                        angle_tol=4,  # degree\n",
    "                                                        index_error_tol=0.2,\n",
    "                                                        n_peaks_to_index=7,\n",
    "                                                        n_best=5,\n",
    "                                                        show_progressbar=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indexation_results.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Refine all crystal orientations for improved phase reliability and orientation reliability maps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "refined_results = indexation_generator.refine_n_best_orientations(indexation_results,\n",
    "                                                                  accelarating_voltage=accelarating_voltage,\n",
    "                                                                  camera_length=camera_length,\n",
    "                                                                  index_error_tol=0.2,\n",
    "                                                                  vary_angles=True,\n",
    "                                                                  vary_scale=True,\n",
    "                                                                  method=\"leastsq\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get crystallographic map from optimized indexation results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crystal_map = refined_results.get_crystallographic_map()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the objections documentation for further details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crystal_map?"
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}