02-Crystallography.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib widget\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import chemiscope\n",
    "from widget_code_input import WidgetCodeInput\n",
    "from ipywidgets import Layout, Output, Textarea, HTML, HBox\n",
    "from scwidgets import (AnswerRegistry, TextareaAnswer, CodeDemo,\n",
    "                       ParametersBox, PyplotOutput, ClearedOutput,\n",
    "                       AnimationOutput,CheckRegistry,Answer)\n",
    "import ase\n",
    "from ase.io import read, write\n",
    "import itertools\n",
    "import functools    \n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "#### AVOID folding of output cell "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%html\n",
    "<style>\n",
    ".jp-CodeCell.jp-mod-outputsScrolled .jp-Cell-outputArea  {  height:auto !important;\n",
    "    max-height: 5000px; overflow-y: hidden }\n",
    "</style>\n",
    "<style>\n",
    ".output_wrapper, .output {\n",
    "    height:auto !important;\n",
    "    max-height:4000px;  /* your desired max-height here */\n",
    "}\n",
    ".output_scroll {\n",
    "    box-shadow:none !important;\n",
    "    webkit-box-shadow:none !important;\n",
    "}\n",
    "</style>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please enter your name as `SurnameName` to initialize the answer file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_registry = CheckRegistry() \n",
    "answer_registry = AnswerRegistry(prefix=\"module_02\")\n",
    "display(answer_registry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can write here general comments you may have on this module. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "module_summary = TextareaAnswer(\"general comments on this module\")\n",
    "answer_registry.register_answer_widget(\"module-summary\", module_summary)\n",
    "display(module_summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Reference textbook / figure credits: Charles Kittel, \"Introduction to solid-state physics\", Chapter 1_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit cells, fractional coordinates, lattices\n",
    "\n",
    "A periodic structure is defined by a *lattice* and an a-periodic *repeat unit*. The lattice is a periodic set of points generated by all integer combinations of three *unit cell vectors* $\\mathbf{a}_{1,2,3}$, i.e. \n",
    "\n",
    "$$\n",
    "\\mathbf{T} = u_1 \\mathbf{a}_1 +  u_2 \\mathbf{a}_2 +  u_3 \\mathbf{a}_3, \\quad u_{1,2,3} \\in \\mathbb{Z}\n",
    "$$\n",
    "\n",
    "The repeat unit, or *basis* is defined by the coordinates $\\{x_i, y_i, z_i\\}$ of a (usually small) number of atoms that sit in arbitrary positions within the unit cell. These are often given in *fractional coordinates* $\\{s_{i1}, s_{i2}, s_{i3}\\}$, such that the set of all atoms in the crystal is generated by \n",
    "\n",
    "$$\n",
    "(u_1+s_{i1}) \\mathbf{a}_1 +  (u_2+s_{i2}) \\mathbf{a}_2 + (u_3+s_{i3}) \\mathbf{a}_3\n",
    "$$\n",
    "\n",
    "with the $u_{1,2,3}$ ranging over all positive and negative integers, and $i$ ranging over the number of atoms in the basis.\n",
    "\n",
    "There are 14 types of lattices known as _Bravais lattices_ in three dimensions, that are distinguished by the symmetry group of the lattice points. If you need to refresh your fundamentals of crystallography, and don't remember what a _face centered cubic_ or _body centered cubic_ lattice is, the [wikipedia page](https://en.wikipedia.org/wiki/Bravais_lattice) is excellent. Note also that the crystal structure (lattice+basis) can have more complicated symmetries, forming the 230 [space groups](https://en.wikipedia.org/wiki/Space_group)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, consider the structure below. This is just a finite set of atoms, and coordinates are listed individually. You can click on the atoms in the viewer and see its coordinates by clicking on the info panel below the viewer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "positions = np.array( [[x,y,z] for x,y,z in itertools.product([0, 5, 10, 15],[0, 5, 10, 15],[0, 5, 10, 15]) ])\n",
    "ase_cube = ase.Atoms(\"Ga64\", positions=positions)\n",
    "\n",
    "properties = {}\n",
    "properties[\"index\"] = {\n",
    "                \"target\": \"atom\",\n",
    "                \"values\": list(range(1, len(ase_cube)+1)),\n",
    "            }\n",
    "\n",
    "properties[\"coordinates\"] = {\n",
    "                \"target\": \"atom\",\n",
    "                \"values\": positions,\n",
    "            }\n",
    "\n",
    "cs = chemiscope.show([ase_cube], properties=properties, mode=\"structure\",                      \n",
    "                     environments=chemiscope.all_atomic_environments([ase_cube], cutoff=40),\n",
    "                     settings={\"structure\":[{\"spaceFilling\": False, \"environments\": {\"cutoff\": 40}}]}\n",
    "                    )\n",
    "display(cs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **01a** Write a function that returns the lattice vectors and a basis that generates the periodic structure that continues to infinity the motif above. </span>\n",
    "\n",
    "_NB: the validation code only tests for the primitive cell - you can come up with correct structures that will be marked as incorrect. Trust your own judgment (and look carefully at the visualization). Note also that you are required to reproduce also the actual lattice parameters, and not just the symmetry, of the structure above_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex01_wci = WidgetCodeInput(\n",
    "        function_name=\"sc_lattice_basis\", \n",
    "        function_parameters=\"\",\n",
    "        docstring=\"\"\"\n",
    "Returns the lattice vectors and the basis (in fractional coordinates) that \n",
    "generates a simple cubic structure corresponding to the non-periodic structure\n",
    "given in the notebook.\n",
    "\n",
    ":return: Three lattice vectors and a list of basis coordinates\n",
    "\"\"\",\n",
    "            function_body=\"\"\"\n",
    "# Write your solution, then click on the button below to update the plotter \n",
    "# and check against the reference value\n",
    "\n",
    "a1 = []\n",
    "a2 = []\n",
    "a3 = []\n",
    "basis = [[]]\n",
    "\n",
    "return a1, a2, a3, basis\n",
    "\"\"\"\n",
    "        )\n",
    "\n",
    "def reciprocal_lattice_vectors(a1, a2):\n",
    "    # compute it in obfuscated way\n",
    "    reciprocal_lattice = 2*np.pi*ase.Atoms(cell=[[a1[0], a1[1], 0], [a2[0], a2[1], 0], [0,0,1]]).cell.reciprocal()\n",
    "    return reciprocal_lattice[0][:2], reciprocal_lattice[1][:2]\n",
    "    \n",
    "def ex01_updater(code_input, visualizers):\n",
    "    a1, a2, a3, basis = ex01_wci.get_function_object()()\n",
    "    positions = np.asarray(basis)\n",
    "    h = np.asarray([a1,a2,a3])\n",
    "    if h.size != 0:\n",
    "        clear_input = visualizers[0]\n",
    "        with clear_input:\n",
    "            structure = ase.Atoms('Ga'+str(len(basis)), positions=positions@h.T, cell=[a1, a2, a3])\n",
    "            display(chemiscope.show(frames = [structure], mode=\"structure\", \n",
    "                                settings={\"structure\":[{\"unitCell\":True,\"supercell\":{\"0\":3,\"1\":3,\"2\":3}}]}\n",
    "                               ))\n",
    "\n",
    "def match_lattice(a, ref):\n",
    "    a1, a2, a3, basis = a;\n",
    "\n",
    "    b1, b2, b3, ref_basis = ref\n",
    "    assert len(np.asarray(basis).shape)==2, f\"ShapeAssert failed: Basis should be a (n_atoms,3) array, but I got {np.asarray(basis).shape}\"\n",
    "    assert np.asarray(basis).shape[1]==3, f\"ShapeAssert failed: Basis should be a (n_atoms,3) array, but I got {np.asarray(basis).shape}\"\n",
    "    assert np.asarray(basis).shape[0]==1, f\"ShapeAssert failed: The simple cubic lattice has usually a single-atom basis\"\n",
    "    assert np.allclose([a1,a2,a3], [b1,b2,b3]), f\"Your lattice has incorrect basis vectors.\"\n",
    "    return np.allclose(basis, ref_basis)\n",
    "\n",
    "ex01_code_demo = CodeDemo(\n",
    "            code_input= ex01_wci,\n",
    "            check_registry=check_registry,\n",
    "            visualizers = [ClearedOutput()],\n",
    "            update_visualizers = ex01_updater)\n",
    "\n",
    "check_registry.add_check(ex01_code_demo,\n",
    "                         inputs_parameters=[{}],\n",
    "                         reference_outputs=[([5,0,0],[0,5,0],[0,0,5],[[0,0,0]])],\n",
    "                         fingerprint=None,\n",
    "                         equal = match_lattice\n",
    "                        )\n",
    "                        \n",
    "answer_registry.register_answer_widget(\"ex01-function\", ex01_code_demo)\n",
    "display(ex01_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **01b** Try to shift all the basis atom(s) by the same displacement. Do you think that the resulting crystal would have different properties? </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex01_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex01-answer\", ex01_txt)\n",
    "display(ex01_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Primitive cell, supercells, conventional cells\n",
    "\n",
    "It is always possible to give different descriptions to the same crystal structure. For instance, for a given cell and basis one can always specify a _supercell_ i.e. a multiple of repeat units of the original cell, with a correspondingly larger basis. This basis contains \"hidden\" symmetries, meaning that it would be possible to describe the same structure with a smaller unit cell. The smallest possible cell is called a _primitive_ (or minimal) cell. \n",
    "\n",
    "For instance, the figure below shows three different choices of unit cell for a face-centered cubic lattice. All cells describe the same structure! The first structure is the primitive cell, and the third the conventional cells that reveals more clearly the origin of the name of this lattice.\n",
    "\n",
    "<img src=\"figures/fcc-cells.png\" width=\"800\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following visualizer shows a collection of 9 crystal structures, containing either one or two chemical species. Look at them, and try to understand what type of lattice they belong to. You can visualize the environment of each atom within an adjusable cutoff, which may help you appreciate the 3D nature of the structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ase_crystals = read('data/crystals.xyz',\":\")\n",
    "\n",
    "properties = {}\n",
    "properties[\"lattice vectors a1\"] = {\n",
    "                \"target\": \"structure\",\n",
    "                \"values\": np.asarray([str(list(a.cell[0])) for a in ase_crystals]),\n",
    "            }\n",
    "properties[\"lattice vectors a2\"] = {\n",
    "                \"target\": \"structure\",\n",
    "                \"values\": np.asarray([str(list(a.cell[1])) for a in ase_crystals]),\n",
    "            }\n",
    "properties[\"lattice vectors a3\"] = {\n",
    "                \"target\": \"structure\",\n",
    "                \"values\": np.asarray([str(list(a.cell[2])) for a in ase_crystals]),\n",
    "            }\n",
    "\n",
    "properties[\"basis\"] = {\n",
    "                \"target\": \"atom\",\n",
    "                \"values\": np.vstack([a.positions for a in ase_crystals]),\n",
    "            }\n",
    "\n",
    "\n",
    "pb_crystal_output = chemiscope.show(ase_crystals, properties=properties, mode=\"structure\",                      \n",
    "                     environments=chemiscope.all_atomic_environments(ase_crystals),\n",
    "                     settings={\"structure\":[{\"bonds\":True, \"unitCell\":True,\"supercell\":{\"0\":3,\"1\":3,\"2\":3},\n",
    "                                            \"environments\": {\"cutoff\": 6}}]}                    \n",
    "                    )\n",
    "def pb_crystal_process(co,visualizers):\n",
    "    clear_output = visualizers[0]\n",
    "    pyplot_output = visualizers[1]\n",
    "    with clear_output:\n",
    "        pyplot_output.settings={\"structure\": [{\"environments\": {\"cutoff\": pb_crystal_box.value['co']}}]}\n",
    "    \n",
    "pb_crystal_box = ParametersBox(co=(6.,1,12,0.1, r\"environment cutoff / Å\"))\n",
    "example_primitive_cell = CodeDemo(\n",
    "            input_parameters_box=pb_crystal_box,\n",
    "            visualizers=[ClearedOutput(),pb_crystal_output],\n",
    "            update_visualizers=pb_crystal_process)\n",
    "display(example_primitive_cell)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **02** Each of the structures above are either face-centered (fcc), body-centered (bcc) or simple cubic (sc). Write down in the box below what is the Bravais lattice for each structure, and the size of the basis used to describe the structure in each frame. </span>\n",
    "\n",
    "_NB: pay attention: (1) you are asked about the symmetry of the **lattice**: if you just look at the cell, you may be misled; (2) the number of atoms included in the basis depend on the choice of cell._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex02_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex02-answer\", ex02_txt)\n",
    "display(ex02_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a supercell is not only a way of obtaining a more convenient/intuitive view of a crystal structure. It can also be useful to represent real materials, in which the ideal periodicity of the crystal is broken, e.g. because there are defects, interfaces, or simply disorder. In these cases, one often starts from a small unit cells and explicitly repeats it many times. _This is different from just replicating the unit cell for visualization purposes: the cell is also enlarged, and the coordinates of all atoms inside the unit cell can be adjusted independently_\n",
    "\n",
    "ASE provides convenient utilities to replicate a structure. If `structure` is an `ase.Atoms` object, then\n",
    "`structure.repeat((nx, ny, nz))` will replicate the structure the given number of times along each of the axes. You can learn more about the function using `help(ase.Atoms.repeat)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(ase.Atoms.repeat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **03** Write code to generate a supercell for _fcc_ aluminum, using the number of repeat units as an argument, and a lattice parameter of 4Å. You can use the `repeat` ASE command, but if you feel adventurous you may as well write a replicate function yourself. </span>\n",
    "\n",
    "_NB: the self-test function can generate false errors because it expects a specific order of the basis atoms. Don't worry too much if it tells you one test has not passed!_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex03_wci = WidgetCodeInput(\n",
    "        function_name=\"al_supercell\", \n",
    "        function_parameters=\"nrep\",\n",
    "        docstring=\"\"\"\n",
    "Returns an ASE object describing a supercell built by replicating `nrep` times along each direction a conventional (4-atoms)\n",
    "fcc unit cell for aluminum. Use a lattice parameter of 4 Å.\n",
    "\n",
    ":param nrep: int: number of repetitions a supercell replicates\n",
    "\n",
    ":return: The replicated-cell ASE object\n",
    "\"\"\",\n",
    "            function_body=\"\"\"\n",
    "# Write your solution, then click on the button below to update the chemiscope viewer\n",
    "import ase\n",
    "\n",
    "al4 = ase.Atoms(\"Al4\", pbc=True)\n",
    "al4.cell = [ ... ]                 # lattice parameters of the conventional unit cell\n",
    "al4.positions = [[atom1x, atom1y, atom1z],\n",
    "                 [atom2x, atom2y, atom2z],\n",
    "                 [atom3x, atom3y, atom3z],\n",
    "                 [atom4x, atom4y, atom4z]] # positions of the 4 atoms in the conventional fcc cell\n",
    "\n",
    "\n",
    "# empty atom\n",
    "al_replicated =  ... \n",
    "\n",
    "return al_replicated\n",
    "\"\"\"\n",
    "        )\n",
    "\n",
    "def ex03_updater(nrep, code_input,visualizers):\n",
    "    \n",
    "    al_multi = code_input.get_function_object()(ex03_wp.value['nrep'])\n",
    "    clear_input = visualizers[0]\n",
    "    with clear_input:\n",
    "        display(chemiscope.show(frames = [al_multi], mode=\"structure\", \n",
    "                    settings={\"structure\":[{\"unitCell\":True}]})\n",
    "                )\n",
    "\n",
    "def equal_cell_and_positions(student,reference):\n",
    "    return np.allclose(reference[0], student[0]) and (reference[1] is None or np.allclose(reference[1], student[1][0:4])) \n",
    "       \n",
    "ex03_wp = ParametersBox(nrep=(2, 1, 4, 1, r\"$n_{\\mathrm{repeat}}$\"),\n",
    "                       refresh_mode=\"click\")    \n",
    "\n",
    "\n",
    "ex03_code_demo = CodeDemo(\n",
    "            input_parameters_box=ex03_wp,\n",
    "            code_input= ex03_wci,\n",
    "            check_registry=check_registry,\n",
    "            visualizers = [ClearedOutput()],\n",
    "            update_visualizers = ex03_updater)\n",
    "  \n",
    "def fingerprint_ase_atoms(ase_atom):\n",
    "    return (ase_atom.cell[:],ase_atom.positions)\n",
    "check_registry.add_check(ex03_code_demo,\n",
    "                         inputs_parameters=[{\"nrep\" : 1},\n",
    "                                           {\"nrep\" : 2}],\n",
    "                         reference_outputs=[([[4,0,0],[0,4,0],[0,0,4]], [[0,0,0],[2,2,0],[2,0,2],[0,2,2]]),\n",
    "                                            ([[8,0,0],[0,8,0],[0,0,8]], None)\n",
    "                                           ],\n",
    "                         fingerprint= fingerprint_ase_atoms,\n",
    "                         equal=equal_cell_and_positions\n",
    "                         ) \n",
    "\n",
    "answer_registry.register_answer_widget(\"ex03-function\", ex03_code_demo)\n",
    "display(ex03_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lattice planes and surfaces "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general notation used to define lattice planes is somewhat contrived (because it actually relates to the reciprocal lattice!). A plane is defined by three points, so one can define a lattice plane by picking three points that are multiples of the unit cell vectors, $(n_1 \\mathbf{a_1}, n_2 \\mathbf{a_2}, n_3 \\mathbf{a_3})$. The plane is determined by the reciprocals of the $n_{1,2,3}$, multiplied by their least common multiple so as to obtain three integer indices $(h k l)$. For instance, a plane that intercepts the lattice axes with $n_{1,2,3} = (4,3,1)$ has Miller indices $(3,4,12)$. _Only in a cubic lattice_ the plane identified by (h k l) has $h \\mathbf{a_1} + k \\mathbf{a_2} + l \\mathbf{a_3}$ as a plane normal. \n",
    "\n",
    "If you need a more detailed discussion, see Chapter 1 of _Kittel_, or the [Wikipedia page on Miller indices](https://en.wikipedia.org/wiki/Miller_index) that has some good figures. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the widget below, you can see a large supercell of _fcc_ aluminum. You can select different Miller indices, and see the atoms that belong to one of the lattice planes highlighted in a different color. Experiment a bit and note how e.g. `(2,2,4)` is equivalent to `(1,1,2)`, etc. Note also how the density of atoms on low-index planes is higher than on high-index planes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fcc_al = ase.lattice.cubic.FaceCenteredCubic('Al')\n",
    "al_supercell = fcc_al.repeat((4,4,4))\n",
    "\n",
    "normal_plane = np.array([1,0,0])\n",
    "origin = np.diagonal(al_supercell.cell)/2\n",
    "distances = np.abs((al_supercell.positions-origin) @ normal_plane) / np.linalg.norm(normal_plane)\n",
    "atoms_on_plane = np.where( distances < 1e-5 )[0]\n",
    "al_supercell.numbers[atoms_on_plane] = 12\n",
    "\n",
    "\n",
    "cs_fcc = chemiscope.show([al_supercell], mode=\"structure\", settings={\"structure\":[{\"spaceFilling\": False, \"unitCell\":True}]}\n",
    "                    )\n",
    "def update_surface_cut(h,k,l,visualizers):\n",
    "    output = visualizers[0]\n",
    "    al_supercell.numbers[:] = 13\n",
    "    normal_plane = np.array([pb_fcc.value['h'],pb_fcc.value['k'],pb_fcc.value['l']])    \n",
    "    if np.linalg.norm(normal_plane) != 0:\n",
    "        origin = np.diagonal(al_supercell.cell)/2\n",
    "        distances = np.abs((al_supercell.positions-origin) @ normal_plane) / np.linalg.norm(normal_plane)\n",
    "        atoms_on_plane = np.where( distances < 1e-6 )[0]\n",
    "        al_supercell.numbers[atoms_on_plane] = 12\n",
    "    global cs_fcc \n",
    "    settings = cs_fcc.settings\n",
    "    cs_fcc.close()\n",
    "    with output:\n",
    "        cs_fcc = chemiscope.show([al_supercell], mode=\"structure\", settings=cs_fcc.settings )\n",
    "        display(cs_fcc)\n",
    "\n",
    "\n",
    "pb_fcc = ParametersBox(h=(1,0,4,1,r\"h\"), k=(0,0,4,1,r\"k\"), l=(0,0,4,1,r\"l\"))\n",
    "surface_cut_code_demo = CodeDemo(\n",
    "            input_parameters_box=pb_fcc,\n",
    "            visualizers = [ClearedOutput()], \n",
    "            update_visualizers = update_surface_cut)\n",
    "\n",
    "\n",
    "display(surface_cut_code_demo)\n",
    "surface_cut_code_demo.run_demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'> **04** Activate the visualization of multiple replicas in the visualizer above (e.g. $2\\times2\\times2$) by increasing the supercell replication counts along X, Y, Z. Are the planes continuous across the edges of the supercell, if you pick a `(1,0,0)` plane? And what happens if you pick `(1,1,1)`? </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex04_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex04-answer\", ex04_txt)\n",
    "display(ex04_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create a supercell with an actual surface. While there are tools to do this for more complicated scenarios (see e.g. [here](https://wiki.fysik.dtu.dk/ase/ase/build/surface.html#create-specific-non-common-surfaces) for some examples using ASE), we will do this manually to understand better what is going on. \n",
    "\n",
    "If the surface is aligned with one of the lattice parameters, it is sufficient to first replicate the unit cell a number of times, and then artificially enlarge one of the edges of the unit cell. This will leave some empty space between the top and bottom layers of the structure, effectively leaving some atoms in contact with vacuum. \n",
    "\n",
    "<img src=\"figures/slab-100.png\" width=\"400\"/>\n",
    "\n",
    "Note you always create _two_ surfaces, because you are still dealing with a periodic structure. This is usually referred to as a _slab geometry_. Note also that for complicated crystals with a basis, the unit cell can be cut at different positions, so that there can be multiple different surfaces corresponding to the same lattice direction, depending on the position of the cut. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'> **05** Write a function that creates a supercell for _fcc_ aluminum with 4x4x2 replicas along the three directions. Use a conventional unit cell and a lattice parameter of 4Å. Modify the `cell` of the resulting ASE structure to add 20Å of vacuum along the $\\mathbf{a}_3$ direction, creating a slab geometry with a surface along `(0,0,1)` </span>\n",
    "\n",
    "_NB: you can copy most of the code from exercise 03._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex05_wci = WidgetCodeInput(\n",
    "        function_name=\"al_slab\", \n",
    "        function_parameters=\"nrep, nslab, vacuum\",\n",
    "        docstring=\"\"\"\n",
    "Returns an ASE object describing Al (100) surfaces using a slab geometry with nrep x nrep x nslab cells,\n",
    "and a vacuum region along z. Use a lattice parameter of 4 Å.\n",
    "\n",
    ":param nrep: int:     number of repetitions in the x,y plane\n",
    ":param nslab: int:    number of repetitions in the z direction (which determines the slab thickness)\n",
    ":param vacuum: float: thickness of the vacuum layer (in Å) along the z direction\n",
    "\n",
    ":return: The ASE object describing the slab geometry\n",
    "\"\"\",\n",
    "            function_body=\"\"\"\n",
    "# Write your solution, then click on the button below to update the chemiscope viewer\n",
    "import ase\n",
    "\n",
    "al4 = ase.Atoms(\"Al4\", pbc=True)\n",
    "al4.cell = [ ... ] # lattice parameters of the conventional unit cell\n",
    "al4.positions = [[, ,], [, ,], [, ,], [, ,]] # positions of the 4 atoms in the conventional fcc cell\n",
    "\n",
    "# bulk structure, replicated to obtain the desired slab size\n",
    "al_replicated =  ... \n",
    "# create gap by adding some vacuum to the supercell in the z direction\n",
    "\n",
    "return al_replicated\n",
    "\"\"\"\n",
    "        )\n",
    "\n",
    "def ex05_updater(nrep,nslab,vacuum,code_input,visualizers):\n",
    "    output = visualizers[0]\n",
    "    al_multi = code_input.get_function_object()(ex05_wp.value['nrep'], ex05_wp.value['nslab'], ex05_wp.value['vacuum'])\n",
    "    with output:\n",
    "        display(chemiscope.show(frames = [al_multi], mode=\"structure\", \n",
    "                            settings={\"structure\":[{\"unitCell\":True}]}\n",
    "                           ) )\n",
    "ex05_wp = ParametersBox(\n",
    "    nrep=(4, 1, 6, 1, r\"$n_{\\mathrm{rep}}$\"),\n",
    "    nslab=(2, 1, 6, 1, r\"$n_{\\mathrm{slab}}$\"),\n",
    "    vacuum=(20., 0, 40, 0.5, r\"$L_{\\mathrm{vacuum}}$\"),\n",
    "    refresh_mode=\"click\"\n",
    "    )\n",
    "\n",
    "ex05_code_demo = CodeDemo(\n",
    "            input_parameters_box=ex05_wp,\n",
    "            code_input= ex05_wci,\n",
    "            check_registry=check_registry,\n",
    "            visualizers = [ClearedOutput()],\n",
    "            update_visualizers = ex05_updater\n",
    ")\n",
    "\n",
    "answer_registry.register_answer_widget(\"ex05-function\", ex05_code_demo)\n",
    "\n",
    "   \n",
    "check_registry.add_check(ex05_code_demo,\n",
    "                         inputs_parameters=[{\"nrep\" : 1,\n",
    "                                             \"nslab\": 1, \n",
    "                                             \"vacuum\": 10 },\n",
    "                                           {\"nrep\" : 4,\n",
    "                                             \"nslab\": 2, \n",
    "                                             \"vacuum\": 11 }],\n",
    "                         reference_outputs=[ (np.array([[4.,0.,0.],[0.,4.,0.],[0.,0.,14.]]), np.array([[0.,0.,0.],[2.,2.,0.],[2.,0.,2.],[0.,2.,2.]])),\n",
    "                                            ([[16.,0.,0.],[0.,16.,0.],[0.,0.,19.]], None) \n",
    "                                           ],\n",
    "                         fingerprint= fingerprint_ase_atoms,\n",
    "                         equal=equal_cell_and_positions\n",
    "                         ) \n",
    "\n",
    "display(ex05_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a `(1,1,1)` surface is somewhat more complicated, because the conventional unit cell is not aligned properly. One way to create a slab with the appropriate orientation is to create a _primitive_ face-centered cell and to create the slab by _rescaling_ one of the cell vectors. \n",
    "\n",
    "<span style='color:blue'> **06** Write a function that creates a supercell for _fcc_ aluminum, starting with the *primitive* cell replicated as 8x8x2 along the lattice vectors. Then _multiply_ $\\mathbf{a}_3$ by a scaling factor to create the surface. Visualize the resulting structure</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex06_wci = WidgetCodeInput(\n",
    "        function_name=\"al_slab_111\", \n",
    "        function_parameters=\"nrep, nslab, zscale\",\n",
    "        docstring=\"\"\"\n",
    "Returns an ASE object describing Al (111) surfaces using a slab geometry with \n",
    "nrep x nrep x nslab copies of the primitive cell. Vacuum must be created by \n",
    "elongating one of the lattice vectors by a factor zscale. Use a lattice parameter of 4 Å.\n",
    "\n",
    "\n",
    ":param nrep: int:     number of repetitions in the x,y plane\n",
    ":param nslab: int:    number of repetitions in the z direction (which determines the slab thickness)\n",
    ":param zscale: float: multiplicative factors by which the third lattice vector should be magnified to create some vacuum\n",
    "\n",
    ":return: The ASE object describing the slab geometry\n",
    "\"\"\",\n",
    "            function_body=\"\"\"\n",
    "# Write your solution, then click on the button below to update the chemiscope viewer\n",
    "import ase\n",
    "\n",
    "al = ase.Atoms(\"Al\", pbc=True)\n",
    "al.cell = [ ... ] # lattice parameters of the *primitive* unit cell\n",
    "al.positions = [[0,0,0]] # just one-atom basis!\n",
    "\n",
    "\n",
    "# empty atom\n",
    "al_replicated =  ... \n",
    "# create gap\n",
    "\n",
    "return al_replicated\n",
    "\"\"\"\n",
    "        )\n",
    "\n",
    "def ex06_updater(nrep,nslab,zscale,code_input,visualizers):\n",
    "    output = visualizers[0]\n",
    "    al_multi = code_input.get_function_object()(ex06_wp.value['nrep'], ex06_wp.value['nslab'], ex06_wp.value['zscale'])\n",
    "    with output:\n",
    "        display(chemiscope.show(frames = [al_multi], mode=\"structure\", \n",
    "                                settings={\"structure\":[{\"unitCell\":True}]}\n",
    "                               )\n",
    "               )\n",
    "\n",
    "ex06_wp = ParametersBox(\n",
    "    nrep=(4, 1, 6, 1, r\"$n_{\\mathrm{rep}}$\"),\n",
    "    nslab=(2, 1, 6, 1, r\"$n_{\\mathrm{slab}}$\"),\n",
    "    zscale=(4., 1., 10, 0.5, r\"$z_{\\mathrm{scale}}$\"),\n",
    "    refresh_mode=\"click\"\n",
    "    )\n",
    "\n",
    "ex06_code_demo = CodeDemo(\n",
    "            input_parameters_box=ex06_wp,\n",
    "            code_input= ex06_wci,\n",
    "            check_registry=check_registry,\n",
    "            visualizers = [ClearedOutput()],\n",
    "            update_visualizers = ex06_updater\n",
    ")\n",
    "answer_registry.register_answer_widget(\"ex06-function\", ex06_code_demo)\n",
    "\n",
    "\n",
    "check_registry.add_check(ex06_code_demo,\n",
    "                         inputs_parameters=[{\"nrep\" : 1,\n",
    "                                             \"nslab\": 1, \n",
    "                                             \"zscale\": 1 },\n",
    "                                           {\"nrep\" : 1,\n",
    "                                             \"nslab\": 2, \n",
    "                                             \"zscale\": 2 }],\n",
    "                         reference_outputs=[ ([[2,2,0],[2,0,2],[0,2,2]], [[0,0,0]]),\n",
    "                                            ([[2,2,0],[2,0,2],[0,8,8]], None) \n",
    "                                           ],\n",
    "                         fingerprint= fingerprint_ase_atoms,\n",
    "                         equal=equal_cell_and_positions\n",
    "                         ) \n",
    "display(ex06_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **07** What is the direction of the primitive lattice parameters relative to the conventional _fcc_ index system? Is the surface normal parallel to the $\\mathbf{a}_3$ cell vector? \n",
    "In order to create an easier to visualize structure, one often builds a unit cell that is orthorhombic and has one axis that is parallel to the surface normal. Can you come up with three low-Miller-indices directions that are mutually orthogonal and could be used to define an appropriate unit cell?\n",
    "</span>\n",
    "\n",
    "_NB: The last point is not entirely trivial, think about it but don't get too stressed if you don't manage to create the appropriate cell. If you are *really* into these geometric problems, you can also try to derive an actual unit cell, including also the basis. It will be used in the  [module on defects](./05-Defects.ipynb) to generate decohesion curves for aluminum._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex07_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex07-answer\", ex07_txt)\n",
    "display(ex07_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reciprocal lattice in 2D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From here on, we work exclusively with 2D lattices,\n",
    "\n",
    "$$\n",
    "\\mathbf{T} = u_1 \\mathbf{a}_1 + u_2 \\mathbf{a}_2, \\quad \\mathbf{a}_{1,2} \\in \\mathbb{R}^2, u_{1,2} \\in Z\n",
    "$$\n",
    "\n",
    "because they allow for simpler visualization of the core concepts. Most of the concepts we develop and demonstrate, however, apply equally well to actual 3D systems. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The idea of the reciprocal lattice is deeply linked to the idea of scattering, and constructive interference. A plane wave $e^{\\mathrm{i} \\mathbf{k}\\cdot \\mathbf{x}}$ originating at the origin will be in phase with similar waves originating at all other lattice points if its wavevector $\\mathbf{k}$ satisfies the phase relation $\\mathbf{k}\\cdot \\mathbf{T} = 2\\pi n$, where $n$ is an integer, for each and every lattice vector. \n",
    "\n",
    "We can build a _reciprocal lattice_ that consist of integer combinations of basis vectors $\\mathbf{b}_{1,2}$\n",
    "\n",
    "$$\n",
    "\\mathbf{G} = v_1 \\mathbf{b}_1 + v_2 \\mathbf{b}_2, \\quad \\mathbf{b}_{1,2} \\in \\mathbb{R}^2, v_{1,2} \\in Z\n",
    "$$\n",
    "\n",
    "such that every reciprocal lattice point is a wavevector that results in a complete in-phase scattering from the direct lattice. To do this, we need relationships to hold between the lattice vectors: $\\mathbf{b}_{1,2} \\cdot \\mathbf{a}_{1,2} = 2\\pi$, $\\mathbf{b}_{1,2}\\cdot \\mathbf{a}_{2,1} = 0$. Thus, \n",
    "$\\mathbf{b}_1$ must be orthogonal to $\\mathbf{a}_2$ and $\\mathbf{b}_2$ must be orthogonal to $\\mathbf{a}_1$.\n",
    "\n",
    "We can achieve this (including also normalization that ensure the correct scaling $\\mathbf{b}_{1,2} \\cdot \\mathbf{a}_{1,2} = 2\\pi$, with the definition\n",
    "\n",
    "$$ \\mathbf{b}_1 = 2\\pi\\frac{\\mathbf{R}\\mathbf{a}_2}{\\mathbf{a}_1\\cdot\\mathbf{R}\\mathbf{a}_2}, \\quad \\mathbf{b}_2 = 2\\pi\\frac{\\mathbf{R}\\mathbf{a}_1}{\\mathbf{a}_2\\cdot\\mathbf{R}\\mathbf{a}_1},\\quad\\quad\\mathbf{R} = \\begin{bmatrix}0 & -1\\\\ 1 & 0\\end{bmatrix}$$\n",
    "\n",
    "where $\\mathbf{R}$ is a $\\pi/2$ rotation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **08** What are the reciprocal lattice vectors for a 2D rectangular Bravais lattice with lattice vectors $(1,0)$ and $(0,2)$?\n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex08_txt = TextareaAnswer(\"Enter your answer here.\")\n",
    "answer_registry.register_answer_widget(\"ex08-answer\", ex08_txt)\n",
    "display(ex08_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **09** Write a function that computes the reciprocal lattice vectors given $\\mathbf{a}_{1,2}$. Use the demo widget to experiment and get an intuitive understanding of what's going on. \n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex09_wci = WidgetCodeInput(\n",
    "        function_name=\"reciprocal_lattice\", \n",
    "        function_parameters=\"a1, a2\",\n",
    "        docstring=\"\"\"\n",
    "Return the 2D reciprocal unit cell vectors.\n",
    "\n",
    ":param a1: list: unit cell vector a1 [a1x, a1y] \n",
    ":param a2: list: unit cell vector a2 [a2x, a2y]\n",
    "\n",
    ":return: reciprocal lattice unit cell vectors\n",
    "\"\"\",\n",
    "        function_body=\"\"\"\n",
    "\n",
    "import numpy as np\n",
    "from numpy import pi\n",
    "\n",
    "# this is just to accept all sort of sequence inputs \n",
    "a1 = np.asarray(a1)\n",
    "a2 = np.asarray(a2)\n",
    "\n",
    "# matrix-matrix and matrix-vector multiplication can be achieved with the @ operator\n",
    "# For example `R @ a` multiplies the matrix R with the vector a\n",
    "R = np.array([[0,-1],[1,0]])  # <- this converts a nested list to a numpy array\n",
    "\n",
    "# change to the correct expression\n",
    "b1 = 2*pi*a1 \n",
    "b2 = 2*pi*a2 \n",
    "\n",
    "return np.asarray(b1), np.asarray(b2)  # this is just to return a standard format even if you define b1 and b2 as another type of iterable\n",
    "\"\"\"\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_lattice(ax, a1, a2, basis=None, alphas=None, s=20, c='red', \n",
    "                 lattice_size = 60, head_length = 0.5, head_width= 0.2, width=0.05):\n",
    "    if basis is None:\n",
    "        basis = np.array([[0,0]])\n",
    "    A = np.array([a1, a2])\n",
    "    # each atom in the basis gets a different basis alpha value when plotted\n",
    "    if alphas is None:\n",
    "        alphas = np.linspace(1, 0.3, len(basis))\n",
    "    for i in range(len(basis)):\n",
    "        lattice = (np.mgrid[:lattice_size,:lattice_size].T @ A + basis[i]).reshape(-1, 2)\n",
    "        lattice -= (np.array([lattice_size//2,lattice_size//2]) @ A).reshape(-1, 2)\n",
    "        ax.scatter(lattice[:,0], lattice[:,1], color=c, s=s, alpha=alphas[i])\n",
    "        \n",
    "    ax.fill([0,a1[0],(a1+a2)[0],a2[0]], [0,a1[1],(a1+a2)[1],a2[1]], color=c, alpha=0.2)\n",
    "    ax.arrow(0,0, a1[0], a1[1],width=width,\n",
    "             length_includes_head=True,\n",
    "             fc=c, ec='black')\n",
    "    ax.arrow(0,0, a2[0], a2[1],width=width,\n",
    "             length_includes_head=True,\n",
    "             fc=c, ec='black')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_reciprocal_and_real_lattice(axes, a11, a12, a21, a22, basis=None):\n",
    "    if basis is None:\n",
    "        basis = np.array([[0,0]])\n",
    "    a1 = np.array([a11, a12])\n",
    "    a2 = np.array([a21, a22])\n",
    "    \n",
    "    b1, b2 = ex09_wci.get_function_object()(a1, a2)\n",
    "    \n",
    "    plot_lattice(axes[0], a1, a2, basis, s=20, c='red')\n",
    "    plot_lattice(axes[1], b1/(2*np.pi), b2/(2*np.pi), None, s=20, c='blue')\n",
    "        \n",
    "    axes[0].set_title('real space')\n",
    "    axes[0].set_xlim(-5,5)\n",
    "    axes[0].set_ylim(-5,5)\n",
    "    axes[0].set_xlabel(\"$x$ / Å\")\n",
    "    axes[0].set_ylabel(\"$y$ / Å\")\n",
    "    \n",
    "    axes[1].set_title('reciprocal space')\n",
    "    axes[1].set_xlim(-5,5)\n",
    "    axes[1].set_ylim(-5,5)\n",
    "    axes[1].set_xlabel(\"$k_x/2\\pi$ / Å$^{-1}$\")\n",
    "    axes[1].set_ylabel(\"$k_y/2\\pi$ / Å$^{-1}$\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex09_wp = ParametersBox(a11 = (1., -4, 4, 0.1, r'$a_{11} / Å$'),\n",
    "                            a12 = (0., -4, 4, 0.1, r'$a_{12} / Å$'),\n",
    "                            a21 = (0., -4, 4, 0.1, r'$a_{21} / Å$'),\n",
    "                            a22 = (2., -4, 4, 0.1, r'$a_{22} / Å$'),\n",
    "                            refresh_mode=\"continuous\"\n",
    "                           )\n",
    "ex09_figure, _ = plt.subplots(1, 2, figsize=(7.5,3.8), tight_layout=True)\n",
    "ex09_pyplot_output = PyplotOutput(ex09_figure)\n",
    "\n",
    "def ex09_updater(a11, a12, a21, a22, code_input, visualizers):\n",
    "    print_output = visualizers[0]\n",
    "    pyplot_output = visualizers[1] \n",
    "    axes = pyplot_output.figure.get_axes()\n",
    "    basis = np.array([[0,0]])\n",
    "    a1 = [ex09_wp.value['a11'], ex09_wp.value['a12']]\n",
    "    a2 = [ex09_wp.value['a21'],ex09_wp.value['a22']]\n",
    "    b1, b2 = code_input.get_function_object()(a1, a2)\n",
    "    print_output = visualizers[0]\n",
    "    plot_reciprocal_and_real_lattice(axes, a11, a12, a21, a22, basis)\n",
    "\n",
    "ex09_code_demo = CodeDemo(\n",
    "            input_parameters_box=ex09_wp,\n",
    "            code_input= ex09_wci,\n",
    "            check_registry=check_registry,\n",
    "            visualizers = [ClearedOutput(),ex09_pyplot_output],\n",
    "            update_visualizers = ex09_updater\n",
    ")\n",
    "\n",
    "ex09_pb = [{\"a1\" : (0,1),\"a2\": (1,0)},\n",
    "                          {\"a1\" : (1,1),\"a2\": (1,-1)},\n",
    "                          {\"a1\" : (0,2),\"a2\": (2,1)}] \n",
    "\n",
    "check_registry.add_check(ex09_code_demo,\n",
    "                         inputs_parameters=ex09_pb,\n",
    "                         reference_outputs=[reciprocal_lattice_vectors(inputs[\"a1\"],inputs[\"a2\"]) for inputs in ex09_pb],\n",
    "                         equal=np.allclose) \n",
    "answer_registry.register_answer_widget(\"ex09-function\", ex09_code_demo)\n",
    "display(ex09_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diffraction from a lattice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand diffraction, you need to consider that scattering is a process involving an incoming wave, $e^{-\\mathrm{i} \\mathbf{k}_{\\mathrm{in}} \\cdot \\mathbf{x}}$. Each lattice point will be hit by the wave with a different phase \n",
    "$e^{-\\mathrm{i} \\mathbf{k}_{\\mathrm{in}} \\cdot \\mathbf{T}}$ and act as a spherical scatterer. The detector will be in a given position $\\mathbf{R}_d$, and if it is sufficiently far it will pick up a plane wave in that direction, with outgoing wavevector $\\mathbf{k}_{\\mathrm{out}}$. Depending on the position of the scattering point, it will accumulate a further phase $e^{\\mathrm{i} \\mathbf{k}_{\\mathrm{out}} \\cdot \\mathbf{T}}$ (the change in sign coming from the fact the distance traveled will be $~(\\mathbf{R}_d - \\mathbf{T})$. The scheme below, drawn for arbitrary position of the scattering centers, applies clearly also to the case when scattering occurs from lattice points\n",
    "\n",
    "<img src=\"figures/scattering.png\" width=\"600\"/>\n",
    "\n",
    "The condition to have constructive interference is therefore to have the scattering vector $\\mathbf{k}=\\mathbf{k}_\\mathrm{in}-\\mathbf{k}_\\mathrm{out}$ be a vector of the reciprocal lattice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For typical diffraction experiments, the scattering process is elastic, meaning that the modulus of the wavevector does not change during the interaction, so $|\\mathbf{k}_{\\mathrm{in}}|=|\\mathbf{k}_{\\mathrm{out}}|$. Furthermore, the modulus of the wavevector depends on the source of radiation used in the experiment. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **10** what are the smallest and largest reciprocal lattice vectors that can be observed with electromagnetic radiation with wavelength $\\lambda$? Think of the geometry of the experiment, and take the modulus of the incoming and outgoing wavevectors to be $2\\pi/\\lambda$. \n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex10_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex10-answer\", ex10_txt)\n",
    "display(ex10_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The widget below allows you to experiment with the geometry of a scattering experiment. You can define a direct lattice, the wavelength of the incoming light, and the angle between incoming and outgoing beam. \n",
    "The scheme that is drawn around the origin is the construction for the Ewald circle (2D equivalent of the [Ewald sphere](https://en.wikipedia.org/wiki/Ewald%27s_sphere)). There may be scattering only if the scattering vector $\\mathbf{k}$ coincides with a point of the reciprocal lattice. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_braggs_reflection(a11, a12, a21, a22, phi, wavelength, two_theta,visualizers):\n",
    "    print_output = visualizers[0]\n",
    "    pyplot_output = visualizers[1]\n",
    "    \n",
    "    axes = pyplot_output.figure.get_axes()\n",
    "    def rot2d(angle):\n",
    "        return np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]])\n",
    "    rot_phi = rot2d(phi)\n",
    "    a1 = np.array([a11, a12]) @ rot_phi\n",
    "    a2 = np.array([a21, a22]) @ rot_phi\n",
    "    \n",
    "    # reuse \n",
    "    plot_reciprocal_and_real_lattice(axes, a1[0], a1[1], a2[0], a2[1])\n",
    "        \n",
    "    head_length = 0.5\n",
    "    head_width = 0.2\n",
    "    width = 0.05\n",
    "    lw = 1\n",
    "    alpha_unit_cell_vectors = 0.8\n",
    "    \n",
    "    k_in = 2*np.pi*np.array([-1,0])/wavelength /(2*np.pi) #<- scale by 2pi so it is consistent with reciprocal lattice plot\n",
    "    k_out = rot2d(two_theta)@k_in\n",
    "    k = k_in - k_out\n",
    "    scatter_origin = np.array([0,0])\n",
    "    axes[1].arrow(scatter_origin[0]+k_in[0], scatter_origin[1]+k_in[1], -k_in[0], -k_in[1],\n",
    "                  lw=lw, head_width=head_width, head_length=head_length, width=0.05,\n",
    "                  length_includes_head=True,\n",
    "                  fc='red', ec='red', label='$k_{in}}$')\n",
    "    axes[1].arrow(scatter_origin[0]+k_in[0], scatter_origin[1]+k_in[1], -k_out[0], -k_out[1],\n",
    "                  lw=lw, head_width=head_width, head_length=head_length, width=0.05,\n",
    "                  length_includes_head=True,\n",
    "                  fc='orange', ec='orange', label='$k_{out}$')\n",
    "    axes[1].arrow(scatter_origin[0], scatter_origin[1], k[0], k[1],\n",
    "                  lw=lw, head_width=head_width, head_length=head_length, width=0.05,\n",
    "                  length_includes_head=True,\n",
    "                  fc='black', ec='black', label='$k$')\n",
    "\n",
    "    circle_theta = np.linspace(-np.pi, np.pi, 200)\n",
    "    r = 2*np.pi/wavelength/(2*np.pi)\n",
    "    axes[1].plot(np.sin(circle_theta)*r + scatter_origin[0]+k_in[0],\n",
    "            np.cos(circle_theta)*r + scatter_origin[1]+k_in[1],\n",
    "            color='red', label=\"Ewald circle\")\n",
    "    r = np.linalg.norm(k)\n",
    "    axes[1].plot(np.sin(circle_theta)*r + scatter_origin[0],\n",
    "            np.cos(circle_theta)*r + scatter_origin[1],\n",
    "            color='black', label=\"$|\\mathbf{k}|$ circle\")    \n",
    "    axes[1].legend(loc=\"lower right\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bragg_figure, _ = plt.subplots(1, 2, figsize=(7.5,3.8), tight_layout=True)\n",
    "bragg_output = PyplotOutput(bragg_figure)\n",
    "\n",
    "ex10_pb = ParametersBox(a11 = (1., -4, 4, 0.1, r'$a_{11} / Å$'),\n",
    "                            a12 = (0., -4, 4, 0.1, r'$a_{12} / Å$'),\n",
    "                            a21 = (0., -4, 4, 0.1, r'$a_{21} / Å$'),\n",
    "                            a22 = (1., -4, 4, 0.1, r'$a_{22} / Å$'),\n",
    "                            phi = (0., 0., 2*np.pi, 0.05, r'$\\phi$'),\n",
    "                            wavelength = (1., 0.2, 2, 0.05, r'$\\lambda$ / Å'),\n",
    "                            two_theta = (1., 0.1, np.pi, 0.05, r'$2\\theta$'),\n",
    "                            refresh_mode=\"continuous\"\n",
    "                           )\n",
    "# we need to reload the widget  when the solution of ex09\n",
    "# computing the reciprocal unit cell vectors has been updated\n",
    "\n",
    "ex10_code_demo = CodeDemo(\n",
    "            input_parameters_box=ex10_pb,\n",
    "            visualizers = [ClearedOutput(),bragg_output],\n",
    "            update_visualizers = plot_braggs_reflection\n",
    ")\n",
    "display(ex10_code_demo)\n",
    "ex10_code_demo.run_demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice that it is not easy, with a fixed position of the incoming light, to orient the detector so that $\\mathbf{k}$ corresponds to a reciprocal lattice vector. The widget above allows you to change the orientation of the direct lattice. Note how, by changing the orientation of the crystal, you can bring any of the reciprocal lattice point that lie on the circle with radius $k$ in coincidence with the scattering wavevector $\\mathbf{k}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **11** What happens if you consider scattering from a collection of crystals with different, random orientations (a powder sample)? Does diffraction depend on the orientation of the sample? \n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex11_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex11-answer\", ex11_txt)\n",
    "display(ex11_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diffraction from an atomic structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An actual crystalline structure involves both a lattice and of an a-periodic basis $\\{\\mathbf{s}_i\\}$ of atoms. Each will scatter with a form factor $f_i$ (that depends on the modulus of $\\mathbf{k}$ but we will take to be a constant proportional to the atomic charge $Z_i$). The scattered amplitude can be written as  \n",
    "\n",
    "$$\n",
    "F(\\mathbf{k}) = \\frac{1}{N} \\sum^N_{j \\textrm{ atom}} f_j\\exp(-\\mathrm{i}\\mathbf{k}\\cdot\\mathbf{r}_j)\\textrm{, with }\\mathbf{r}_j\\textrm{ position of atom }j\n",
    "$$\n",
    "\n",
    "by breaking the position of atoms into lattice vector and basis positions ($\\mathbf{r}_j=\\mathbf{T}+\\mathbf{s}_m$), we can write \n",
    "\n",
    "$$\n",
    "F(\\mathbf{k}) = \\frac{1}{n_\\mathrm{cell} n_\\mathrm{basis}} \n",
    "\\sum^{n_\\mathrm{cell}}_{\\mathbf{T}} \\exp(-\\mathrm{i}\\mathbf{k}\\cdot \\mathbf{T}) \n",
    "\\sum_m^{n_\\mathrm{basis}} f_m \\exp(-\\mathrm{i}\\mathbf{k}\\cdot\\mathbf{s}_m).\n",
    "$$\n",
    "\n",
    "One sees that the sum over lattice vectors selects the diffracted wavevectors that correspond to a reciprocal lattice vector, $\\mathbf{k}=\\mathbf{G}$, as we saw in the previous section. The sum over the atomic basis modulates the amplitude of the peak through a _structure factor_, which we will see encodes information on the type and position of atoms within the unit cell\n",
    "\n",
    "$$\n",
    "F_\\mathbf{G} = \\sum_m^{n_\\mathrm{basis}} f_m \\exp(-\\mathrm{i}\\mathbf{G}\\cdot\\mathbf{s}_m).\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img src=\"figures/diffraction.png\" width=\"600\"/>\n",
    "\n",
    "In the scattering geometry above, one can determine the conditions for scattering in terms of the scattering angle $2\\theta$, as follows. If $k$ is the modulus of both $\\mathbf{k}_\\mathrm{in}$ and $\\mathbf{k}_\\mathrm{out}$, and $\\mathbf{G} = \\mathbf{k} = \\mathbf{k}_\\mathrm{in}-\\mathbf{k}_\\mathrm{out}$ must hold, a first necessary condition is\n",
    "\n",
    "$$\n",
    "G^2 = |\\mathbf{k}_\\mathrm{in}-\\mathbf{k}_\\mathrm{out}|^2 = 2k^2 (1-\\cos 2\\theta) = 4k^2 sin^2 \\theta\n",
    "$$\n",
    "\n",
    "hence, $\\sin\\theta=G/2k$. To determine the orientation of $\\mathbf{G}$ a second condition is needed. We can consider the angle between $\\mathbf{G}$ and the incoming vector $\\phi$, that can be set by changing the orientation of the crystal. Thus, by writing $|\\mathbf{G}-\\mathbf{k}_\\mathrm{in}|^2 = |\\mathbf{k}_\\mathrm{out}|^2$ we can easily get $G = 2 k \\cos\\phi$, and hence $\\cos\\phi = \\sin\\theta$. If the sample is formed by uniformly oriented grains, the second condition is always satisfied by some crystals, and so the diffraction pattern is just a sequence of peaks at particular values of the angle $2\\theta$.  The intensity of each peak is given by the square modulus of the structure factor, $|F_\\mathbf{G}|^2$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This widget below computes the powder (rotationally averaged) diffraction pattern for a crystal with a basis of two atoms. The function computes the list of diffraction peaks, with the corresponding structure factor. \n",
    "It is not entirely trivial, and so it is already implemented: you don't have to change it, but you can read it and understand what it does. Experiment with the widget, and then move to the exercises below, that will ask you to comment on what you observe in different scenarios. \n",
    "\n",
    "Parameters are as follows:\n",
    "* $a_{ij}$: components of the lattice vectors\n",
    "* $\\phi$: rigid rotation of the lattice (does it have an impact on the diffraction?)\n",
    "* $s_{1,2}$: fractional coordinates of the second atom of the basis (first atom is in (0,0))\n",
    "* $f_{1,2}$: atomic form factors for the two atoms in the basis (roughly take it to be the atomic number)\n",
    "* $\\lambda$: wavelength of the scattering radiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set upt the code widget window\n",
    "ex12_wci = WidgetCodeInput(\n",
    "        function_name=\"diffraction_peaks\",\n",
    "        function_parameters=\"basis, atomic_ff, reciprocal_b1, reciprocal_b2, wavelength\",\n",
    "        docstring=\"\"\"\n",
    "Computes the list of peaks for a lattice with a given (real-space) basis \n",
    "and reciprocal lattice, and for a given wavelength of the incoming radiation.\n",
    "\n",
    ":param basis: list of N 2D vectors corresponding to the (real space!) position of the basis atoms\n",
    ":param atomic_form_factors: atomic form factors of atoms in lattice, array of length N\n",
    ":param reciprocal_b1, reciprocal_b2:  reciprocal lattice vectors\n",
    ":param wavelength: wavelength of the incoming radiation\n",
    "\n",
    ":return: The list of diffraction peaks, as [h, l, theta, intensity]\n",
    "\"\"\",\n",
    "    function_body=\"\"\"    \n",
    "import numpy as np\n",
    "\n",
    "def compute_absolute_structure_factor(sj, fj, G):\n",
    "    # sj: atomic basis (n_basis x 2)\n",
    "    # fj: form factors (n_basis)\n",
    "    # G: reciprocal lattice vectors (2D)\n",
    "    return np.abs(fj @ np.exp(-1j * sj @ G))\n",
    "\n",
    "# wave number (modulus of the incoming wavevector)\n",
    "k = np.pi*2/wavelength \n",
    "# determine the range of reciprocal lattice vectors that could give rise to permissible reflections\n",
    "if reciprocal_b1@reciprocal_b1 != 0:\n",
    "    n1 = int((k*2)/np.sqrt(reciprocal_b1@reciprocal_b1))+1\n",
    "else:\n",
    "    n1 = 0\n",
    "if reciprocal_b2@reciprocal_b2 != 0:\n",
    "    n2 = int((k*2)/np.sqrt(reciprocal_b2@reciprocal_b2))+1  \n",
    "else:\n",
    "    n2 = 0\n",
    "\n",
    "# allocated space for the list of peaks\n",
    "lpeaks = []\n",
    "for v1 in range(-n1,n1+1):\n",
    "    for v2 in range(-n2,n2+1):\n",
    "        # reciprocal lattice vector\n",
    "        G = reciprocal_b1*v1 + reciprocal_b2*v2\n",
    "\n",
    "        # theta (from 2theta geometry)\n",
    "        sin_theta = np.sqrt(G@G)/(2*k)\n",
    "        if sin_theta > 1: # discards reflections that fall outside of the permissible range\n",
    "            continue\n",
    "        theta = np.arcsin(sin_theta)\n",
    "        # structure factor\n",
    "        absolute_structure_factor = compute_absolute_structure_factor(basis, atomic_ff, G)\n",
    "        lpeaks.append([v1, v2, theta, absolute_structure_factor**2])\n",
    "return np.asarray(lpeaks)\n",
    "\"\"\"\n",
    "        )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_diffraction(a11, a12, a21, a22, s1, s2, f1, f2, phi, wavelength,code_input,visualizers):\n",
    "    print_output = visualizers[0]\n",
    "    pyplot_output = visualizers[1]\n",
    "    table_output = visualizers[2]\n",
    "    axes = pyplot_output.figure.get_axes()\n",
    "    def rot2d(angle):\n",
    "        return np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]])\n",
    "    rot_phi = rot2d(phi)\n",
    "    a1 = np.array([a11, a12]) @ rot_phi\n",
    "    a2 = np.array([a21, a22]) @ rot_phi\n",
    "    basis = np.asarray([0*a1,s1*a1+s2*a2])\n",
    "    plot_lattice(axes[0], a1, a2, basis=basis, alphas=[f1/40, f2/40], c='red')\n",
    "    axes[0].set_title('real space')\n",
    "    axes[0].set_xlim(-5,5)\n",
    "    axes[0].set_ylim(-5,5)\n",
    "    axes[0].set_xlabel(\"$x$ / Å\")\n",
    "    axes[0].set_ylabel(\"$y$ / Å\")\n",
    "    \n",
    "    b1, b2 = reciprocal_lattice_vectors(a1, a2)\n",
    "    \n",
    "    dpeaks = code_input.get_function_object()( basis, np.asarray([f1, f2]), b1, b2, wavelength )\n",
    "    \n",
    "    twotheta_grid = np.linspace(0, 180, 720)\n",
    "    dp_grid = np.zeros(len(twotheta_grid))\n",
    "    for _, _, t, f2 in dpeaks:\n",
    "        dp_grid += np.exp(-(twotheta_grid-2*t*180/np.pi)**2/0.5)*f2\n",
    "    \n",
    "    axes[1].clear()\n",
    "    # we plot two theta\n",
    "    axes[1].plot(twotheta_grid, dp_grid, 'b-')\n",
    "    \n",
    "    axes[1].set_xlim(0,180)\n",
    "    axes[1].set_xlabel(\"$2\\\\theta$ / degree °\")\n",
    "    axes[1].set_title('Diffraction pattern')\n",
    "    axes[1].set_ylabel(\"Intensity $|F(\\mathbf{k}(\\\\theta))|$\")\n",
    "    \n",
    "    axes[0].set_aspect('equal')\n",
    "    axes[1].set_aspect(150/np.max(dp_grid))\n",
    "    with table_output:\n",
    "        header = \"\"\"\n",
    "                      v1 / Å \n",
    "                      v2 / Å \n",
    "                      2θ / degree ° \n",
    "                      |FG|2 \n",
    "                    \"\"\"\n",
    "        # cleans up peak info for displaying\n",
    "        tpeaks = []\n",
    "        for d in dpeaks[np.argsort(dpeaks[:,2])]:\n",
    "            tpeaks.append( [ int(d[0]), int(d[1]), np.round(2*d[2]*180/np.pi,2),  np.round(d[3],1) ])\n",
    "        reflection_table_html.value = array_to_html_table(tpeaks, header)\n",
    "        display(reflection_table)\n",
    "        \n",
    "def array_to_html_table(numpy_array, header):\n",
    "    rows = \"\"\n",
    "    for i in range(len(numpy_array)):\n",
    "        rows += \"<tr>\" + functools.reduce(lambda x,y: x+y,\n",
    "                             map(lambda x: \"<td>\" + str(x) + \"</td>\",\n",
    "                                 numpy_array[i])\n",
    "                            ) + \"</tr>\"\n",
    "\n",
    "    return \"<table>\" + header + rows + \"</table>\"\n",
    "        \n",
    "\n",
    "reflection_table_html = HTML(\n",
    "    value=f\"dpeaks\")\n",
    "\n",
    "reflection_table = HBox(layout=Layout(width='99%', height='250px', overflow_y='auto'))\n",
    "reflection_table.children += (reflection_table_html,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "diffraction_figure, _ = plt.subplots(1, 2, figsize=(7.5,3.8), tight_layout=True)\n",
    "diffraction_output = PyplotOutput(diffraction_figure)\n",
    "\n",
    "ex12_wp = ParametersBox(a11 = (1., -4, 4, 0.1, r'$a_{11} / Å$'),\n",
    "                            a12 = (0., -4, 4, 0.1, r'$a_{12} / Å$'),\n",
    "                            a21 = (0., -4, 4, 0.1, r'$a_{21} / Å$'),\n",
    "                            a22 = (1.5, -4, 4, 0.1, r'$a_{22} / Å$'),\n",
    "                            s1 = (0.25, 0.01, 0.99, 0.01, r'$s_1$'),\n",
    "                            s2 = (0.75, 0.01, 0.99, 0.01, r'$s_2$'),\n",
    "                            f1 = (10., 1., 40., 1, r'$f_{1}$'),\n",
    "                            f2 = (30., 0, 40., 1, r'$f_{2}$'),\n",
    "                            phi = (0., 0., 2*np.pi, 0.1, r'$\\phi$'),\n",
    "                            wavelength = (0.1, 1.0, 2, 0.05, r'$\\lambda$'),\n",
    "                            refresh_mode=\"click\")\n",
    "ex12_code_demo = CodeDemo(\n",
    "            input_parameters_box=ex12_wp,\n",
    "            code_input= ex12_wci,\n",
    "            visualizers = [ClearedOutput(),diffraction_output,ClearedOutput()],\n",
    "            update_visualizers = plot_diffraction\n",
    ")\n",
    "\n",
    "answer_registry.register_answer_widget(\"ex12-function\", ex12_code_demo)\n",
    "display(ex12_code_demo)\n",
    "ex12_code_demo.run_demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set $f_2$ to zero (so that effectively this becomes a lattice with a single atom) and set the unit cell to be a $1\\times 1.2$ rectangle. Set the wavelength to 1. Observe how the position and intensity of the peaks change when you change the dimensions of the lattice.\n",
    "\n",
    "\n",
    "<span style=\"color:blue\"> **12a** What happens if you set the off-diagonal term $a_{12}$ to be (slightly) different from zero? What happens if you set the two lattice vectors to be orthogonal and equal in length?\n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex012a_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex12a-answer\", ex012a_txt)\n",
    "display(ex012a_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sumSet $f_1=30$, $f_2=10$, and set the unit cell to be a $1\\times 1.2$ rectangle. Set the fractional coordinates of the second atom to be $(0.5,0.5)$. Set the wavelength to 1. Observe how the position and intensity of the peaks change when you change the form factor of the second atom from $0$ to be equal to $f_1$.\n",
    "\n",
    "<span style=\"color:blue\"> **12b** Do the peak positions change? How do you explain the change in intensity?\n",
    "What happens if (keeping the form factors equal) you change one of the fractional coordinates to be different from $0.5$? And if you change both coordinates? How do you explain this observation?\n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex012b_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex12b-answer\", ex012b_txt)\n",
    "display(ex012b_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set $f_1=30$, $f_2=10$, and set the unit cell to be a $1\\times 1$ square. Set the fractional coordinates of the second atom to be $(0.5,0.5)$. Set the wavelength to 1. Observe how the position and intensity of the peaks change when you change the form factor of the second atom from $0$ to be $f_2=f_1=30$.\n",
    "\n",
    "<span style=\"color:blue\"> **12c** How many peaks are left when $f_2=f_1$? How do you explain this? You can obtain exactly the same diffraction pattern by setting $f_2=0$ and changing the lattice parameters. What lattice parameters should you use? \n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex012c_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex12c-answer\", ex012c_txt)\n",
    "display(ex012c_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A more challenging exercise (optional!)\n",
    "\n",
    "Write a function that takes a structure from an `ase.Atoms` frame (take e.g. those in `data/crystals.txt` that are used in the visualizer at the beginning of this notebook) and the scattering medium wavelength, and evaluates the position and intensity of the powder diffraction peaks. Assume that the atomic form factors are equal to the atomic numbers. You may also make a visualizer, if you wish so. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.12"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "160px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "461px",
    "left": "0px",
    "right": "927.667px",
    "top": "107px",
    "width": "334.867px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}