05 Simulate Data - Strain Mapping.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial demonstrates different routes to obtain strain maps from scanning electron diffraction data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code functionality is illustrated using synthetic data, which is first generated using pyxem. This synthetic data represents a simple cubic crystal that is distorted to a tetragonal stucture. The intention is for this to provide an easy to understand illustration of the code functionality rather than to model any physical system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This functionaility has been checked to run in pyxem-0.13.0 (Jan 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": [
    "# Contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. <a href='#gen'> Setting up & Creating Synthetic Data</a>\n",
    "2. <a href='#aff'> Image Affine Transform Based Mapping</a>\n",
    "3. <a href='#vec'> Vector Based Mapping</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='gen'></a> 1. Setting up & Creating Synthetic Data"
   ]
  },
  {
   "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\n",
    "import hyperspy.api as hs\n",
    "import diffpy.structure\n",
    "from matplotlib import pyplot as plt\n",
    "from pyxem.generators.indexation_generator import IndexationGenerator\n",
    "from diffsims.generators.diffraction_generator import DiffractionGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a structure for the creation of synthetic data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latt = diffpy.structure.lattice.Lattice(3,3,3,90,90,90)\n",
    "atom = diffpy.structure.atom.Atom(atype='Ni',xyz=[0,0,0],lattice=latt)\n",
    "structure = diffpy.structure.Structure(atoms=[atom],lattice=latt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simulate an electron diffraction pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ediff = DiffractionGenerator(300.)\n",
    "diffraction = ediff.calculate_ed_data(structure,\n",
    "                                      reciprocal_radius=5.,\n",
    "                                      max_excitation_error=0.025, \n",
    "                                      with_direct_beam=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check we have some spots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diffraction.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and that they play nice with our \"detector\" configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = diffraction.get_diffraction_pattern(128,5)\n",
    "plt.imshow(pattern)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason this looks \"off\" is that we haven't calibrated our pattern, once we do so we get a nice clean pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diffraction.calibration = 1e-2\n",
    "pattern = diffraction.get_diffraction_pattern(128,5)\n",
    "plt.imshow(pattern)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a distorted structure and simulate diffraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latt = diffpy.structure.lattice.Lattice(3+0.12,3+0.12,3,90,90,90)\n",
    "atom = diffpy.structure.atom.Atom(atype='Ni',xyz=[0,0,0],lattice=latt)\n",
    "structure_d = diffpy.structure.Structure(atoms=[atom],lattice=latt)\n",
    "diffractiond = ediff.calculate_ed_data(structure_d, reciprocal_radius=5.,\n",
    "                                       max_excitation_error=0.025,\n",
    "                                       with_direct_beam=False)\n",
    "diffractiond.calibration = 1e-2\n",
    "patternd = diffractiond.get_diffraction_pattern(128,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copy the data and stitch patterns together with distortions applied to the patterns to make a 2x2 map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp = pxm.signals.ElectronDiffraction2D((np.asarray([[pattern,patternd],[pattern,pattern]])))\n",
    "\n",
    "x_l = []\n",
    "for x in [0, 0, -0.01, 0.02]:\n",
    "    x_s = np.eye(3)\n",
    "    x_s[0,0] += x\n",
    "    x_l.append(x_s)\n",
    "\n",
    "angles = hs.signals.Signal2D(np.asarray(x_l).reshape(2,2,3,3))\n",
    "dp = dp.apply_affine_transformation(D=angles,order=1,inplace=False)\n",
    "dp.set_diffraction_calibration(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the synthetic data to visualise distortions to be mapped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.plot(cmap='inferno')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='vec'></a> 2. Vector Based Mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import pyxem modules for vector based strain mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyxem.generators.subpixelrefinement_generator import SubpixelrefinementGenerator\n",
    "from pyxem.signals.tensor_field import *\n",
    "from pyxem.generators.displacement_gradient_tensor_generator import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finding the two peaks to be used for strain mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.plot()\n",
    "\n",
    "x_peak = [24,0]\n",
    "y_peak = [0,-42]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Determine peak positions to subpixel precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spg = SubpixelrefinementGenerator(dp, np.asarray([x_peak,y_peak]))\n",
    "Vs = spg.center_of_mass_method(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare distorted and undistorted diffraction vectors to obtain a strain map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D = get_DisplacementGradientMap(hs.signals.Signal2D(Vs), Vs.data[0,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The warnings in this cell and the next one can be ignored and they will be removed in the next patch version\n",
    "# see https://github.com/pyxem/pyxem/issues/716\n",
    "strain_map = D.get_strain_maps()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strain_map.plot(cmap='seismic',vmax=0.04,vmin=-0.04)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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"
  },
  "widgets": {
   "state": {
    "280e931f7b274209a009d92f04098e5c": {
     "views": [
      {
       "cell_index": 54
      }
     ]
    },
    "3d704cd8716e4cb1bf00a7c4e9fe1330": {
     "views": [
      {
       "cell_index": 34
      }
     ]
    },
    "477fdf6035284f3ca253bc694d701370": {
     "views": [
      {
       "cell_index": 24
      }
     ]
    },
    "48d9b9d421a14ddc9e73f084d5fc5e37": {
     "views": [
      {
       "cell_index": 30
      }
     ]
    },
    "635d08b3b596415ab27d7bed3b684f91": {
     "views": [
      {
       "cell_index": 48
      }
     ]
    },
    "64f45a95642f400ea7d3bed5fecff420": {
     "views": [
      {
       "cell_index": 52
      }
     ]
    },
    "7618040a46fc4203b76648a4d1383a11": {
     "views": [
      {
       "cell_index": 28
      }
     ]
    },
    "bb0e63a793d34b2bb255c5dca59a5aa3": {
     "views": [
      {
       "cell_index": 54
      }
     ]
    }
   },
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}