01-Atomic_scale_structures.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%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 scwidgets import (AnswerRegistry, TextareaAnswer, CodeDemo,\n",
    "                       ParametersBox, PyplotOutput, ClearedOutput,\n",
    "                       AnimationOutput,CheckRegistry,Answer)\n",
    "import ase\n",
    "from ase.io import read, write"
   ]
  },
  {
   "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_01\")\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": [
    "# Atomic structures on a computer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In an atomistic description of matter, a configuration of a structure is entirely determined by\n",
    "\n",
    "* The chemical nature of the atoms, $a_i$\n",
    "\n",
    "* Their positions, $\\mathbf{r}_i$, corresponding to a list of $(x,y,z)$ Cartesian coordinates\n",
    "\n",
    "* Possibly, three unit-cell vectors $\\mathbf{h}_{i=1,2,3}$ that descibe the periodicity of a lattice\n",
    "\n",
    "There is a [babel of formats](http://openbabel.org/), often poorly standardized, that have been developed to store atomic configurations. Notable examples are `pdb` files, used for biological structures (e.g. in the [protein data bank](https://www.rcsb.org/)), `cif` files that are often used to store crystallographic data (the main format for the [Cambridge structural database](https://www.ccdc.cam.ac.uk/solutions/csd-core/components/csd/) and the `xyz` format, one of the simplest (and most abused) formats, in which atomic positions are stored according to the schema\n",
    "\n",
    "```\n",
    "N_ATOMS\n",
    "comment line\n",
    "Element X Y Z\n",
    "...\n",
    "```\n",
    "\n",
    "The comment line is often abused to add further information, e.g. the lattice parameters following the format \n",
    "\n",
    "```\n",
    "Lattice='h1x h1y h1z h2x h2y h2z h3x h3y h3z'\n",
    "```\n",
    "\n",
    "Multiple blocks corresponding to different structures can be simply concatenated -- although many programs assume all structures in a single file to have the same number and type of atoms. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of the content of an `xyz` file (the QM7b dataset, from [DOI: 10.1088/1367-2630/15/9/095003](https://doi.org/10.1088/1367-2630/15/9/095003) ):\n",
    "\n",
    "```\n",
    "!head -n 17 data/qm7b-ase.xyz\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!head -n 17 data/qm7b-ase.xyz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\">**01** What is the chemical formula of these two structures? Can you also guess what actual molecules they correspond to? If you can't figure it out by looking at the coordinates (which are in Å), we'll look at this file later on, so you can \"cheat\" if you can't see the structure based on the distance!</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex01_txt = TextareaAnswer(\"Enter your answer\")\n",
    "answer_registry.register_answer_widget(\"ex01-answer\", ex01_txt)\n",
    "display(ex01_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading and defining atomic structures with ASE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this course we will use the [Atomic Simulation Environment](https://wiki.fysik.dtu.dk/ase/) to load and manipulate structures. ASE stores structures in an `Atoms` class, which contains `positions`, `symbols` and `cell` members. Atomic positions are typically interpreted to be expressed in Ångstrom ($10^{-10}$m).\n",
    "\n",
    "Structures can be loaded from disk using the `read` command (from `ase.io`)\n",
    "\n",
    "```\n",
    "# the second argument determines the slice of the file that will be read (e.g. 0 to load the first frame)\n",
    "# it can be either a python slice() or a string representation with the usual start[:end][:stride] format\n",
    "qm7 = read(\"data/qm7b-ase.xyz\", \":\")  \n",
    "```\n",
    "\n",
    "or created manually\n",
    "\n",
    "```\n",
    "methane = ase.Atoms(symbols=\"CH4\", positions=[ \n",
    "    [1.00, -0.00, -0.00], \n",
    "    [2.09, 0.00,  0.00], \n",
    "    [0.63,  1.03,  0.00], \n",
    "    [0.63, -0.53,  0.88],\n",
    "    [0.64, -0.51, -0.91]]\n",
    "    )\n",
    "```\n",
    "\n",
    "The atomic positions, labels, or the unit cell can also be modified as common arrays\n",
    "\n",
    "```\n",
    "methane.symbols[1] = \"Cl\"   # turn the molecule into chloromethane\n",
    "```\n",
    "\n",
    "*NB:*\n",
    "1. the frame indices are 0-based\n",
    "2. atoms indices are 0-based\n",
    "3. symbols, positions and cell can be manipulated as arrays, but implement some syntactic sugar, e.g. you can set symbols in compact, string form, e.g. `methane.symbols = \"CH4\"`\n",
    "See the [documentation for the `ase.Atoms` object](https://wiki.fysik.dtu.dk/ase/ase/atoms.html) for more details. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\"> **02** Write a function that loads the structure with index 1 from the `data/qm7b-ase.xyz`. What is it? Modify the structure so it corresponds to methylammonium, $\\mathrm{CH_3NH_3^+}$, one of the organic cations used in [hybrid perovskite solar cells](https://en.wikipedia.org/wiki/Methylammonium_lead_halide).\n",
    "Get a nice snapshot of the structure! </span> <br>\n",
    "\n",
    "You can also play around with the function to load the full file (use `index=\":\"` as an option) and visualize the 7000-something molecules in the QM7 dataset. Experiment with the visualization options of the widget."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fingerprint_ase_atoms(atoms):\n",
    "    return np.sum(atoms.get_all_distances()*atoms.numbers)\n",
    "\n",
    "def chemiscope_update_visualizers_structure(code_input, visualizers):\n",
    "    cleared_output = visualizers[0]\n",
    "    structure = code_input.get_function_object()()\n",
    "    if len(structure) != 0: # silently reject a void code_input\n",
    "        cleared_output = visualizers[0]\n",
    "        with cleared_output:\n",
    "            chemiscope_widget = chemiscope.show(frames = [structure], properties=chemiscope.extract_properties([structure]), mode=\"structure\")\n",
    "            display(chemiscope_widget)\n",
    "\n",
    "def fingerprint_ex02(output):\n",
    "    assert isinstance(output, ase.Atoms), f\"TypeAssert failed: Expected type ase.Atoms but got {type(output)}.\"\n",
    "    assert len(output) == 8, f\"LenAssert failed: Expected length {8} but got {len(output)}.\"\n",
    "    assert np.sum(7 == output.numbers) == 1, f\"One nitrogen is expected in the molecule. Found {np.sum(7 == output.numbers)} nitrogen(s).\"\n",
    "    assert np.sum(1 == output.numbers) == 6, f\"Six hydrogens are expected in the molecule. Found {np.sum(1 == output.numbers)} hydrogen(s).\"\n",
    "    \n",
    "    return fingerprint_ase_atoms(output)\n",
    "\n",
    "ex02_wci = WidgetCodeInput(\n",
    "        function_name=\"methylammonium\", \n",
    "        function_parameters=\"\",\n",
    "        docstring=\"\"\"\n",
    "Loads the structure #1 from the data/qm7b-ase.xyz file, \n",
    "and modifies the composition so that it corresponds to CH3NH3+. \n",
    "\n",
    ":return: an ASE atoms object that describes the molecular structure\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",
    "import ase\n",
    "from ase.io import read\n",
    "\n",
    "structure = []  # load here\n",
    "\n",
    "# modify the structure ...\n",
    "\n",
    "return structure\n",
    "\"\"\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ex02_updater(code_input,visualizers):\n",
    "    structure = code_input.get_function_object()()\n",
    "    if type(structure) is ase.Atoms: # chemiscope.show expects a list\n",
    "        structure = [structure]\n",
    "        \n",
    "    if len(structure) != 0: # silently reject a void code_input\n",
    "        clear_output = visualizers[0]\n",
    "        with clear_output:\n",
    "            cs_widget = chemiscope.show(frames = structure, properties=chemiscope.extract_properties(structure), mode=\"structure\")\n",
    "            display(cs_widget)\n",
    "\n",
    "ex02_code_demo = CodeDemo(code_input= ex02_wci,\n",
    "                          check_registry=check_registry,\n",
    "                          visualizers = [ClearedOutput()], \n",
    "                          update_visualizers = chemiscope_update_visualizers_structure\n",
    "                          )\n",
    "\n",
    "check_registry.add_check(ex02_code_demo,\n",
    "                         inputs_parameters=[{}],\n",
    "                         reference_outputs=[237.7334114111937],\n",
    "                         fingerprint=fingerprint_ex02\n",
    "                         ) \n",
    "\n",
    "answer_registry.register_answer_widget(\"ex02-function\", ex02_code_demo)\n",
    "display(ex02_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit cell and periodic structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ASE format and the structure viewer allows also to manipulate periodic structures corresponding to bulk materials. To do so, you need to set the `cell` member of an `Atoms` structure to contain the (row-major) cell matrix. ASE considers separately the information on whether the unit cell should be considered as indicating just a finite volume that contains the atoms, or as a periodic repeat unit: this is controlled by the `pbc` parameter - standing for Periodic Boundary Conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Polonium is the only element that crystallizes in a simple-cubic structure. It has a density of 9.196 g/cm<sup>3</sup>. The isotope of polonium that can be isolated from uranium ores is $\\mathrm{^{210} Po}$,     that has a molar mass of 210 g/mol. Consider that one mole contains `6.02214076e23` atoms.\n",
    "\n",
    "<span style=\"color:blue\">**03a** What is the lattice parameter of simple-cubic Po? </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex03_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex03-answer\", ex03_txt)\n",
    "display(ex03_txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\">**03b** Write a function that returns an `Atoms` object that describes a single unit cell of Po, with one atom at the origin, and take a snapshot! </span>\n",
    "\n",
    "Take this opportunity to experiment with the visualization options for crystalline structures: by clicking on the ☰ icon, you can choose to visualize the unit cell, and replicate the cell multiple times along the three axes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex03_wci = WidgetCodeInput(\n",
    "        function_name=\"polonium\", \n",
    "        function_parameters=\"\",\n",
    "        docstring=\"\"\"\n",
    "Build a unit cell of simple-cubic, alpha-Po. \n",
    "\n",
    ":return: an ASE atoms object that describes the unit cell structure\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",
    "import ase\n",
    "from ase.io import read\n",
    "\n",
    "a0 = 0. # lattice parameter\n",
    "# complete the call, substituting placeholders with actual values\n",
    "structure = ase.Atoms(symbols=\"...\", positions= ... , \n",
    "                      cell= [ [...], ...] , \n",
    "                      pbc=True)\n",
    "\n",
    "return structure\n",
    "\"\"\"\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ex03_updater(code_input,visualizers):\n",
    "    structure = code_input.get_function_object()()\n",
    "    if len(structure) != 0: # silently reject a void code_input\n",
    "        clear_output = visualizers[0]\n",
    "        with clear_output:\n",
    "            cs_widget = chemiscope.show(frames = structure, mode=\"structure\", \n",
    "                                properties={'dummy' : {\"target\":\"structure\", 'values': [0]}} )\n",
    "            display(cs_widget)\n",
    "def ex03_fingerprint(output):\n",
    "    assert isinstance(output, ase.Atoms), f\"TypeAssert failed: Expected type ase.Atoms but got {type(output)}.\"\n",
    "    assert len(output) == 1, f\"LenAssert failed: Expected length 1 but got {len(output)}.\"\n",
    "    assert np.sum(84 == output.numbers) == 1, f\"One Polonium is expected in the molecule. Found {np.sum(84 == output.numbers)} Polonium atom(s).\"\n",
    "    assert np.allclose(output.cell,3.3596173*np.eye(3)), f\"Unit cell has wrong dimensions.\"\n",
    "    return fingerprint_ase_atoms(output)\n",
    " \n",
    "    \n",
    "ex03_code_demo = CodeDemo(code_input= ex03_wci,\n",
    "                          check_registry=check_registry,\n",
    "                          visualizers = [ClearedOutput()],\n",
    "                          update_visualizers = chemiscope_update_visualizers_structure)\n",
    "\n",
    "check_registry.add_check(ex03_code_demo,\n",
    "                         inputs_parameters=[{}],\n",
    "                         reference_outputs=[0.0],\n",
    "                         fingerprint=ex03_fingerprint) \n",
    "\n",
    "answer_registry.register_answer_widget(\"ex03-function\", ex03_code_demo)\n",
    "display(ex03_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Periodic-boundary conditions, supercells, wrapping structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Periodic boundary conditions are not only used to model perfect crystals. They are also used as a practical way to describe bulk systems, while using a finite number of atomic degrees of freedom: the size of the cell and the coordinates of the atoms in a single repeate unit. Compare these two systems:\n",
    "\n",
    "a) a finite-sized droplet with 10 water molecules\n",
    "<img src=\"figures/pbc-1.png\" width=\"400\"/>\n",
    "b) a periodic system with a repeat unit of 10 water molecules\n",
    "<img src=\"figures/pbc-2.png\" width=\"400\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\">**04** Discuss briefly in which ways the two scenarios differ from bulk water: these are usually referred to as _finite-size effects._ \n",
    "You can think of the impact of having just a finite number of water molecules in terms of the atomic environment \"seen\" by each water molecule, or discuss in more macroscopic terms based on bulk and interfaces. Which of the two cases would you expect to be closer to the limit of a large number of water molecules? </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": [
    "We will see later how we can define and compute interactions in a periodic system such as this. For the moment, let's look at a snapshot from a real simulation of liquid water, with a supercell containing 32 water molecules. You'll need to load the file `data/h2o-32-snapshot.xyz`, and return it as an `Atoms` object. Switch on the unit cell visualization and look at the position of the water molecules relative to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\">**05a** After you have looked at the original structure, write code to \"fold\" the coordinates of the atoms so that they are within the unit cell. Some molecules will be \"broken\" across cell boundaries - you can see what happens when you visualize multiple periodic replicas, using the `supercell` options in the visualizer.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex05_wci = WidgetCodeInput(\n",
    "        function_name=\"water_pbc\", \n",
    "        function_parameters=\"\",\n",
    "        docstring=\"\"\"\n",
    "Loads data/h2o-32-snapshot.xyz as an ase.Atoms object, folds the atomic\n",
    "coordinates into the supercell, and returns it so it can be visualized \n",
    "\n",
    ":return: an ASE atoms object containing the atomic coordinates \"folded\" \n",
    "     into the unit cell.\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",
    "import ase\n",
    "from ase.io import read\n",
    "\n",
    "# complete the call, substituting placeholders with actual values\n",
    "structure = read( ... )\n",
    "\n",
    "# add here code to wrap the structure. you'll need to use the cell parameters and the \n",
    "# atomic positions. \n",
    "# NB1: ASE has a wrap() method \n",
    "# structure.wrap()\n",
    "# you can use it to get an idea of what should happen, but you'll have to implement\n",
    "# wrapping yourself\n",
    "# NB2: the positions of each atom should be modified, shifting them by an integer number\n",
    "#      of lattice parameters so they are between 0 and the lattice parameter.\n",
    "# NB3: you can (and should) exploit the fact that the supercell is cubic, but if you\n",
    "#     want extra brownie points you can try a general version. \n",
    "\n",
    "# structure.positions = ....\n",
    "\n",
    "return structure\n",
    "\"\"\"\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ex05_updater(code_input,visualizers):\n",
    "    structure = code_input.get_function_object()()\n",
    "        \n",
    "    if len(structure) != 0: # silently reject a void code_input\n",
    "        clear_output = visualizers[0]\n",
    "        with clear_output:\n",
    "            cs_widget = chemiscope.show(frames = [ structure ], mode=\"structure\", \n",
    "                                        properties={'dummy' : {\"target\":\"structure\", 'values': [0]}} )\n",
    "            display(cs_widget)\n",
    "    \n",
    "def ex05_fingerprint(output):\n",
    "    # reproduce default asserts here\n",
    "    assert isinstance(output, ase.Atoms), f\"TypeAssert failed: Expected type ase.Atoms but got {type(output)}.\"\n",
    "    assert len(output) == 96, f\"LenAssert failed: Expected length 96 but got {len(output)}.\"\n",
    "    return fingerprint_ase_atoms(output)\n",
    "\n",
    "ex05_code_demo = CodeDemo(code_input= ex05_wci,\n",
    "                          check_registry=check_registry,\n",
    "                          visualizers = [ClearedOutput()],\n",
    "                          update_visualizers = chemiscope_update_visualizers_structure\n",
    ")\n",
    "\n",
    "check_registry.add_check(ex05_code_demo,\n",
    "                         inputs_parameters=[{}],\n",
    "                         reference_outputs=[199303.2380212066],\n",
    "                         fingerprint=ex05_fingerprint,\n",
    "                         equal=np.allclose\n",
    "                         ) \n",
    "\n",
    "answer_registry.register_answer_widget(\"ex05-function\", ex05_code_demo)\n",
    "display(ex05_code_demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue\">**05b** Does the structure before folding \"look\" at all like liquid water? Do you think that the physical properties of the structure with the atoms folded within the unit cell are different from those of the original structure? Keep in mind that a supercell is meant to describe an infinite bulk solid, and not only the set of atoms that are explicitly displayed.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex05_txt = TextareaAnswer(\"Enter your answer here\")\n",
    "answer_registry.register_answer_widget(\"ex05-answer\", ex05_txt)\n",
    "display(ex05_txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.12.3"
  },
  "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": "139px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}