notebook/band-theory/brillouin_zone.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "conditional-elizabeth",
   "metadata": {},
   "source": [
    "# **Reciprocal Space and Brillouin Zone**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "strange-injury",
   "metadata": {},
   "source": [
    "**Authors:** Taylor James Baird, Dou Du and Giovanni Pizzi\n",
    "\n",
    "<i class=\"fa fa-home fa-2x\"></i><a href=\"../index.ipynb\" style=\"font-size: 20px\"> Go back to index</a>\n",
    "\n",
    "**Source code:** https://github.com/osscar-org/quantum-mechanics/blob/master/notebook/band-theory/brillouin_zone.ipynb\n",
    "<p style=\"text-align: justify;font-size:15px\">\n",
    "    In this notebook, we explore two central concepts in electronic structure and band theory: those of reciprocal space and the Brillouin zone.\n",
    "</p>\n",
    "<hr style=\"height:1px;border:none;color:#cccccc;background-color:#cccccc;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "infrared-calculation",
   "metadata": {},
   "source": [
    "## **Goals**\n",
    "* Appreciate the nature of the relationship between the real and reciprocal space descriptions of a crystalline system.\n",
    "* Use this understanding to explain the differences in the Brillouin zones observed for different crystal structures. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eacf9dfd-66ac-47f3-a490-1eb0566210de",
   "metadata": {},
   "source": [
    "## **Background theory** \n",
    "\n",
    "[More on the background theory.](./theory/theory_brillouin_zone.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0ee56a7-baf1-42d7-a28d-0435ec5c8cde",
   "metadata": {},
   "source": [
    "## **Tasks and exercises** \n",
    "\n",
    "<ol style=\"text-align: justify;font-size:15px\">\n",
    "    <li> What is the relationship between real space primitive vectors and reciprocal space\n",
    "        primitive vectors? \n",
    "    <details>\n",
    "    <summary style=\"color: red\">Solution</summary>\n",
    "    The definition of the reciprocal lattice vector $\\vec{b}_1$ is:\n",
    "    $$\\vec{b}_1 = 2\\pi \\frac{\\vec{a}_2 \\times \\vec{a}_3}{\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)}$$\n",
    "    Hence, the dot products of each real space primitive vectors with $\\vec{b}_1$ are\n",
    "    computed as:\n",
    "    $$\\vec{a}_1 \\cdot \\vec{b}_1 = 2 \\pi \\vec{a}_1  \\cdot  \\frac{\\vec{a}_2 \\times \\vec{a}_3}{\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)} = 2  \\pi$$\n",
    "    $$\\vec{a}_2 \\cdot  \\vec{b}_1 =2 \\pi  \\vec{a}_2 \\cdot  \\frac{\\vec{a}_2 \\times \\vec{a}_3}{\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)} = 0$$\n",
    "    $$\\vec{a}_3 \\cdot  \\vec{b}_1 =2 \\pi  \\vec{a}_3 \\cdot  \\frac{\\vec{a}_2 \\times \\vec{a}_3}{\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)} = 0$$\n",
    "    Similarly, one can compute for other reciprocal lattice vector $\\vec{b}_2$ and \n",
    "    $\\vec{b}_3$. In summary, we have the relation as $\\vec{a}_i \\cdot \\vec{b}_j = 2\\pi \\delta _{ij}$.\n",
    "    </details>\n",
    "    </li>\n",
    "    <li> What is the volume of the primitive cell in reciprocal space? How it is related \n",
    "         to the volume of the real space primitive cell? Please give a mathematical proof.  \n",
    "    <details>\n",
    "    <summary style=\"color: red\">Solution</summary>\n",
    "    The volume of the primitive cell in reciprocal space, $\\Omega_b$, can be calculated as:\n",
    "        $$\\Omega_b =  \\vec{b}_1 \\cdot (\\vec{b}_2 \\times \\vec{b}_3) = \n",
    "        2\\pi \\frac{\\vec{a}_2 \\times \\vec{a}_3}{\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)}\n",
    "        (\\vec{b}_2 \\times \\vec{b}_3)$$\n",
    "    According to the Lagrange's identity, one can show:\n",
    "        $$(\\vec{a}_2 \\times \\vec{a}_3) \\cdot (\\vec{b}_2 \\times \\vec{b}_3) =\n",
    "        (\\vec{a}_2 \\cdot \\vec{b}_2)(\\vec{a}_3 \\cdot \\vec{b}_3) - \n",
    "        (\\vec{a}_2 \\cdot \\vec{b}_3)(\\vec{a}_3 \\cdot \\vec{b}_2) = 2\\pi \\cdot 2\\pi - 0 = 4\\pi^2$$\n",
    "    Hence,\n",
    "        $$\\Omega_b = \\frac{8\\pi^3}{\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)} = \\frac{8\\pi^3}{\\Omega_a}$$\n",
    "    where, $\\Omega_a$ is the volume of the real space primitive cell.\n",
    "    </details>   \n",
    "    </li>\n",
    "    <li> What are the structures of the Wigner-Seitz primitive cells for the BCC and FCC lattices? How about their 1st Brillouin zones?\n",
    "    <details>\n",
    "    <summary style=\"color: red\">Solution</summary>\n",
    "    <div style=\"text-align:center\">\n",
    "    <img src=\"./images/BCC.png\" alt=\"drawing\" style=\"width:300px;\"/>\n",
    "    <figcaption>Figure 1. Demonstration of the procedure for constructing the primitive lattice vectors for the body-centered cubic (BCC) structure.</figcaption>\n",
    "    </div>\n",
    "    For a BCC structure, as shown in the Figure 1, the primitive lattice vectors can\n",
    "    be constructed as:\n",
    "        $$\\vec{a}_1 = \\frac{a}{2} (\\vec{x}+\\vec{y}-\\vec{z})$$\n",
    "        $$\\vec{a}_2 = \\frac{a}{2} (-\\vec{x}+\\vec{y}+\\vec{z})$$\n",
    "        $$\\vec{a}_3 = \\frac{a}{2} (\\vec{x}-\\vec{y}+\\vec{z})$$\n",
    "        \n",
    "    The corresponding reciprocal lattice vectors are:\n",
    "        $$\\vec{b}_1 = 2\\pi \\frac{\\vec{a}_2 \\times \\vec{a}_3}\n",
    "        {\\vec{a}_1 (\\vec{a}_2 \\times \\vec{a}_3)} = \\frac{2\\pi}{\\Omega}\n",
    "        (\\vec{a}_2 \\times \\vec{a}_3) = \\frac{\\pi a^2}{\\Omega} (x + y)$$\n",
    "        \n",
    "        $$\\vec{b}_2 = 2\\pi \\frac{\\vec{a}_3 \\times \\vec{a}_1}\n",
    "        {\\vec{a}_1 (\\vec{a}_2 \\times \\vec{a}_3)} = \\frac{2\\pi}{\\Omega}\n",
    "        (\\vec{a}_3 \\times \\vec{a}_1) = \\frac{\\pi a^2}{\\Omega} (y + z)$$\n",
    "        \n",
    "        $$\\vec{b}_1 = 2\\pi \\frac{\\vec{a}_1 \\times \\vec{a}_2}\n",
    "        {\\vec{a}_1 (\\vec{a}_2 \\times \\vec{a}_3)} = \\frac{2\\pi}{\\Omega}\n",
    "        (\\vec{a}_2 \\times \\vec{a}_3) = \\frac{\\pi a^2}{\\Omega} (x + y)$$\n",
    "        \n",
    "    <div style=\"text-align:center\">\n",
    "    <img src=\"./images/FCC.png\" alt=\"drawing\" style=\"width:300px;\"/>\n",
    "    <figcaption>Figure 2.Demonstration of the procedure for constructing the primitive lattice vectors for the face-centered cubic (FCC) structure.</figcaption>\n",
    "    </div>\n",
    "        \n",
    "    For an FCC structure as shown in Figure 2, the primitive lattice vectors can\n",
    "    be constructed as:\n",
    "        $$\\vec{a}_1 = \\frac{a}{2} (\\vec{x}+\\vec{y})$$\n",
    "        $$\\vec{a}_2 = \\frac{a}{2} (\\vec{y}+\\vec{z})$$\n",
    "        $$\\vec{a}_3 = \\frac{a}{2} (\\vec{z}+\\vec{x})$$\n",
    "    \n",
    "    The corresponding reciprocal lattice vectors are:\n",
    "    \n",
    "    $$\\vec{b}_1 = 2\\pi \\frac{\\vec{a}_2 \\times \\vec{a}_3}\n",
    "        {\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)} = \\frac{2\\pi}{\\Omega}\n",
    "        (\\vec{a}_2 \\times \\vec{a}_3) = \\frac{\\pi a^2}{2 \\Omega}\n",
    "        (\\vec{x}+\\vec{y}-\\vec{z})$$\n",
    "        \n",
    "    $$\\vec{b}_2 = 2\\pi \\frac{\\vec{a}_3 \\times \\vec{a}_1}\n",
    "        {\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)} = \\frac{2\\pi}{\\Omega}\n",
    "        (\\vec{a}_3 \\times \\vec{a}_1) = \\frac{\\pi a^2}{2 \\Omega}\n",
    "        (-\\vec{x}+\\vec{y}+\\vec{z})$$\n",
    "        \n",
    "    $$\\vec{b}_1 = 2\\pi \\frac{\\vec{a}_1 \\times \\vec{a}_2}\n",
    "        {\\vec{a}_1 \\cdot (\\vec{a}_2 \\times \\vec{a}_3)} = \\frac{2\\pi}{\\Omega}\n",
    "        (\\vec{a}_2 \\times \\vec{a}_3) = \\frac{\\pi a^2}{2 \\Omega}\n",
    "        (\\vec{x}-\\vec{y}+\\vec{z})$$\n",
    "    \n",
    "    One can see that the reciprocal lattice vectors of the BCC structure are simply \n",
    "    the real space primitive lattice vectors of the FCC structure. Conversely, the reciprocal lattice of the FCC structure\n",
    "    is just that of BCC structure in real space. In other words, the 1st Brillouin zone of the BCC structure\n",
    "    has the same structure as the Wigner-Seitz primitive cell of FCC.\n",
    "    And the 1st Brillouin zone of the FCC lattice has the same structure as the\n",
    "    the Wigner-Seitz primitive cell of BCC.\n",
    "    </details>   \n",
    "    </li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "265b5e68-f58c-40f5-a0b9-b5b7cd40e00b",
   "metadata": {},
   "source": [
    "<hr style=\"height:1px;border:none;color:#cccccc;background-color:#cccccc;\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "posted-injection",
   "metadata": {},
   "outputs": [],
   "source": [
    "from widget_bzvisualizer import BZVisualizer\n",
    "import numpy as np\n",
    "import seekpath\n",
    "import nglview as nv\n",
    "from ase.build import bulk, molecule\n",
    "from ipywidgets import HBox, VBox, Button, Output, Text, Tab, Layout, Label, HTML, Dropdown\n",
    "import ipywidgets as widgets\n",
    "import nglview as nv\n",
    "from ase import Atom, Atoms\n",
    "from ase.symbols import symbols2numbers\n",
    "from ase.data import atomic_numbers\n",
    "from ase.lattice.cubic import BodyCenteredCubic,SimpleCubic, FaceCenteredCubic\n",
    "from ase.lattice.orthorhombic import *\n",
    "from ase.lattice.triclinic import Triclinic\n",
    "from ase.lattice.monoclinic import *\n",
    "from ase.lattice.tetragonal import *\n",
    "import logging\n",
    "from ase.lattice.hexagonal import Hexagonal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bd45845-7969-4808-aba4-8f60f850f139",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "mat = SimpleOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': 3.6, 'b': 3.6, 'c': 3.6})\n",
    "\n",
    "\n",
    "m = nv.NGLWidget(width='400px', height='400px')\n",
    "\n",
    "m.stage.set_parameters(**{\n",
    "    # percentages, start of fog and where on full effect\n",
    "    \"fogNear\": 100, \"fogFar\": 100,\n",
    "    # background color\n",
    "    \"backgroundColor\": \"white\",\n",
    "})\n",
    "\n",
    "c1 = m.add_component(nv.ASEStructure(mat))\n",
    "\n",
    "m.clear()\n",
    "m.add_spacefill(radius=0.4)\n",
    "m.add_unitcell()\n",
    "# m.add_axes()\n",
    "mpos = [];\n",
    "msym = [];\n",
    "\n",
    "for i in mat:\n",
    "    mpos.append(i.position.tolist())\n",
    "    msym.append('Cu')\n",
    "\n",
    "a=3.6\n",
    "b=3.6\n",
    "c=3.6\n",
    "real_lattice=np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) *a/ 2.0;\n",
    "\n",
    "w = BZVisualizer(real_lattice, [[0.0, 0.0, 0.0]], [1], True, height='400px',width='400px', enable_interaction=True)\n",
    "\n",
    "# dictionary to keep track of lattice parameters for easy reversion and comparison\n",
    "param_dict = {'Cubic': {'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90,'gamma':90},\\\n",
    "'Cubic-Primitive': {'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90,'gamma':90},\\\n",
    "'Cubic-Body-centered': {'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90,'gamma':90},\\\n",
    "'Cubic-Face-centered': {'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90,'gamma':90},\\\n",
    "'Hexagonal-Primitive':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Rhombohedral-Primitive':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Tetragonal-Primitive':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Tetragonal-Body-centered':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Orthorhombic-Primitive':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Orthorhombic-Face-centered':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Orthorhombic-Body-centered':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Orthorhombic-Base-centered':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Monoclinic-Primitive':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Monoclinic-Base-centered':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90},\\\n",
    "'Triclinic':{'a':3.0,'b':3.0,'c':3.0,'alpha':90,'beta':90, 'gamma':90}}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e813f33a-8d73-469f-8b9b-ec4e93763abc",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "now contents are dropdwn menus. \n",
    "Depending on the crystal family selected, there shall be a dropdown menu \n",
    "\n",
    "\"\"\"\n",
    "crystal_family = 'Cubic'\n",
    "crystal_family_radio = widgets.RadioButtons(options=['Cubic','Hexagonal','Rhombohedral','Tetragonal','Orthorhombic','Monoclinic','Triclinic'],\n",
    "                                           value='Cubic',    \n",
    "                                           disabled=False)\n",
    "\n",
    "centering_radio = widgets.RadioButtons(options=['Primitive','Body-centered', 'Face-centered'],\n",
    "                                           value='Primitive',\n",
    "                                           disabled=False)\n",
    "\n",
    "\n",
    "crystal_family_title=Text(value='Crystal family')\n",
    "col0 = VBox([crystal_family_title, crystal_family_radio])\n",
    "centering_title=Text(value='Centering')\n",
    "col1 = VBox([centering_title, centering_radio])\n",
    "\n",
    "\n",
    "# Callback which reverts lattice parameters to their saved values.\n",
    "def on_revert_lattice_params(change):\n",
    "    \n",
    "    crystal_family = crystal_family_radio.value\n",
    "    centering=centering_radio.value\n",
    "    a_slider.value=param_dict[crystal_family+'-'+centering]['a']\n",
    "    b_slider.value=param_dict[crystal_family+'-'+centering]['b']\n",
    "    c_slider.value=param_dict[crystal_family+'-'+centering]['c']\n",
    "    alpha_slider.values=param_dict[crystal_family+'-'+centering]['alpha'] \n",
    "    beta_slider.values=param_dict[crystal_family+'-'+centering]['beta'] \n",
    "    gamma_slider.values=param_dict[crystal_family+'-'+centering]['gamma']\n",
    "    \n",
    "    compute_BZ()\n",
    "    \n",
    "def on_save_lattice_params(change):\n",
    "    \n",
    "    crystal_family = crystal_family_radio.value\n",
    "\n",
    "    \n",
    "    a = a_slider.value\n",
    "    b = b_slider.value\n",
    "    c = c_slider.value\n",
    "\n",
    "    alpha=alpha_slider.value\n",
    "    beta=beta_slider.value\n",
    "    gamma=gamma_slider.value\n",
    "    \n",
    "\n",
    "    centering=centering_radio.value\n",
    "    \n",
    "    # save lattice parameters for retrieval after a change of crystal family\n",
    "    \n",
    "  \n",
    "    param_dict[crystal_family+'-'+centering]['a'] = a\n",
    "    param_dict[crystal_family+'-'+centering]['b'] = b\n",
    "    param_dict[crystal_family+'-'+centering]['c'] = c\n",
    "    param_dict[crystal_family+'-'+centering]['alpha'] = alpha\n",
    "    param_dict[crystal_family+'-'+centering]['beta'] = beta\n",
    "    param_dict[crystal_family+'-'+centering]['gamma'] = gamma\n",
    "    \n",
    "\n",
    "\n",
    "def on_orientation_sync(c):\n",
    "    ngl_dict=m.__dict__['_trait_values']\n",
    "    init_ngl_matrix= np.array([24.451005287902106, 0.0, 0.0, -3.5999999046325684, 0.0, 24.451005287902106, 0.0, -3.5999999046325684, 0.0, 0.0, 24.451005287902106, -3.5999999046325684, 0.0, 0.0, 0.0, 1.0]).reshape((4,4))\n",
    "    temp = (np.linalg.inv(init_ngl_matrix))@np.array(ngl_dict[\"_camera_orientation\"]).reshape(4,4).T\n",
    "    temp2 = (np.array(ngl_dict[\"_camera_orientation\"]).reshape(4,4).T)@(np.linalg.inv(init_ngl_matrix))\n",
    "    ngl_extmat=np.array(ngl_dict[\"_camera_orientation\"]).reshape(4,4).T\n",
    "    init_worldmatrix = np.array([1,0,0,0,0,1,0,0,0,0,1,0,0,0,10.471975511965978,1]).reshape((4,4)).T\n",
    "    ngl_extmat = init_worldmatrix@temp\n",
    "#     orientation = init_worldmatrix@temp\n",
    "#     orientation = temp@init_worldmatrix\n",
    "#     ngl_extmat = temp@np.linalg.inv(init_worldmatrix)\n",
    "#     ngl_extmat = temp@init_worldmatrix\n",
    "\n",
    "#     ngl_extmat = temp2@init_worldmatrix\n",
    "\n",
    "    R=ngl_extmat[0:3,0:3]\n",
    "    T=ngl_extmat[0:3,-1]\n",
    "    campos=list(-(R.T)@T) \n",
    "    camdir=list((R.T)@np.array([0,0,1]))\n",
    "    cam_dict={\"campos\":campos, \"camdir\":camdir}\n",
    "\n",
    "# #     orientation=temp\n",
    "# #     orientation = orientation.T\n",
    "#     orientation = orientation.flatten()\n",
    "#     orientation[-1] = 1\n",
    "#     orientation[12]=0.\n",
    "#     orientation[13]=0.\n",
    "#     orientation[14]=0.\n",
    "#     orientation *=1/100.\n",
    "#     orientation[3] =0.\n",
    "#     orientation[7] =0.\n",
    "#     orientation[11]=0.\n",
    "\n",
    "#     orientation -= np.array([24.451005287902106, 0.0, 0.0, -3.5999999046325684, 0.0, 24.451005287902106, 0.0, -3.5999999046325684, 0.0, 0.0, 24.451005287902106, -3.5999999046325684, 0.0, 0.0, 0.0, 0.0])\n",
    "#     orientation += np.array([1,0,0,0,0,1,0,0,0,0,1,0,0,0,10.471975511965978,0])\n",
    "    #     orientation=[0.7500277180472348,5.551115123125783e-17,0.6614063971272561,0,0.5078318190417079,0.6406823725596474,-0.5758758035029177,0,-0.4237514197376189,0.7678060285588679,0.48052953788400066,0,-4.437514490653162,8.040445929008314,5.0320935534975835,1]\n",
    "#     orientation = [0.7683450340620741,-5.551115123125783e-17,0.6400358651139405,0,0.5491434688219112,0.5136687465056196,-0.659231271644166,0,-0.32876642055171756,0.8579885890053234,0.39467483053048313,0,-3.964409288439841,8.830108018321802,3.6037858154548483,1]\n",
    "   # orientation = [0.9709872600909863,0,0.2391312207575565,0,0.23913122075743692,0.0000010000000000287557,-0.9709872600905007,0,-2.3913122074170623e-7,0.9999999999995,9.709872600405234e-7,0,-0.000002504176287919244,10.471975511960737,0.000010168154810102051,1]\n",
    "    w.orientation=cam_dict\n",
    "#     w.orientation = list(orientation)\n",
    "    # with output:\n",
    "    #     #print(\"set orientation ={}\".format(w.orientation))\n",
    "    #     ngl_dict=m.__dict__['_trait_values']\n",
    "        \n",
    "#         print(\"w = {}\\n\".format(w.__dict__))\n",
    "#         print(\"init_world_matrix= {}\".format(init_worldmatrix))\n",
    "\n",
    "#         print(\"init_ngl_matrix= {}\".format(init_ngl_matrix))\n",
    "        \n",
    "#         print(\"np.array(ngl_dict[\\\"_camera_orientation\\\"]).reshape(4,4).T = {}\\n\".format(np.array(ngl_dict[\"_camera_orientation\"]).reshape(4,4).T))\n",
    "#         print(\"camdict={}\".format(cam_dict))\n",
    "#         print(\"(np.linalg.inv(init_ngl_matrix)@np.array(ngl_dict[\\\"_camera_orientation\\\"]).reshape(4,4)).T{}\".format(np.linalg.inv(init_ngl_matrix)@np.array(ngl_dict[\"_camera_orientation\"]).reshape(4,4)))\n",
    "        # set the bz visualizer camera orientation equal to this\n",
    "\n",
    "\n",
    "\n",
    "output = Output(layout=Layout(width=\"400px\"))\n",
    "a_slider=widgets.FloatSlider(\n",
    "    value=3.5,\n",
    "    min=0,\n",
    "    max=10.0,\n",
    "    step=0.1,\n",
    "    description='a:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "b_slider=widgets.FloatSlider(\n",
    "    value=3.5,\n",
    "    min=0,\n",
    "    max=10.0,\n",
    "    step=0.1,\n",
    "    description='b:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "c_slider=widgets.FloatSlider(\n",
    "    value=3.5,\n",
    "    min=0,\n",
    "    max=10.0,\n",
    "    step=0.1,\n",
    "    description='c:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "alpha_slider=widgets.FloatSlider(\n",
    "    value=90.,\n",
    "    min=0,\n",
    "    max=180,\n",
    "    step=0.1,\n",
    "    description=r'$\\alpha$:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "beta_slider=widgets.FloatSlider(\n",
    "    value=90.,\n",
    "    min=0,\n",
    "    max=180,\n",
    "    step=0.1,\n",
    "    description=r'$\\beta$:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "gamma_slider=widgets.FloatSlider(\n",
    "    value=90.,\n",
    "    min=0,\n",
    "    max=180,\n",
    "    step=0.1,\n",
    "    description=r'$\\gamma$:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "\n",
    "def fix_sliders_ab(a):\n",
    "    # fix value of b to that of a\n",
    "    return a\n",
    "\n",
    "def fix_sliders_ac(a):\n",
    "    # fix value of b and c sliders to that of a\n",
    "    return a\n",
    "\n",
    "def fix_sliders_alpha_beta(alpha):\n",
    "    # fix value of b and c sliders to that of a\n",
    "    return alpha\n",
    "\n",
    "def fix_sliders_alpha_gamma(alpha):\n",
    "    # fix value of b and c sliders to that of a\n",
    "    return alpha\n",
    "\n",
    "# set up link between a and b sliders\n",
    "l_ab = widgets.dlink((a_slider, 'value'), (b_slider, 'value'),transform=fix_sliders_ab)\n",
    "l_ab.link()\n",
    "l_ab_flag=True # flags for keeping track of link status\n",
    "\n",
    "# set up link between a and c sliders\n",
    "l_ac = widgets.dlink((a_slider, 'value'), (c_slider, 'value'),transform=fix_sliders_ac)\n",
    "l_ac.link()\n",
    "l_ac_flag=True\n",
    "\n",
    "# set up link between alpha and beta sliders\n",
    "l_alpha_beta = widgets.dlink((alpha_slider, 'value'), (beta_slider, 'value'),transform=fix_sliders_alpha_beta)\n",
    "l_alpha_beta.link()\n",
    "l_alpha_beta_flag=True\n",
    "\n",
    "# set up link between alpha and gamma sliders\n",
    "l_alpha_gamma = widgets.dlink((alpha_slider, 'value'), (gamma_slider, 'value'),transform=fix_sliders_alpha_gamma)\n",
    "l_alpha_gamma.link()\n",
    "l_alpha_gamma_flag=True\n",
    "\n",
    "\n",
    "# default settings for cubic crystal type\n",
    "alpha_slider.value=90\n",
    "beta_slider.value=90\n",
    "gamma_slider.value=90\n",
    "alpha_slider.disabled=True\n",
    "beta_slider.disabled=True\n",
    "gamma_slider.disabled=True\n",
    "b_slider.disabled=True\n",
    "c_slider.disabled=True\n",
    "\n",
    "revert_lattice_params_button = Button(description=\"Revert lattice parameters.\", layout = Layout(width='auto'))\n",
    "revert_lattice_params_button.on_click(on_revert_lattice_params)\n",
    "\n",
    "save_lattice_params_button = Button(description=\"Save lattice parameters.\", layout = Layout(width='auto'))\n",
    "save_lattice_params_button.on_click(on_save_lattice_params)\n",
    "\n",
    "col2 = VBox([Text(value='Lattice parameters'),VBox([a_slider,b_slider,c_slider]), VBox([alpha_slider,beta_slider,gamma_slider, revert_lattice_params_button, save_lattice_params_button])])\n",
    "\n",
    "# col2.set_title(0, 'Lattice vectors')\n",
    "# col2.set_title(1, 'Axial angles')\n",
    "# col2.set_title(2, 'List of atoms')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Function to initialize crystal structure set up lattice vector and axial angle selection according to choice \n",
    "# of crystal family + centering\n",
    "def reset_sliders(change):\n",
    "    # crystal_family = str(tab.children[0].value)\n",
    "    \n",
    "    \n",
    "   # get also the value of the centering chosen by the user before updating the crystal structure     \n",
    "        \n",
    "    \n",
    "        global crystal_family_radio,alpha_slider, l_ab_flag, l_ac_flag, l_alpha_beta_flag, l_alpha_gamma_flag\n",
    "\n",
    "        \n",
    "        # If we want to have the lattice parameters automatically saved for future reversion\n",
    "        # then we will need some logic to prevent overriding them when we change crystal\n",
    "        # structure or centering\n",
    "       \n",
    "    # if type(change['owner']) == widgets.widget_selection.RadioButtons:\n",
    "        #     save_lat_params=False\n",
    "                # print(\"reset sliders: type(change[owner]) = {}\".format(type(change['owner'])))\n",
    "        # if change['owner'] = \n",
    "        crystal_family_radio.unobserve(reset_sliders, names='value')\n",
    "\n",
    "        crystal_family = crystal_family_radio.value\n",
    "        # with output:\n",
    "        #     print(\"crystal family = {}\".format(crystal_family))\n",
    "        \n",
    "        a_slider.unobserve(compute_BZ,names='value')\n",
    "        b_slider.unobserve(compute_BZ,names='value')\n",
    "        c_slider.unobserve(compute_BZ,names='value')\n",
    "        alpha_slider.unobserve(compute_BZ,names='value')\n",
    "        beta_slider.unobserve(compute_BZ,names='value')\n",
    "        gamma_slider.unobserve(compute_BZ,names='value')\n",
    "\n",
    "        # a_slider.unobserve(None) # temporarily unobserve callback to prevent looping\n",
    "        # b_slider.unobserve(None)\n",
    "        # c_slider.unobserve(None)\n",
    "        # alpha_slider.unobserve(None)\n",
    "        # beta_slider.unobserve(None)\n",
    "        # gamma_slider.unobserve(None)\n",
    "        \n",
    "        if(crystal_family=='Cubic'):\n",
    "              \n",
    "            # lock b and c sliders to that of a\n",
    "            # lock angles to 90,90,90\n",
    "            centering_radio.options=['Primitive','Body-centered', 'Face-centered']\n",
    "            alpha_slider.value=90\n",
    "            beta_slider.value=90\n",
    "            gamma_slider.value=90\n",
    "            alpha_slider.disabled=True\n",
    "            beta_slider.disabled=True\n",
    "            gamma_slider.disabled=True\n",
    "            b_slider.disabled=True\n",
    "            c_slider.disabled=True\n",
    "\n",
    "            if l_ab_flag==False:\n",
    "                l_ab.link()\n",
    "                l_ab_flag=True\n",
    "            if l_ac_flag==False:\n",
    "                l_ac.link()\n",
    "                l_ac_flag=True\n",
    "                \n",
    "            if l_alpha_beta_flag==True:\n",
    "                l_alpha_beta.unlink()\n",
    "                l_alpha_beta_flag = False\n",
    "                \n",
    "            if l_alpha_gamma_flag==True:\n",
    "                l_alpha_gamma.unlink()\n",
    "                l_alpha_gamma_flag = False\n",
    "                        \n",
    "\n",
    "        elif(crystal_family=='Orthorhombic'):\n",
    "           \n",
    "            # vector lengths are all independent\n",
    "            # lock angles to 90,90,90\n",
    "            centering_radio.options=['Primitive','Base-centered','Body-centered', 'Face-centered']\n",
    "\n",
    "            alpha_slider.value=90\n",
    "            beta_slider.value=90\n",
    "            gamma_slider.value=90\n",
    "            alpha_slider.disabled=True\n",
    "            beta_slider.disabled=True\n",
    "            gamma_slider.disabled=True\n",
    "            \n",
    "            if l_ab_flag==True:\n",
    "                l_ab.unlink()\n",
    "                l_ab_flag=False\n",
    "\n",
    "            if l_ac_flag==True:\n",
    "                l_ac.unlink()\n",
    "                l_ac_flag=False\n",
    "                \n",
    "            if l_alpha_beta_flag==True:\n",
    "                l_alpha_beta.unlink()\n",
    "                l_alpha_beta_flag=False\n",
    "                \n",
    "            if l_alpha_gamma_flag==True:\n",
    "                l_alpha_gamma.unlink()\n",
    "                l_alpha_gamma_flag=False\n",
    "                \n",
    "           \n",
    "            b_slider.disabled=False\n",
    "            c_slider.disabled=False\n",
    "        \n",
    "\n",
    "        elif(crystal_family=='Tetragonal'):\n",
    "            \n",
    "            centering_radio.options=['Primitive','Body-centered']\n",
    "            alpha_slider.value=90\n",
    "            beta_slider.value=90\n",
    "            gamma_slider.value=90\n",
    "            a_slider.value = 3.\n",
    "            c_slider.value = 5.\n",
    "            alpha_slider.disabled=True\n",
    "            beta_slider.disabled=True\n",
    "            gamma_slider.disabled=True\n",
    "            \n",
    "            \n",
    "            # lock b slider value to that of a\n",
    "\n",
    "            if l_ab_flag==False:\n",
    "                l_ab.link()\n",
    "                l_ab_flag=True\n",
    "\n",
    "            if l_ac_flag==True:\n",
    "                l_ac.unlink()\n",
    "                l_ac_flag=False\n",
    "                \n",
    "            b_slider.disabled=True\n",
    "            c_slider.disabled=False\n",
    "            \n",
    "            if l_alpha_beta_flag==False:\n",
    "                l_alpha_beta.link()\n",
    "                l_alpha_beta_flag=False\n",
    "            \n",
    "            if l_alpha_gamma_flag==False:\n",
    "                l_alpha_gamma.link()\n",
    "                l_alpha_gamma_flag=False\n",
    "                                     \n",
    "\n",
    "\n",
    "        elif(crystal_family=='Monoclinic'):\n",
    "            # two lattice vectors meet at 90 degrees.\n",
    "            # The third meets at an angle beta\n",
    "            # all 3 lattice vectors can take unique values\n",
    "            \n",
    "            centering_radio.options=['Primitive','Base-centered']\n",
    "            alpha_slider.value=90\n",
    "            gamma_slider.value=90\n",
    "            beta_slider.value = 60\n",
    "            alpha_slider.disabled=True\n",
    "            beta_slider.disabled=False\n",
    "            gamma_slider.disabled=True\n",
    "            a_slider.value = 3\n",
    "            b_slider.value = 4\n",
    "            c_slider.value = 5\n",
    "           \n",
    "            b_slider.disabled=False\n",
    "            c_slider.disabled=False\n",
    "           \n",
    "            \n",
    "            if l_ab_flag==True:\n",
    "                l_ab.unlink()\n",
    "                l_ab_flag=False\n",
    "\n",
    "            if l_ac_flag==True:\n",
    "                l_ac.unlink()\n",
    "                l_ac_flag=False\n",
    "                \n",
    "            if l_alpha_beta_flag==True:\n",
    "                l_alpha_beta.unlink()\n",
    "                l_alpha_beta_flag=False\n",
    "                \n",
    "            if l_alpha_gamma_flag==True:\n",
    "                l_alpha_gamma.unlink()\n",
    "                l_alpha_gamma_flag=False\n",
    "            \n",
    "            \n",
    "\n",
    "            \n",
    "        elif(crystal_family=='Hexagonal'):\n",
    "            # a=b with 120 degrees between\n",
    "            # a and c are perpendicular. Similarly for b and c\n",
    "            # all 3 lattice vectors can take unique values\n",
    "          \n",
    "            centering_radio.options=['Primitive']\n",
    "            alpha_slider.value=90\n",
    "            beta_slider.value=90\n",
    "            a_slider.value = 3\n",
    "            c_slider.value = 5\n",
    "            gamma_slider.value=120\n",
    "            alpha_slider.disabled=True\n",
    "            gamma_slider.disabled=True\n",
    "            \n",
    "            b_slider.disabled=True\n",
    "            c_slider.disabled=False\n",
    "            \n",
    "            if l_ab_flag==False:\n",
    "                l_ab.link()\n",
    "                l_ab_flag=True\n",
    "\n",
    "            if l_ac_flag==True:\n",
    "                l_ac.unlink()\n",
    "                l_ac_flag=False\n",
    "                \n",
    "            if l_alpha_beta_flag==True:\n",
    "                l_alpha_beta.unlink()\n",
    "                l_alpha_beta_flag=False\n",
    "                \n",
    "            if l_alpha_gamma_flag==True:\n",
    "                l_alpha_gamma.unlink()\n",
    "                l_alpha_gamma_flag=False\n",
    "            \n",
    "            \n",
    "\n",
    "\n",
    "        elif(crystal_family=='Rhombohedral'):\n",
    "            # a=b=c. Only need to specify a and alpha.\n",
    "            centering_radio.options=['Primitive']\n",
    "            alpha_slider.disabled=False\n",
    "            alpha_slider.value=60\n",
    "            beta_slider.disabled=True\n",
    "            gamma_slider.disabled=True\n",
    "           \n",
    "            b_slider.disabled=True\n",
    "            c_slider.disabled=True\n",
    "            \n",
    "            if l_ab_flag==False:\n",
    "                l_ab.link()\n",
    "                l_ab_flag=True\n",
    "\n",
    "            if l_ac_flag==False:\n",
    "                l_ac.link()\n",
    "                l_ac_flag=True\n",
    "                \n",
    "            if l_alpha_beta_flag==False:\n",
    "                l_alpha_beta.link()\n",
    "                l_alpha_beta_flag=True\n",
    "                \n",
    "            if l_alpha_gamma_flag==False:\n",
    "                l_alpha_gamma.link()\n",
    "                l_alpha_gamma_flag=True\n",
    "            \n",
    "            \n",
    "            \n",
    "\n",
    "        elif(crystal_family=='Triclinic'):\n",
    "            # all 3 lattice vectors and angles may vary independently\n",
    "        \n",
    "            centering_radio.options=['Primitive']\n",
    "           \n",
    "            alpha_slider.value=30\n",
    "            beta_slider.value=50\n",
    "            gamma_slider.value=70\n",
    "            \n",
    "            \n",
    "            if l_ab_flag==True:\n",
    "                l_ab.unlink()\n",
    "                l_ab_flag=False\n",
    "\n",
    "        \n",
    "            if l_ac_flag==True:\n",
    "                l_ac.unlink()\n",
    "                l_ac_flag=False\n",
    "            \n",
    "            if l_alpha_beta_flag==True:\n",
    "                l_alpha_beta.unlink()\n",
    "                l_alpha_beta_flag=False\n",
    "            \n",
    "            if l_alpha_gamma_flag==True:\n",
    "                l_alpha_gamma.unlink()\n",
    "                l_alpha_gamma_flag=False\n",
    "            \n",
    "            \n",
    "\n",
    "            b_slider.value=3\n",
    "            c_slider.value=4\n",
    "            \n",
    "            alpha_slider.disabled=False\n",
    "            \n",
    "            b_slider.disabled=False\n",
    "            c_slider.disabled=False\n",
    "            beta_slider.disabled=False\n",
    "            gamma_slider.disabled=False\n",
    "            \n",
    "           \n",
    "                 \n",
    "        crystal_family_radio.observe(reset_sliders, names='value')\n",
    "\n",
    "\n",
    "        a_slider.observe(compute_BZ,names='value')\n",
    "        b_slider.observe(compute_BZ,names='value')\n",
    "        c_slider.observe(compute_BZ,names='value')\n",
    "        alpha_slider.observe(compute_BZ,names='value')\n",
    "        beta_slider.observe(compute_BZ,names='value')\n",
    "        gamma_slider.observe(compute_BZ,names='value')\n",
    "        \n",
    "        compute_BZ(change)\n",
    "            \n",
    "crystal_family_radio.observe(reset_sliders,names='value')\n",
    "centering_radio.observe(reset_sliders,names='value')\n",
    "\n",
    "\n",
    "def compute_BZ(c):\n",
    "    global m,c1, crystal_family_radio,w, real_lattice\n",
    "    \n",
    "    crystal_family = crystal_family_radio.value\n",
    "    # with output:\n",
    "    #     print(\"compute_bz. crystal fam = {}, c == {}\\n\".format(crystal_family,c))\n",
    "\n",
    "        \n",
    "    try:\n",
    "        a_slider.unobserve(compute_BZ,names='value')\n",
    "    except:\n",
    "        with output:\n",
    "            print(\"error\")\n",
    "    b_slider.unobserve(compute_BZ,names='value')\n",
    "    c_slider.unobserve(compute_BZ,names='value')\n",
    "    alpha_slider.unobserve(compute_BZ,names='value')\n",
    "    beta_slider.unobserve(compute_BZ,names='value')\n",
    "    gamma_slider.unobserve(compute_BZ,names='value')\n",
    "    \n",
    "    \n",
    "    \n",
    "    # only update BZ if c['disabled'] != True\n",
    "    # This prevents double updates due to linked sliders\n",
    "    \n",
    "    # if c['disabled'] == True:\n",
    "    #     with output:\n",
    "    #         print(\"returning == {}\\n\".format(c))\n",
    "    #     return\n",
    "\n",
    "    # get mag of lattice vec from slider and construct vector\n",
    "    a = a_slider.value\n",
    "    b = b_slider.value\n",
    "    c = c_slider.value\n",
    "\n",
    "    alpha=alpha_slider.value\n",
    "    beta=beta_slider.value\n",
    "    gamma=gamma_slider.value\n",
    "    \n",
    "\n",
    "    centering=centering_radio.value\n",
    "    \n",
    "    # save lattice parameters for retrieval after a change of crystal family\n",
    "    \n",
    "  \n",
    "    \n",
    "\n",
    "    mpos = [];\n",
    "    msym = [];\n",
    "        \n",
    "\n",
    "    if(crystal_family=='Cubic'):\n",
    "        if(centering=='Primitive'):\n",
    "\n",
    "            real_lattice  =  np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) *a / 2.0\n",
    "            mat = SimpleOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "\n",
    "        elif(centering=='Body-centered'):\n",
    "            \n",
    "            real_lattice = np.array([[-1, 1, 1], [1, -1, 1], [1, 1, -1]]) *a / 2.0;\n",
    "            mat = BodyCenteredOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "\n",
    "        elif(centering=='Face-centered'):\n",
    "            real_lattice=np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]]) *a/ 2.0;\n",
    "            mat = FaceCenteredOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})                         \n",
    "\n",
    "    if(crystal_family=='Orthorhombic'):\n",
    "        if(centering=='Primitive'):\n",
    "            real_lattice  =  np.array([[a, 0, 0], [0, b, 0], [0, 0, c]])\n",
    "            mat = SimpleOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "\n",
    "        elif(centering=='Base-centered'):\n",
    "\n",
    "            real_lattice  =  np.array([[a, -b, 0], [a, b, 0], [0, 0, 2*c]]) / 2.0\n",
    "            #real_lattice=np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]]) *a/ 2.0;\n",
    "            mat = BaseCenteredOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "        elif(centering=='Body-centered'):\n",
    "            real_lattice  =  np.array([[-a, b, c], [a, -b, c], [a, b, -c]])/2\n",
    "            mat = BodyCenteredOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "        elif(centering=='Face-centered'):\n",
    "            real_lattice  =  np.array([[0, b, c], [a, 0, c], [a, b, 0]])/2\n",
    "            mat = FaceCenteredOrthorhombic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "            \n",
    "    \n",
    "    if(crystal_family=='Triclinic'):\n",
    "           \n",
    "            c_x = c*np.cos(np.pi*(beta/180))\n",
    "            c_y = (1./np.sin(np.pi*(90/180)))*c*(np.cos(np.pi*(alpha/180))-np.cos(np.pi*(beta/180))*np.cos(np.pi*(gamma/180)))\n",
    "            c_z = np.sqrt(c**2-c_x**2-c_y**2)\n",
    "            real_lattice  =  np.array([[a, 0, 0], [b*np.cos(np.pi*(gamma/180)), b*np.sin(np.pi*(gamma/180)), 0], [c_x, c_y, c_z]])               \n",
    "            mat = Triclinic( size=(3,3,3), symbol='Cu', \n",
    "                              latticeconstant={'a': a, 'b': b, 'c': c,'alpha':alpha,'beta':beta,'gamma':gamma})\n",
    "\n",
    "    if(crystal_family=='Monoclinic'):\n",
    "        if(centering=='Primitive'):\n",
    "            real_lattice=np.array([[a,0,0], [0, b, 0], [c*np.cos(np.pi*(beta/180)),0,c*np.sin(np.pi*(beta/180))]])\n",
    "            mat = SimpleMonoclinic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c,'alpha':beta})\n",
    "        elif(centering=='Base-centered'):\n",
    "            real_lattice=np.array([[a/2,-b/2,0], [a/2, b/2, 0], [c*np.cos(np.pi*(beta/180)),0,c*np.sin(np.pi*(beta/180))]])\n",
    "            mat = BaseCenteredMonoclinic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c,'alpha':beta})\n",
    "    if(crystal_family=='Tetragonal'):\n",
    "        if(centering=='Primitive'):\n",
    "            real_lattice=np.array([[a,0,0], [0, a, 0], [0,0,c]])\n",
    "            mat = SimpleTetragonal(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "        elif(centering=='Body-centered'):\n",
    "            real_lattice=np.array([[-a,a,c], [a, -a, c], [a,a,-c]])/2\n",
    "            mat = BodyCenteredTetragonal(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],\n",
    "                          size=(3,3,3), symbol='Cu', \n",
    "                          latticeconstant={'a': a, 'b': b, 'c': c})\n",
    "    if(crystal_family=='Rhombohedral'):\n",
    "            mat = Triclinic( size=(3,3,3), symbol='Cu', \n",
    "                              latticeconstant={'a': a, 'b': a, 'c': a,'alpha':alpha,'beta':alpha,'gamma':alpha})\n",
    "\n",
    "            # mat = bulk('Cu', 'rhombohedral', a=a,alpha=alpha,basis=[[0,0,0],[0,0,0],[0,0,0]])\n",
    "            c_z=np.sqrt((1/3.)*(4*np.cos(np.pi*(alpha/2/180))**2-1))\n",
    "            # rhombohedral/trigonal lattices aset not implemented in ase's lattice module\n",
    "            real_lattice= a*np.array([[np.sin(np.pi*(alpha/2/180)), -1/np.sqrt(3)*np.sin(np.pi*(alpha/(2*180))), c_z], [0,2/np.sqrt(3)*np.sin(np.pi*(alpha/(2*180))), c_z],[-np.sin(np.pi*(alpha/2/180)), -1/(np.sqrt(3))*np.sin(np.pi*(alpha/2/180)), c_z]]) \n",
    "\n",
    "    if(crystal_family=='Hexagonal'):\n",
    "        mat = Hexagonal(size=(3,3,3), symbol='Cu',latticeconstant={'a':a,'c':c})\n",
    "        real_lattice= np.array([[a, 0, 0], [a/2, np.sqrt(3)/2*a, c],[0, 0, c],]) \n",
    "\n",
    "\n",
    "    w.cell = real_lattice.tolist()\n",
    "\n",
    "    m.remove_component(c1)\n",
    "    m.clear()\n",
    "\n",
    "    c1 = m.add_component(nv.ASEStructure(mat))\n",
    "    m.clear()\n",
    "\n",
    "    m.add_spacefill(radius=0.4)\n",
    "    m.add_unitcell()\n",
    "    \n",
    "    \n",
    "    a_slider.observe(compute_BZ,names='value')\n",
    "    b_slider.observe(compute_BZ,names='value')\n",
    "    c_slider.observe(compute_BZ,names='value')\n",
    "    alpha_slider.observe(compute_BZ,names='value')\n",
    "    beta_slider.observe(compute_BZ,names='value')\n",
    "    gamma_slider.observe(compute_BZ,names='value')\n",
    "\n",
    "\n",
    "    \n",
    "a_slider.observe(compute_BZ,names='value')\n",
    "b_slider.observe(compute_BZ,names='value')\n",
    "c_slider.observe(compute_BZ,names='value')\n",
    "alpha_slider.observe(compute_BZ,names='value')\n",
    "beta_slider.observe(compute_BZ,names='value')\n",
    "gamma_slider.observe(compute_BZ,names='value')\n",
    "\n",
    "\n",
    "# bt_compute.on_click(compute_BZ);\n",
    "\n",
    "label1 = HTML(value = f\"<div style='width: 400px; text-align:center;'><b><font color='blue'><font size=5>Structure</b></div>\")\n",
    "label2 = HTML(value = f\"<div style='width: 400px; text-align:center;'><b><font color='blue'><font size=5>Brillouin zone</b></div>\")\n",
    "\n",
    "# orientation_sync_button = Button(description=\"Sync orientations\")\n",
    "# orientation_sync_button.on_click(on_orientation_sync)\n",
    "# display(HBox([label1, label2]), HBox([m, VBox([w,orientation_sync_button])]), HBox([col0, col1,col2]))\n",
    "display(HBox([label1, label2]), HBox([m, VBox([w])]), HBox([col0, col1,col2]))\n",
    "\n",
    "# display(orientation_sync_button)\n",
    "# try the following [0.7500277180472348,5.551115123125783e-17,0.6614063971272561,0,0.5078318190417079,0.6406823725596474,-0.5758758035029177,0,-0.4237514197376189,0.7678060285588679,0.48052953788400066,0,-4.437514490653162,8.040445929008314,5.0320935534975835,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52fcce72",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[1,0,0,0,0,1,0,0,0,0,1,0,0,0,10.471975511965978,1] is init world vec\n",
    "# [24.451005287902106, 0.0, 0.0, -3.5999999046325684, 0.0, 24.451005287902106, 0.0, -3.5999999046325684, 0.0, 0.0, 24.451005287902106, -3.5999999046325684, 0.0, 0.0, 0.0, 1.0\n",
    "# is init orientation\n",
    "# np.array([1,0,0,0,0,1,0,0,0,0,1,0,0,0,10.471975511965978,1]).reshape((4,4)).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74673cfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a = np.array([[24.45100529 , 0.    ,      0.    ,     -3.5999999 ],\n",
    "#  [ 0.   ,      24.45100529,  0.   ,      -3.5999999 ],\n",
    "#  [ 0.   ,       0.       ,  24.45100529 ,-3.5999999 ],\n",
    "#  [ 0.  ,        0.      ,    0.       ,   1.        ]])\n",
    "# np.linalg.inv(a)@a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd7be2a4-74ea-4522-954f-7c607837f26f",
   "metadata": {},
   "source": [
    "<hr style=\"height:1px;border:none;color:#cccccc;background-color:#cccccc;\" />\n",
    "\n",
    "## **Legend**\n",
    "(How to use the interactive visualization)\n",
    "\n",
    "### Interactive figures\n",
    "\n",
    "There are two visualizers for the real space lattice structure (top left) and its 1st Brillouin zone in reciprocal space (top right) respectively. One can left-click\n",
    "and rotate both structures. Middle wheel of the mouse can zoom in and zoom out\n",
    "the structures. In the 1st Brillouin zone visualizer, the high symmetry points\n",
    "are also shown in the figure.\n",
    "\n",
    "### Controls\n",
    "\n",
    "There are a collection of controls under the two visualizers. Firstly, one can use the \"Crystal family\" dropdown menu to choose\n",
    "from the possible crystal families in 3D, such as cubic, orthorhombic, tetragonal, \n",
    "monoclinic, etc. After having selected the crystal family one is interested in studying, the user may then select the type of centering they wish to investigate (primitive, face-centered, body-centered, base-centered). Of course, certain crystal families only possess a subset of these possible types of centering and therefore certain options shall be greyed out depending on the choice for the crystal family.\n",
    "\n",
    "Finally, users can change the lattice parameters (lattice vector magnitudes and axial angles) on the bottom right panel. Recall that certain selections of the crystal family shall impose restrictions on the allowable lattice parameters and therefore some of the sliders shall be locked accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3976cd86-a564-412e-bbce-55445b4d333a",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}