docs/source/Deformation_and_dislocations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deformation and Dislocations\n",
    "\n",
    "Perfectly periodic lattices are interesting, but in practical applications it is often desirable to study imperfect lattices. To compare to such pratical applications, `latticegen`s lattice generation functions support general deformations via the `shift=` keyword argument. \n",
    "\n",
    "This allows for two main classes of deformations: topologically trivial, deformations via a continuous deformation field and edge dislocations, where a discontinuous deformation field corresponds to a missing row of unit cells, yielding a topological point defect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import latticegen\n",
    "from latticegen.singularities import singularity_shift"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continuous deformation field\n",
    "\n",
    "First, let's look at an example of a simple continuous deformation, in the variable `shift`. It should consist of two stacked arrays, each the same size/shape as the intended final lattice, (500x500) by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = 250\n",
    "r_k = 0.05\n",
    "xp, yp = np.mgrid[-S:S, -S:S]\n",
    "xshift = 0.5*xp*np.exp(-0.5 * ((xp/(2*S/8))**2 + 1.2*(yp/(2*S/6))**2))\n",
    "shift = np.stack([xshift, np.zeros_like(xshift)])\n",
    "a = 30\n",
    "plt.quiver(xp[::a,::a], yp[::a,::a],\n",
    "          *-shift[:,::a,::a],  # There is a minus sign still wrong.\n",
    "           units='xy', scale=1, angles='xy')\n",
    "plt.gca().set_aspect('equal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lattice = latticegen.hexlattice_gen(r_k=r_k, theta=0, \n",
    "                                    order=2, shift=shift)\n",
    "plt.imshow(lattice.T, origin='lower')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Edge Dislocations\n",
    "\n",
    "In a two-dimensional lattice, the [edge dislocation](https://en.wikipedia.org/wiki/Dislocation#Edge) is the only fundamental dislocation. `latticegen` supports rendering such dislocations using [singularity_shift()](api.rst#latticegen.singularities.singularity_shift) to generate a corresponding deformation array (*dis*continuous now)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = np.array([90,90])\n",
    "shift = singularity_shift(r_k, 5)\n",
    "singularity = latticegen.hexlattice_gen(r_k, 5, 3, shift=shift)\n",
    "shift2 = singularity_shift(r_k, 5, position=l1, alpha=np.pi)\n",
    "singularity2 = latticegen.hexlattice_gen(r_k, 5, 3, shift=shift2)\n",
    "ssum = latticegen.hexlattice_gen(r_k, 5, 3, shift=shift2+shift)\n",
    "fig, ax = plt.subplots(figsize=[12,12], ncols=2, nrows=2)\n",
    "ax=ax.flat\n",
    "ax[0].imshow(singularity.compute().T)\n",
    "ax[0].set_title('Singularity 1')\n",
    "ax[1].imshow(singularity2.compute().T)\n",
    "ax[1].set_title('Singularity 2')\n",
    "ax[2].imshow(ssum.compute().T)\n",
    "ax[2].set_title('Both singularities')\n",
    "ax[3].set_title('Difference')\n",
    "ax[3].imshow(ssum.compute().T - latticegen.hexlattice_gen(r_k, 5, 3).T.compute(),\n",
    "             cmap='seismic')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Edge dislocation in a moiré lattice\n",
    "As [D.C. Cosma et al.](https://doi.org/10.1039/C4FD00146J) describe, an atomic edge dislocation in a moiré lattice is magnified to a corresponding edge dislocation in the moiré lattice.\n",
    "\n",
    "With this information a more complex example of the use of `latticegen` is shown below.\n",
    "\n",
    "To illustrate the effect of the moiré lattice on the dislocation, we recreate an adapted version of the relevant panels from Figure 3 of [De Jong et al.](https://arxiv.org/abs/2107.14716)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = 600  #Size of visualization in pixels. \n",
    "r_k = 0.05\n",
    "xi0 = 0\n",
    "alphai=3\n",
    "sshift = singularity_shift(r_k, xi0, S, alpha=2*np.pi*alphai/6) \n",
    "lattice1 = 0.7 * latticegen.hexlattice_gen(r_k, xi0, 3, S, \n",
    "                                           shift=sshift, chunks=400).compute()\n",
    "lattice1 -= lattice1.min()\n",
    "\n",
    "theta = 10\n",
    "l2_shift = np.array([-1.5, -2])\n",
    "lattice2 = latticegen.hexlattice_gen(r_k, xi0+theta, 3, S, \n",
    "                                     shift=l2_shift, chunks=400).compute()\n",
    "lattice2 -= lattice2.min()\n",
    "moire = np.sqrt((lattice1)**2 + (lattice2)**2)\n",
    "\n",
    "z = 4\n",
    "r = slice((z-1)*S//z//2, (z+1)*S//z//2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(ncols=3, figsize=[12, 5], constrained_layout=True)\n",
    "\n",
    "inset_extent = [r.start, r.stop, r.start, r.stop]\n",
    "\n",
    "axs[0].imshow(lattice1[r,r].T,\n",
    "              origin='lower',\n",
    "              extent=inset_extent,\n",
    "                  )\n",
    "axs[1].imshow(moire.T,\n",
    "               origin='lower',\n",
    "          )\n",
    "axs[2].imshow(lattice2[r,r].T, \n",
    "                 origin='lower',\n",
    "                 extent=inset_extent,\n",
    "      )\n",
    "\n",
    "axs[0].set_title('Bottom layer:\\n single dislocation')\n",
    "axs[1].set_title('Stacked graphene layers')\n",
    "axs[2].set_title(f'Top layer: rotated by θ$ = ${theta}°')\n",
    "\n",
    "rect = mpl.patches.Rectangle((r.start,r.start), \n",
    "                             (r.stop-r.start), (r.stop-r.start),\n",
    "                             edgecolor='red',\n",
    "                             facecolor='none')\n",
    "axs[1].add_patch(rect)\n",
    "\n",
    "for ax in [axs[0], axs[2]]:\n",
    "    for axis in ['top','bottom','left','right']:\n",
    "        ax.spines[axis].set_color(\"red\")"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}