ebsd1_preprocess.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d951f637-54a7-4dda-9f76-ccdb900ad1e1",
   "metadata": {},
   "source": [
    "# Pre-process EBSD patterns from an Al-steel joint\n",
    "\n",
    "Håkon Wiik Ånes (hakon.w.anes@ntnu.no)\n",
    "\n",
    "See the relevant package documentation for more details on the packages used here:\n",
    "* diffsims: https://diffsims.readthedocs.io/en/latest/\n",
    "* kikuchipy: https://kikuchipy.org/en/stable/\n",
    "* hyperspy: hyperspy.org/hyperspy-doc/current/\n",
    "* pyebsdindex: https://pyebsdindex.readthedocs.io/en/latest/\n",
    "* orix: https://orix.readthedocs.io/en/stable/\n",
    "\n",
    "Import required packages and print their versions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "dd9a1423-ca4d-4c14-b4f8-9d45fda369c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run date:  2022-05-27\n",
      "\n",
      "Software versions\n",
      "------------------\n",
      "dask : 2022.5.0\n",
      "diffpy.structure : 3.0.1\n",
      "diffsims : 0.4.2\n",
      "hyperspy : 1.7.0\n",
      "kikuchipy : 0.6.dev0\n",
      "matplotlib : 3.5.2\n",
      "numpy : 1.21.6\n",
      "pyebsdindex : 0.1.dev1\n",
      "orix : 0.9.0\n"
     ]
    }
   ],
   "source": [
    "# Replace \"inline\" with \"qt5\" from the pyqt package for interactive plotting\n",
    "%matplotlib qt5\n",
    "\n",
    "from datetime import date\n",
    "import importlib_metadata\n",
    "import os\n",
    "\n",
    "import dask\n",
    "from dask.diagnostics import ProgressBar\n",
    "from diffpy.structure import Lattice, Structure\n",
    "from diffsims.crystallography import ReciprocalLatticePoint\n",
    "import hyperspy.api as hs\n",
    "import kikuchipy as kp\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from pyebsdindex import ebsd_index, pcopt\n",
    "from orix import io, plot, sampling\n",
    "from orix.crystal_map import CrystalMap, PhaseList\n",
    "from orix.quaternion import Rotation\n",
    "\n",
    "\n",
    "# Directories\n",
    "dset = \"a\"\n",
    "dir_mp = \"/home/hakon/kode/emsoft/emdata/crystal_data\"\n",
    "dir_data = os.path.join(\"/home/hakon/phd/data/tina\", dset)\n",
    "dir_nordif = os.path.join(dir_data, \"nordif\")\n",
    "dir_kp = os.path.join(dir_data, \"kp\")\n",
    "\n",
    "# Data set specific parameters\n",
    "# Dataset naming (a-c) = (I-III)\n",
    "cal_pats_al = {\"a\": [0, 1, 2, 3], \"b\": [0, 1, 2, 3], \"c\": [0, 1, 2]}\n",
    "pc0 = {\"a\": (0.42, 0.80, 0.51), \"b\": (0.42, 0.80, 0.51), \"c\": (0.41, 0.81, 0.52)}\n",
    "\n",
    "# Matplotlib\n",
    "plt.rcParams.update({\"figure.figsize\": (5, 5), \"font.size\": 12})\n",
    "savefig_kw = dict(bbox_inches=\"tight\", pad_inches=0, dpi=150)\n",
    "\n",
    "print(\"Run date: \", date.today())\n",
    "print(\"\\nSoftware versions\\n------------------\")\n",
    "for pkg in [\n",
    "    \"dask\",\n",
    "    \"diffpy.structure\",\n",
    "    \"diffsims\",\n",
    "    \"hyperspy\",\n",
    "    \"kikuchipy\",\n",
    "    \"matplotlib\",\n",
    "    \"numpy\",\n",
    "    \"pyebsdindex\",\n",
    "    \"orix\",\n",
    "]:\n",
    "    if pkg == \"numpy\":\n",
    "        ver = np.__version__\n",
    "    else:\n",
    "        ver = importlib_metadata.version(pkg)\n",
    "    print(pkg, \":\", ver)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d97e4a7e-1ea2-4388-9e34-3fdfc7510d91",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Pre-correction maps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d704eab2-af4e-432c-951e-ffb1dbf9b3d7",
   "metadata": {},
   "source": [
    "Load data into memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ebadffb9-2b1b-449f-80f9-29234e6c9ce1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<EBSD, title: Pattern, dimensions: (148, 50|240, 240)>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = kp.load(os.path.join(dir_nordif, \"Pattern.dat\"), lazy=False)\n",
    "sig_shape = s.axes_manager.signal_shape[::-1]\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c564a705-a1c4-46bc-b678-0b9c8ec0fd84",
   "metadata": {},
   "source": [
    "Obtain a mean intensity map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dc2210e8-b8d6-46bf-afb0-9129bf9e599c",
   "metadata": {},
   "outputs": [],
   "source": [
    "s_mean = s.mean(axis=s.axes_manager.signal_axes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a602704-589d-44b3-a0f3-2b2307ec5c78",
   "metadata": {},
   "source": [
    "Save unprocessed map and contrast stretched map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0af64e88-fb28-4b31-ba34-fb3dc90e3030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unprocessed map\n",
    "map_mean1 = s_mean.data\n",
    "plt.imsave(os.path.join(dir_kp, \"maps_mean.png\"), map_mean1, cmap=\"gray\")\n",
    "\n",
    "# Contrast stretched map\n",
    "percentiles = np.percentile(map_mean1, q=(1, 99))\n",
    "map_mean2 = kp.pattern.rescale_intensity(map_mean1, in_range=percentiles)\n",
    "plt.imsave(os.path.join(dir_kp, \"maps_mean_q1_q99.png\"), map_mean2, cmap=\"gray\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eedb46a0-ba0d-41ba-a581-4aa5e2bd7e12",
   "metadata": {},
   "source": [
    "Background correction:\n",
    "1. Remove static background\n",
    "2. Remove dynamic background\n",
    "3. Average patterns with their eight nearest neighbour using a Gaussian kernel with $\\sigma$ = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6a8a6cb5-5b2a-4b44-a55b-e2620a1ac268",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing the static background:\n",
      "[########################################] | 100% Completed |  0.1s\n",
      "[########################################] | 100% Completed |  0.6s\n"
     ]
    }
   ],
   "source": [
    "s.remove_static_background()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6c0a1c34-2ffd-43c7-90ab-074f728277ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing the dynamic background:\n",
      "[########################################] | 100% Completed |  0.1s\n",
      "[########################################] | 100% Completed |  6.6s\n"
     ]
    }
   ],
   "source": [
    "s.remove_dynamic_background()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "804fe96d-2d67-47e4-9dfb-667e125eb308",
   "metadata": {},
   "outputs": [],
   "source": [
    "w = kp.filters.Window(window=\"gaussian\", shape=(3, 3), std=1)\n",
    "w.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "30c9b445-599a-419c-b322-5316cbdfe695",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Averaging with the neighbour patterns:\n",
      "[########################################] | 100% Completed |  7.4s\n"
     ]
    }
   ],
   "source": [
    "s.average_neighbour_patterns(window=w)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87ee96cd-3a9a-4875-95ec-29546010ce5f",
   "metadata": {},
   "source": [
    "Save processed patterns to file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2c373ca1-489f-4874-89f6-fd2313c1cbc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.005268482367197672 min\n"
     ]
    }
   ],
   "source": [
    "s.save(os.path.join(dir_kp, \"pattern_sda.h5\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c953a54-7aa4-4f03-b37f-a1b197c099a2",
   "metadata": {},
   "source": [
    "## Pre-indexing maps\n",
    "\n",
    "Generate image quality $\\mathbf{Q}$ and average dot product maps and save to\n",
    "file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e4f06559-3646-4c4d-8837-efff3d620ace",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating the image quality:\n",
      "[########################################] | 100% Completed |  0.1s\n",
      "[########################################] | 100% Completed |  4.7s\n"
     ]
    }
   ],
   "source": [
    "iq = s.get_image_quality()\n",
    "plt.imsave(os.path.join(dir_kp, \"maps_iq.png\"), arr=iq, cmap=\"gray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "da18ded6-8e61-4211-bc59-000daa3521d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating average neighbour dot product map:\n",
      "[########################################] | 100% Completed | 12.7s\n"
     ]
    }
   ],
   "source": [
    "adp = s.get_average_neighbour_dot_product_map()\n",
    "plt.imsave(os.path.join(dir_kp, \"maps_adp.png\"), arr=adp, cmap=\"gray\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "046dbb9e-3f52-4565-bbdf-cb8af6c6fce6",
   "metadata": {},
   "source": [
    "## Projection center from PyEBSDIndex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e77c6599",
   "metadata": {},
   "source": [
    "Load calibration patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "08ea1d69-ece2-4aa7-b336-2bb94702ccf0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<EBSD, title: Calibration patterns, dimensions: (2|240, 240)>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s_cal0 = kp.load(os.path.join(dir_nordif, \"Setting.txt\"))\n",
    "sig_shape_cal = s_cal0.axes_manager.signal_shape[::-1]\n",
    "#s_cal0.static_background = s.static_background.copy()\n",
    "s_cal0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cedfe87b-491f-48fe-b07e-601870cd9757",
   "metadata": {},
   "source": [
    "Remove background"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6f3610c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing the static background:\n",
      "[########################################] | 100% Completed |  0.1s\n",
      "[########################################] | 100% Completed |  0.1s\n",
      "Removing the dynamic background:\n",
      "[########################################] | 100% Completed |  0.1s\n",
      "[########################################] | 100% Completed |  0.1s\n"
     ]
    }
   ],
   "source": [
    "s_cal0.remove_static_background()\n",
    "s_cal0.remove_dynamic_background()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c8b457f-e694-459c-9cbd-6a0e45f2e72c",
   "metadata": {},
   "source": [
    "Identify Al and $\\alpha$-Fe patterns, as `PyEBSDIndex` can only (Hough) index\n",
    "cubic phases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "dab00796-8fc1-4afd-a83f-c75c55efc05b",
   "metadata": {},
   "outputs": [],
   "source": [
    "s_cal0.plot(navigator=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "835d07c3-13e3-4686-819e-a475f107eabe",
   "metadata": {},
   "source": [
    "Extract Al or $\\alpha$-Fe patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "824d7704",
   "metadata": {},
   "outputs": [],
   "source": [
    "s_cal = kp.signals.EBSD(s_cal0.data[cal_pats_al[dset]])\n",
    "s_cal.axes_manager[0].name = \"x\"\n",
    "nav_size = s_cal.axes_manager.navigation_size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf5f6445-3636-42b6-954f-890bc6e5435d",
   "metadata": {},
   "source": [
    "Extract relevant metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1353490d-542b-43f8-a78d-5f1c9364f4ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "md_sem = s_cal0.metadata.Acquisition_instrument.SEM\n",
    "md_ebsd = md_sem.Detector.EBSD\n",
    "sample_tilt = md_ebsd.sample_tilt  # Degrees\n",
    "camera_tilt = md_ebsd.azimuth_angle  # Degrees\n",
    "energy = md_sem.beam_energy  # kV"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9897b001-b8fe-4bf2-b559-751ea743e762",
   "metadata": {},
   "source": [
    "Generate an indexer instance with `PyEBSDIndex` for easy storage of relevant\n",
    "parameters used in projection center (PC) optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6ef1cc28",
   "metadata": {},
   "outputs": [],
   "source": [
    "indexer = ebsd_index.EBSDIndexer(\n",
    "    phaselist=[\"BCC\", \"FCC\"],\n",
    "    vendor=\"EDAX\",\n",
    "    PC=None,\n",
    "    sampleTilt=sample_tilt,\n",
    "    camElev=camera_tilt,\n",
    "    patDim=sig_shape_cal\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5651511",
   "metadata": {},
   "source": [
    "Determine PC from single pattern using an initial guess, as a test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e03eed16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.42, 0.81, 0.51)\n",
      "[0.42025143 0.80980777 0.51327385]\n"
     ]
    }
   ],
   "source": [
    "pc0_i = pc0[dset_no]\n",
    "print(pc0_i)\n",
    "\n",
    "pc = pcopt.optimize(s_cal.inav[0].data, indexer, PC0=pc0_i)\n",
    "print(pc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e9c7c0b",
   "metadata": {},
   "source": [
    "Determine PCs from all patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "fb5951ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.42025143 0.80980777 0.51327385]\n",
      " [0.42365032 0.81203585 0.51243699]]\n",
      "[0.42195087 0.81092181 0.51285542]\n"
     ]
    }
   ],
   "source": [
    "pcs = np.zeros((nav_size, 3))\n",
    "for i in range(nav_size):\n",
    "    pcs[i] = pcopt.optimize(s_cal.inav[i].data, indexer, PC0=pc0_i)\n",
    "print(pcs)\n",
    "\n",
    "pc = pcs.mean(axis=0)\n",
    "print(pc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ad3cf0e-5ff1-429a-bb87-c5da8e06fc66",
   "metadata": {},
   "source": [
    "Index calibration patterns to check PCs and extract rotations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6c5f7717",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = indexer.index_pats(\n",
    "    patsin=s_cal.data,\n",
    "    patstart=0,\n",
    "    npats=-1,\n",
    "    clparams=None,\n",
    "    PC=pc,\n",
    ")\n",
    "rot = Rotation(data[0][\"quat\"][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "603413ea-0d0c-42b1-9d55-4084b3402881",
   "metadata": {},
   "source": [
    "Are the patterns Fe or Al?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2b26211d-9413-42d9-9f3a-de1a437c92e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0]\n"
     ]
    }
   ],
   "source": [
    "phase_id = data[0][\"phase\"][2]\n",
    "print(phase_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "591ac395-1336-4e49-b9c9-f9b1f4d6a60c",
   "metadata": {},
   "source": [
    "Separate rotations into those of Fe and those of Al"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3064b2ac-ae3e-49ff-b376-c7cf23e60b5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "rot_fe = rot[phase_id == 0]\n",
    "#rot_al = rot[phase_id == 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abaca053-8c38-44d5-b65c-2f864acd0e28",
   "metadata": {},
   "source": [
    "Separate calibration patterns into those of Fe and those of Al"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "db868588-2d74-48f1-b2a1-2eb5d42d23d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "s_cal_fe = kp.signals.EBSD(s_cal.data[phase_id == 0]).squeeze()\n",
    "#s_cal_al = kp.signals.EBSD(s_cal.data[phase_id == 1]).squeeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "966988d6-6fb0-4c15-945a-c926c4860a4b",
   "metadata": {},
   "source": [
    "Describe the detector-sample geometry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c8630d48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "EBSDDetector (240, 240), px_size 1 um, binning 1, tilt 0.0, azimuthal 0, pc (0.422, 0.189, 0.513)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "detector = kp.detectors.EBSDDetector(\n",
    "    shape=sig_shape_cal,\n",
    "    pc=pc,  # Use average PC to reduce potential for single error upon refinement\n",
    "    sample_tilt=sample_tilt,\n",
    "    tilt=camera_tilt,\n",
    "    convention=\"edax\",\n",
    ")\n",
    "detector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e40f0617-6632-4520-b147-369948f94020",
   "metadata": {},
   "source": [
    "### Inspect Fe PCs\n",
    "\n",
    "Load Fe master pattern to use in PC refinement and to extract the Fe crystal structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "16a3be08-ee37-4677-a19c-7b02b59418d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "mp_fe = kp.load(\n",
    "    os.path.join(dir_mp, \"ferrite\", \"ferrite_mc_mp_20kv.h5\"),\n",
    "    projection=\"lambert\",\n",
    "    energy=energy,\n",
    "    hemisphere=\"north\",\n",
    ")\n",
    "mp_fe.phase.name = \"ferrite\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "604b8a35-2759-494b-b268-d76ae36af960",
   "metadata": {},
   "source": [
    "Inspect geometrical simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5082b393-a65f-45e4-a489-be13abfe71a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "rlp_fe = ReciprocalLatticePoint(phase=mp_fe.phase, hkl=((1, 1, 1), (2, 0, 0), (2, 2, 0), (3, 1, 1)))\n",
    "rpl_fe = rlp_fe[rlp_fe.allowed]\n",
    "rlp2_fe = rlp_fe.symmetrise()\n",
    "simgen_fe = kp.generators.EBSDSimulationGenerator(detector=detector, phase=rlp_fe.phase, rotations=rot_fe)\n",
    "geosim_fe = simgen_fe.geometrical_simulation(reciprocal_lattice_point=rlp2_fe)\n",
    "markers_fe = geosim_fe.as_markers(pc=False, bands=True, zone_axes_labels=False, zone_axes=False)\n",
    "\n",
    "#del s_cal_fe.metadata.Markers\n",
    "s_cal_fe.add_marker(marker=markers_fe, plot_marker=False, permanent=True)\n",
    "s_cal_fe.plot(navigator=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3788d423-8932-4c86-a2e7-aeceb6b83c83",
   "metadata": {},
   "source": [
    "Refine results from `PyEBSDIndex`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4279de67-c921-470f-ac2f-3aaa3281471f",
   "metadata": {},
   "outputs": [],
   "source": [
    "s_cal_fe.axes_manager[0].name = \"x\"  # Will be unnecessary in kikuchipy v0.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b71d6528-e057-4a12-8265-a5fac1a48a80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Refinement information:\n",
      "\tLocal optimization method: Nelder-Mead (minimize)\n",
      "\tKeyword arguments passed to method: {'method': 'Nelder-Mead'}\n",
      "Refining 2 orientation(s):\n",
      "[########################################] | 100% Completed |  2.2s\n",
      "Refinement speed: 0 patterns/s\n",
      "Refinement information:\n",
      "\tLocal optimization method: Nelder-Mead (minimize)\n",
      "\tKeyword arguments passed to method: {'method': 'Nelder-Mead'}\n",
      "Refining 2 projection center(s):\n",
      "[########################################] | 100% Completed |  0.8s\n",
      "Refinement speed: 2 patterns/s\n"
     ]
    }
   ],
   "source": [
    "xmap_fe = CrystalMap(rotations=rot_fe, phase_list=PhaseList(mp_fe.phase))\n",
    "\n",
    "# First refine orientations, then projection centers\n",
    "ref_kwargs = dict(detector=detector, master_pattern=mp_fe, energy=energy)\n",
    "xmap_fe_refined = s_cal_fe.refine_orientation(xmap=xmap_fe, **ref_kwargs)\n",
    "_, detector_fe_ref = s_cal_fe.refine_projection_center(xmap=xmap_fe_refined, **ref_kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43285fd8",
   "metadata": {},
   "source": [
    "Check geometrical simulations of refined orientations and PCs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "37f7d2c6-bc82-499a-9ac0-36d04ef8d731",
   "metadata": {},
   "outputs": [],
   "source": [
    "simgen_fe = kp.generators.EBSDSimulationGenerator(\n",
    "    detector=detector_fe_ref, phase=mp_fe.phase, rotations=xmap_fe_refined.rotations,\n",
    ")\n",
    "geosim_fe = simgen_fe.geometrical_simulation(reciprocal_lattice_point=rlp2_fe)\n",
    "markers_fe = geosim_fe.as_markers(pc=False, bands=True, zone_axes_labels=False, zone_axes=False)\n",
    "\n",
    "del s_cal_fe.metadata.Markers\n",
    "s_cal_fe.add_marker(marker=markers_fe, plot_marker=False, permanent=True)\n",
    "s_cal_fe.plot(navigator=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "866a6519-fff3-4fbd-98ca-ca87e4eee6ac",
   "metadata": {},
   "source": [
    "### Inspect Al PCs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b82c6780-9ee8-4ffe-a7cb-0587f7dec285",
   "metadata": {},
   "source": [
    "Load Al master pattern to use in PC refinement and to extract the Al crystal structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc92261b",
   "metadata": {},
   "outputs": [],
   "source": [
    "mp_al = kp.load(\n",
    "    os.path.join(dir_mp, \"al\", \"al_mc_mp_20kv.h5\"),\n",
    "    projection=\"lambert\",\n",
    "    energy=energy,\n",
    "    hemisphere=\"north\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eb22263-e544-4f56-b119-3147442b0e22",
   "metadata": {},
   "source": [
    "Inspect geometrical simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7778f034",
   "metadata": {},
   "outputs": [],
   "source": [
    "rlp_al = ReciprocalLatticePoint(phase=mp_al.phase, hkl=((1, 1, 1), (2, 0, 0), (2, 2, 0), (3, 1, 1)))\n",
    "rlp2_al = rlp_al.symmetrise()\n",
    "simgen_al = kp.generators.EBSDSimulationGenerator(detector=detector, phase=rlp_al.phase, rotations=rot_al)\n",
    "geosim_al = simgen_al.geometrical_simulation(reciprocal_lattice_point=rlp2_al)\n",
    "markers_al = geosim_al.as_markers(pc=False, bands=True, zone_axes_labels=False, zone_axes=False)\n",
    "\n",
    "#del s_cal_al.metadata.Markers\n",
    "s_cal_al.add_marker(marker=markers_al, plot_marker=False, permanent=True)\n",
    "s_cal_al.plot(navigator=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a8b4d9-a98e-4b6d-bd43-ae2fb5a6357d",
   "metadata": {},
   "source": [
    "Refine results from `PyEBSDIndex`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9069d89-a011-4d0d-bbb5-e71ead4b57e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "s_cal_al.axes_manager[0].name = \"x\"  # Will be unnecessary in kikuchipy v0.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaee5aee-9391-438e-b900-1a742852767c",
   "metadata": {},
   "outputs": [],
   "source": [
    "xmap_al = CrystalMap(rotations=rot_al, phase_list=PhaseList(mp_al.phase))\n",
    "\n",
    "# First refine orientations, then projection centers\n",
    "ref_kwargs = dict(detector=detector, master_pattern=mp_al, energy=energy)\n",
    "xmap_al_refined = s_cal_al.refine_orientation(xmap=xmap_al, **ref_kwargs)\n",
    "_, detector_al_ref = s_cal_al.refine_projection_center(xmap=xmap_al_refined, **ref_kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f4b5e20-d7d4-4ba2-90ba-8b9b67776f99",
   "metadata": {},
   "source": [
    "Check geometrical simulations of refined orientations and PCs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9f3e418-a287-4ca9-a009-5aa43f2587ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "simgen_al = kp.generators.EBSDSimulationGenerator(\n",
    "    detector=detector_al_ref, phase=mp_al.phase, rotations=xmap_al_refined.rotations,\n",
    ")\n",
    "geosim_al = simgen_al.geometrical_simulation(reciprocal_lattice_point=rlp2_al)\n",
    "markers_al = geosim_al.as_markers(pc=False, bands=True, zone_axes_labels=False, zone_axes=False)\n",
    "\n",
    "del s_cal_al.metadata.Markers\n",
    "s_cal_al.add_marker(marker=markers_al, plot_marker=False, permanent=True)\n",
    "s_cal_al.plot(navigator=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eff98864-e705-4855-a906-e1adbb4354a8",
   "metadata": {},
   "source": [
    "## Save PCs to file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "67bf4974-ef78-426b-9bd0-14e7976bb847",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\n",
    "    os.path.join(dir_kp, \"cal_pcs.txt\"),\n",
    "    np.column_stack((\n",
    "        cal_pats_al[dset],\n",
    "        np.row_stack((\n",
    "#            detector_al_ref.pc,\n",
    "            detector_fe_ref.pc\n",
    "        ))\n",
    "    )),\n",
    "    fmt=\"%i %.12f %.12f %.12f\",\n",
    "    header=\"Cal. pattern, PC (x, y, z) in Bruker's convention\"\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}