solids_2021.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>$(\"div.input\").hide()</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "99bc308808b24b97b792266455e97c9a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButton(value=False, description='Show code')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#piece of code that hides code cells\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import display, HTML\n",
    "\n",
    "javascript_functions = {False: \"hide()\", True: \"show()\"}\n",
    "button_descriptions  = {False: \"Show code\", True: \"Hide code\"}\n",
    "\n",
    "def toggle_code(state):\n",
    "    \"\"\"\n",
    "    Toggles the JavaScript show()/hide() function on the div.input element.\n",
    "    \"\"\"\n",
    "    output_string = \"<script>$(\\\"div.input\\\").{}</script>\"\n",
    "    output_args   = (javascript_functions[state],)\n",
    "    output        = output_string.format(*output_args)\n",
    "    display(HTML(output))\n",
    "\n",
    "\n",
    "def button_action(value):\n",
    "    \"\"\"\n",
    "    Calls the toggle_code function and updates the button description.\n",
    "    \"\"\"\n",
    "    state = value.new\n",
    "    toggle_code(state)\n",
    "    value.owner.description = button_descriptions[state]\n",
    "state = False\n",
    "toggle_code(state)\n",
    "button = widgets.ToggleButton(state, description = button_descriptions[state])\n",
    "button.observe(button_action, \"value\")\n",
    "display(button)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "import numpy as np\n",
    "import copy as copy\n",
    "import time\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import itertools\n",
    "from operator import itemgetter,add\n",
    "import scipy as scipy\n",
    "from scipy import linalg,special,interpolate,signal\n",
    "import pickle\n",
    "import scipy.sparse.linalg as SLA\n",
    "from pylab import *\n",
    "import sys as sys\n",
    "import matplotlib.patches as patch\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "localtime = time.asctime( time.localtime(time.time()) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up dictionary of parameters: key=Z val=[n,l,ml,Hii,alpha]         Hoffmann parameters used\n",
    "\n",
    "#this is a dictionary of single zeta values - only for debugging purposes\n",
    "parameters_sz={1:[1,0,-13.6,1.3],                                           #H\n",
    "       2:[2,0,-23.4,1.688],                                              #He\n",
    "       3:[[2,0,-5.4,0.650],[2,1,-3.5,0.65]],                             #Li\n",
    "       4:[[2,0,-10.0,0.975],[2,1,-6.0,0.975]],                           #Be\n",
    "       5:[[2,0,-15.2,1.300],[2,1,-8.5,1.300]],                           #B\n",
    "       6:[[2,0,-21.4,1.625],[2,1,-11.4,1.625]],                          #C\n",
    "       7:[[2,0,-26.0,2.140],[2,1,-13.4,1.950]],                          #N\n",
    "       8:[[2,0,-32.3,2.275],[2,1,-14.8,2.275]],                          #O\n",
    "       9:[[2,0,-40.0,2.425],[2,1,-18.1,2.425]],                          #F\n",
    "       10:[[2,0,-43.2,2.879],[2,1,-20.0,2.879]],                         #Ne\n",
    "       11:[[3,0,-5.1,0.733],[3,1,-3.0,0.733]],                           #Na\n",
    "       12:[[3,0,-9.0,1.100],[3,1,-4.5,1.100]],                           #Mg\n",
    "       13:[[3,0,-12.3,1.167],[3,1,-6.5,1.167]],                          #Al\n",
    "       14:[[3,0,-17.3,1.383],[3,1,-9.2,1.383]],                          #Si\n",
    "       15:[[3,0,-18.6,1.750],[3,1,-14.0,1.300]],                         #P\n",
    "       16:[[3,0,-20.0,2.122],[3,1,-13.3,1.827]],                         #S\n",
    "       17:[[3,0,-26.3,2.183],[3,1,-14.2,1.733]],                         #Cl\n",
    "       18:[[3,0,-27.63,2.585],[3,1,-15.76,2.255]],                       #Ar\n",
    "       19:[[4,0,-4.34,0.874],[4,1,-2.73,0.874]],                         #K\n",
    "       20:[[4,0,-7.0,1.2],[4,1,-4.0,1.2]],                               #Ca\n",
    "       21:[[4,0,-8.87,1.3],[4,1,-2.75,1.3],[3,2,-8.51,4.34]],            #Sc 3d\n",
    "       22:[[4,0,-8.97,1.075],[4,1,-5.44,0.675],[3,2,-10.81,4.55]],       #Ti 3d\n",
    "       23:[[4,0,-8.81,1.3],[4,1,-5.52,1.30],[3,2,-11.00,4.75]],          #V 3d\n",
    "       24:[[4,0,-8.66,1.7],[4,1,-5.24,1.7],[3,2,-11.22,4.95]],           #Cr 3d\n",
    "       25:[[4,0,-9.75,1.8],[4,1,-5.89,1.80],[3,2,-11.67,5.15]],          #Mn 3d\n",
    "       26:[[4,0,-9.10,1.9],[4,1,-5.32,1.90],[3,2,-12.60,5.35],],         #Fe 3d\n",
    "       27:[[4,0,-9.21,2.00],[4,1,-5.29,2.00],[3,2,-13.18,5.55]],         #Co 3d\n",
    "       28:[[4,0,-9.17,1.825],[4,1,5.15,1.125],[3,2,-13.49,5.75]],        #Ni 3d\n",
    "       29:[[4,0,-11.40,2.20],[4,1,-6.06,2.20],[3,2,-14.00,5.95]],        #Cu 3d\n",
    "       30:[[4,0,-12.40,2.01],[4,1,-6.53,1.70],[3,2,-21.30,0.00]],        #Zn 3d\n",
    "       31:[[4,0,-14.58,1.77],[4,1,-6.75,1.55]],                          #Ga 4p\n",
    "       32:[[4,0,-16.00,2.16],[4,1,-9.00,1.85]],                          #Ge 4p\n",
    "       33:[[4,0,-16.22,2.23],[4,1,-12.16,1.89]],                         #As 4p\n",
    "       34:[[4,0,-20.50,2.44],[4,1,-14.40,2.07]],                         #Se 4p\n",
    "       35:[[4,0,-22.07,2.588],[4,1,-13.10,2.131]],                       #Br 4p\n",
    "       36:[[4,0,-24.36,2.829],[4,1,-13.99,2.442]],                       #Kr 4p\n",
    "       37:[[5,0,-4.180,0.997],[5,1,-2.60,0.997]],                        #Rb 5s\n",
    "       38:[[5,0,-6.620,1.214],[5,1,-3.92,1.214]],                        #Sr 5s\n",
    "       39:[[5,0,0.00,0.000],[5,1,0.000,0.00],[4,2,0.000,0.00]],          #Y  4d\n",
    "       40:[[5,0,-8.000,1.817],[5,1,-5.40,1.776],[4,2,-10.20,3.83]],      #Zr 4d\n",
    "       41:[[5,0,-10.10,1.890],[5,1,-6.86,1.85],[4,2,-12.10,4.08]],       #Nb 4d\n",
    "       42:[[5,0,-8.340,1.96],[5,1,-5.24,1.90],[4,2,-10.50,4.54]],        #Mo 4d\n",
    "       43:[[5,0,-10.07,2.018],[5,1,-5.40,1.984],[4,2,-12.82,4.90]],      #Tc 4d\n",
    "       44:[[5,0,-10.40,2.08],[5,1,-6.87,2.04],[4,2,-14.90,5.38]],        #Ru 4d\n",
    "       45:[[5,0,-8.090,2.135],[5,1,-4.57,2.10],[4,2,-12.50,4.29]],       #Rh 4d\n",
    "       46:[[5,0,-7.320,2.19],[5,1,-3.75,2.152],[4,2,-12.02,5.983]],      #Pd 4d\n",
    "       47:[[5,0,0.0000,0.00],[5,1,0.00,0.00],[4,2,0.00,0.00]],           #Ag 4d\n",
    "       48:[[5,0,0.0000,0.000],[5,1,0.00,0.00],[4,2,0.00,0.00]],          #Cd 4d\n",
    "       79:[[6,0,-10.92,2.6020],[6,1,-5.50,2.5840],[5,2,-15.076,6.1630]], #Au 5d\n",
    "       179:[[6,0,-10.92,2.6020]], #Au 5d\n",
    "       } \n",
    "\n",
    "#these are Hoffmann's parameters - appropriate for molecular calculations but will lead to convergence issues\n",
    "#if used in the solid state\n",
    "#note the tuple (exponent,coefficient) as the last entry. For s and p this is redundant for Hoffmann parameters\n",
    "#as coefficient is always 1, but it is in place here to be compatible with Cerda's parameters where the\n",
    "#p orbitals are sometimes double zeta as well as d.\n",
    "Hoffmann={1:[1,0,-13.6,(1.3,1.)],                                           #H\n",
    "       2:[2,0,-23.4,(1.688,1.)],                                              #He\n",
    "       3:[[2,0,-5.4,(0.650,1.)],[2,1,-3.5,(0.65,1.)]],                             #Li\n",
    "       4:[[2,0,-10.0,(0.975,1.)],[2,1,-6.0,(0.975,1.)]],                           #Be\n",
    "       5:[[2,0,-15.2,(1.300,1.)],[2,1,-8.5,(1.300,1.)]],                           #B\n",
    "       6:[[2,0,-21.4,(1.625,1.)],[2,1,-11.4,(1.625,1.)]],                          #C\n",
    "       7:[[2,0,-26.0,(2.140,1.)],[2,1,-13.4,(1.950,1.)]],                          #N\n",
    "       8:[[2,0,-32.3,(2.275,1.)],[2,1,-14.8,(2.275,1.)]],                          #O\n",
    "       9:[[2,0,-40.0,(2.425,1.)],[2,1,-18.1,(2.425,1.)]],                          #F\n",
    "       10:[[2,0,-43.2,(2.879,1.)],[2,1,-20.0,(2.879,1.)]],                         #Ne\n",
    "       11:[[3,0,-5.1,(0.733,1.)],[3,1,-3.0,(0.733,1.)]],                           #Na\n",
    "       12:[[3,0,-9.0,(1.100,1.)],[3,1,-4.5,(1.100,1.)]],                           #Mg\n",
    "       13:[[3,0,-12.3,(1.167,1.)],[3,1,-6.5,(1.167,1.)]],                          #Al\n",
    "       14:[[3,0,-17.3,(1.383,1.)],[3,1,-9.2,(1.383,1.)]],                          #Si\n",
    "       15:[[3,0,-18.6,(1.750,1.)],[3,1,-14.0,(1.600,1.)]],                         #P\n",
    "       16:[[3,0,-20.0,(2.122,1.)],[3,1,-13.3,(1.827,1.)]],                         #S\n",
    "       17:[[3,0,-26.3,(2.183,1.)],[3,1,-14.2,(1.733,1.)]],                         #Cl\n",
    "       18:[[3,0,-27.63,(2.585,1.)],[3,1,-15.76,(2.255,1.)]],                       #Ar\n",
    "       19:[[4,0,-4.34,(0.874,1.)],[4,1,-2.73,(0.874,1.)]],                         #K\n",
    "       20:[[4,0,-7.0,(1.2,1.)],[4,1,-4.0,(1.2,1.)]],                               #Ca\n",
    "       21:[[4,0,-8.87,(1.3,1.)],[4,1,-2.75,(1.3,1.)],[3,2,-8.51,((4.35,0.422783),(1.70,0.72757))]],            #Sc 3d\n",
    "       22:[[4,0,-8.97,(1.075,1.)],[4,1,-5.44,(0.675,1.)],[3,2,-10.81,((4.55,0.420607),(1.40,0.783913))]],       #Ti 3d\n",
    "       23:[[4,0,-8.81,(1.3,1.)],[4,1,-5.52,(1.30,1.)],[3,2,-11.00,((4.75,0.475509),(1.70,0.705213))]],     #     #V 3d\n",
    "       24:[[4,0,-8.66,(1.7,1.)],[4,1,-5.24,(1.7,1.)],[3,2,-11.22,((4.95,0.505792),(1.80,0.674723))]],           #Cr 3d\n",
    "       25:[[4,0,-9.75,(1.8,1.)],[4,1,-5.89,(1.80,1.)],[3,2,-11.67,((5.15,0.513906),(1.70,0.692909))]],          #Mn 3d\n",
    "       26:[[4,0,-9.10,(1.9,1.)],[4,1,-5.32,(1.90,1.)],[3,2,-12.60,((5.35,0.5505),(2.00,0.626))]],         #Fe 3d\n",
    "       27:[[4,0,-9.21,(2.00,1.)],[4,1,-5.29,(2.00,1.)],[3,2,-13.18,((5.55,0.567865),(2.10,0.605856))]],         #Co 3d\n",
    "       28:[[4,0,-9.17,(1.825,1.)],[4,1,-5.15,(1.125,1.)],[3,2,-13.49,((5.75,0.549306),(2.30,0.60817))]],        #Ni 3d\n",
    "       29:[[4,0,-11.40,(2.20,1.)],[4,1,-6.06,(2.20,1.)],[3,2,-14.00,((5.95,0.593322),(2.30,0.574421))]],        #Cu 3d\n",
    "       30:[[4,0,-12.96,(2.37,1.)],[4,1,-9.23,(1.63,0.42)],[3,2,-18.03,((3.565,0.87781),(2.01,0.1554))]],                          #Zn 4p\n",
    "       31:[[4,0,-14.58,(1.77,1.)],[4,1,-6.75,(1.55,1.)]],                          #Ga 4p\n",
    "       32:[[4,0,-16.00,(2.16,1.)],[4,1,-9.00,(1.85,1.)]],                          #Ge 4p\n",
    "       33:[[4,0,-16.22,(2.23,1.)],[4,1,-12.16,(1.89,1.)]],                         #As 4p\n",
    "       34:[[4,0,-20.50,(2.44,1.)],[4,1,-14.40,(2.07,1.)]],                         #Se 4p\n",
    "       35:[[4,0,-22.07,(2.588,1.)],[4,1,-13.10,(2.131,1.)]],                       #Br 4p\n",
    "       36:[[4,0,-24.36,(2.829,1.)],[4,1,-13.99,(2.442,1.)]],                       #Kr 4p\n",
    "       37:[[5,0,-4.180,(0.997,1.)],[5,1,-2.60,(0.997,1.)]],                        #Rb 5s\n",
    "       38:[[5,0,-6.620,(1.214,1.)],[5,1,-3.92,(1.214,1.)]],                        #Sr 5s\n",
    "       39:[[5,0,-5.337,(1.279,1.)],[5,1,-3.515,(1.079,1.)],[4,2,-6.799,((2.554,0.601963),(1.068,0.577964))]],          #Y  4d  Muller (nb energies rather diff from Hoffman)\n",
    "       40:[[5,0,-9.87,(1.817,1.)],[5,1,-6.76,(1.776,1.)],[4,2,-11.18,((3.835,0.622416),(1.505,0.578216))]],      #Zr 4d\n",
    "       41:[[5,0,-10.10,(1.890,1.)],[5,1,-6.86,(1.85,1.)],[4,2,-12.10,((4.08,0.640101),(1.64,0.551601))]],       #Nb 4d\n",
    "       42:[[5,0,-8.340,(1.96,1.)],[5,1,-5.24,(1.90,1.)],[4,2,-10.50,((4.54,0.589879),(1.9,0.589879))]],        #Mo 4d\n",
    "       43:[[5,0,-10.07,(2.018,1.)],[5,1,-5.40,(1.984,1.)],[4,2,-12.82,((4.9,0.5715),(2.094,0.6012))]],      #Tc 4d\n",
    "       44:[[5,0,-10.40,(2.08,1.)],[5,1,-6.87,(2.04,1.)],[4,2,-14.90,((5.38,0.534242),(2.3,0.636789))]],        #Ru 4d\n",
    "       45:[[5,0,-8.090,(2.135,1.)],[5,1,-4.57,(2.10,1.)],[4,2,-12.50,((4.29,0.580698),(1.97,0.568498))]],       #Rh 4d\n",
    "       46:[[5,0,-7.320,(2.19,1.)],[5,1,-3.75,(2.152,1.)],[4,2,-12.02,((5.983,0.526436),(2.613,0.637334))]],      #Pd 4d\n",
    "       47:[[5,0,-7.054,(1.662,1.)],[5,1,-4.133,(1.397,1.)],[4,2,-19.24,((3.912,0.824441),(1.545,0.328777))]],    #Ag 4d  taken from Muller parameterisation in ATK\n",
    "       48:[[5,0,-7.242,(1.706,1.)],[5,1,-4.196,(1.432,1.)],[4,2,-20.78,((4.094,0.823957),(1.64,0.324983))]],      #Cd  Muller                                               #Cd 4d\n",
    "       78:[[6,0,-9.077,(2.554,1.)],[6,1,-5.475,(2.554,1.)],[5,2,-12.59,((6.013,0.633378),(2.696,0.551281))]],\n",
    "       79:[[6,0,-10.92,(2.6020,1.)],[6,1,-5.50,(2.5040,1.)],[5,2,-15.07,((6.163,0.644177),(2.794,0.535576))]],   #nb p exponent slightly different from literature to avoid singularities in linear chain\n",
    "       179:[6,0,-10.92,(2.6020,1.)], #special Au 6s only for electrodes\n",
    "       } \n",
    "\n",
    "\n",
    "#Muller's parameter set: note, most of these are still Hoffmann for now - need to change them\n",
    "Muller={1:[1,0,-13.6,(1.3,1.)],                                           #H\n",
    "       2:[2,0,-23.4,(1.688,1.)],                                              #He\n",
    "       3:[[2,0,-5.4,(0.650,1.)],[2,1,-3.5,(0.65,1.)]],                             #Li\n",
    "       4:[[2,0,-10.0,(0.975,1.)],[2,1,-6.0,(0.975,1.)]],                           #Be\n",
    "       5:[[2,0,-15.2,(1.300,1.)],[2,1,-8.5,(1.300,1.)]],                           #B\n",
    "       6:[[2,0,-21.4,(1.625,1.)],[2,1,-11.4,(1.625,1.)]],                          #C\n",
    "       7:[[2,0,-26.0,(2.140,1.)],[2,1,-13.4,(1.950,1.)]],                          #N\n",
    "       8:[[2,0,-32.3,(2.275,1.)],[2,1,-14.8,(2.275,1.)]],                          #O\n",
    "       9:[[2,0,-40.0,(2.425,1.)],[2,1,-18.1,(2.425,1.)]],                          #F\n",
    "       10:[[2,0,-43.2,(2.879,1.)],[2,1,-20.0,(2.879,1.)]],                         #Ne\n",
    "       11:[[3,0,-5.1,(0.733,1.)],[3,1,-3.0,(0.733,1.)]],                           #Na\n",
    "       12:[[3,0,-9.0,(1.100,1.)],[3,1,-4.5,(1.100,1.)]],                           #Mg\n",
    "       13:[[3,0,-12.3,(1.167,1.)],[3,1,-6.5,(1.167,1.)]],                          #Al\n",
    "       14:[[3,0,-17.3,(1.383,1.)],[3,1,-9.2,(1.383,1.)]],                          #Si\n",
    "       15:[[3,0,-18.6,(1.750,1.)],[3,1,-14.0,(1.600,1.)]],                         #P\n",
    "       16:[[3,0,-20.0,(2.122,1.)],[3,1,-13.3,(1.827,1.)]],                         #S\n",
    "       17:[[3,0,-26.3,(2.183,1.)],[3,1,-14.2,(1.733,1.)]],                         #Cl\n",
    "       18:[[3,0,-27.63,(2.585,1.)],[3,1,-15.76,(2.255,1.)]],                       #Ar\n",
    "       19:[[4,0,-4.34,(0.874,1.)],[4,1,-2.73,(0.874,1.)]],                         #K\n",
    "       20:[[4,0,-7.0,(1.2,1.)],[4,1,-4.0,(1.2,1.)]],                               #Ca\n",
    "       21:[[4,0,-8.87,(1.3,1.)],[4,1,-2.75,(1.3,1.)],[3,2,-8.51,((4.35,0.422783),(1.70,0.72757))]],            #Sc 3d\n",
    "       22:[[4,0,-8.97,(1.075,1.)],[4,1,-5.44,(0.675,1.)],[3,2,-10.81,((4.55,0.420607),(1.40,0.783913))]],       #Ti 3d\n",
    "       23:[[4,0,-8.81,(1.3,1.)],[4,1,-5.52,(1.30,1.)],[3,2,-11.00,((4.75,0.475509),(1.70,0.705213))]],     #     #V 3d\n",
    "       24:[[4,0,-8.66,(1.7,1.)],[4,1,-5.24,(1.7,1.)],[3,2,-11.22,((4.95,0.505792),(1.80,0.674723))]],           #Cr 3d\n",
    "       25:[[4,0,-9.75,(1.8,1.)],[4,1,-5.89,(1.80,1.)],[3,2,-11.67,((5.15,0.513906),(1.70,0.692909))]],          #Mn 3d\n",
    "       26:[[4,0,-9.10,(1.9,1.)],[4,1,-5.32,(1.90,1.)],[3,2,-12.60,((5.35,0.5505),(2.00,0.626))]],         #Fe 3d\n",
    "       27:[[4,0,-9.21,(2.00,1.)],[4,1,-5.29,(2.00,1.)],[3,2,-13.18,((5.55,0.567865),(2.10,0.605856))]],         #Co 3d\n",
    "       28:[[4,0,-9.17,(1.825,1.)],[4,1,-5.15,(1.125,1.)],[3,2,-13.49,((5.75,0.549306),(2.30,0.60817))]],        #Ni 3d\n",
    "       29:[[4,0,-11.40,(2.20,1.)],[4,1,-6.06,(2.20,1.)],[3,2,-14.00,((5.95,0.593322),(2.30,0.574421))]],        #Cu 3d\n",
    "       30:[[4,0,-12.96,(2.37,1.)],[4,1,-9.23,(1.63,0.42)],[3,2,-18.03,((3.565,0.87781),(2.01,0.1554))]],                          #Zn 4p\n",
    "       31:[[4,0,-14.58,(1.77,1.)],[4,1,-6.75,(1.55,1.)]],                          #Ga 4p\n",
    "       32:[[4,0,-15.158,(2.024,1.)],[4,1,-7.329,(1.55,1.)]],                          #Ge 4p\n",
    "       33:[[4,0,-16.22,(2.23,1.)],[4,1,-12.16,(1.89,1.)]],                         #As 4p\n",
    "       34:[[4,0,-20.50,(2.44,1.)],[4,1,-14.40,(2.07,1.)]],                         #Se 4p\n",
    "       35:[[4,0,-22.07,(2.588,1.)],[4,1,-13.10,(2.131,1.)]],                       #Br 4p\n",
    "       36:[[4,0,-24.36,(2.829,1.)],[4,1,-13.99,(2.442,1.)]],                       #Kr 4p\n",
    "       37:[[5,0,-4.180,(0.997,1.)],[5,1,-2.60,(0.997,1.)]],                        #Rb 5s\n",
    "       38:[[5,0,-6.620,(1.214,1.)],[5,1,-3.92,(1.214,1.)]],                        #Sr 5s\n",
    "       39:[[5,0,-5.337,(1.279,1.)],[5,1,-3.515,(1.079,1.)],[4,2,-6.799,((2.554,0.601963),(1.068,0.577964))]],          #Y  4d  Muller (nb energies rather diff from Hoffman)\n",
    "       40:[[5,0,-9.87,(1.817,1.)],[5,1,-6.76,(1.776,1.)],[4,2,-11.18,((3.835,0.622416),(1.505,0.578216))]],      #Zr 4d\n",
    "       41:[[5,0,-10.10,(1.890,1.)],[5,1,-6.86,(1.85,1.)],[4,2,-12.10,((4.08,0.640101),(1.64,0.551601))]],       #Nb 4d\n",
    "       42:[[5,0,-8.340,(1.96,1.)],[5,1,-5.24,(1.90,1.)],[4,2,-10.50,((4.54,0.589879),(1.9,0.589879))]],        #Mo 4d\n",
    "       43:[[5,0,-10.07,(2.018,1.)],[5,1,-5.40,(1.984,1.)],[4,2,-12.82,((4.9,0.5715),(2.094,0.6012))]],      #Tc 4d\n",
    "       44:[[5,0,-10.40,(2.08,1.)],[5,1,-6.87,(2.04,1.)],[4,2,-14.90,((5.38,0.534242),(2.3,0.636789))]],        #Ru 4d\n",
    "       45:[[5,0,-8.090,(2.135,1.)],[5,1,-4.57,(2.10,1.)],[4,2,-12.50,((4.29,0.580698),(1.97,0.568498))]],       #Rh 4d\n",
    "       46:[[5,0,-7.320,(2.19,1.)],[5,1,-3.75,(2.152,1.)],[4,2,-12.02,((5.983,0.526436),(2.613,0.637334))]],      #Pd 4d\n",
    "       47:[[5,0,-7.054,(1.662,1.)],[5,1,-4.133,(1.397,1.)],[4,2,-19.24,((3.912,0.824441),(1.545,0.328777))]],    #Ag 4d  taken from Muller parameterisation in ATK\n",
    "       48:[[5,0,-7.242,(1.706,1.)],[5,1,-4.196,(1.432,1.)],[4,2,-20.78,((4.094,0.823957),(1.64,0.324983))]],      #Cd  Muller                                               #Cd 4d\n",
    "       78:[[6,0,-9.077,(2.554,1.)],[6,1,-5.475,(2.554,1.)],[5,2,-12.59,((6.013,0.633378),(2.696,0.551281))]],\n",
    "       79:[[6,0,-10.92,(2.6020,1.)],[6,1,-5.50,(2.5040,1.)],[5,2,-15.07,((6.163,0.644177),(2.794,0.535576))]],   #nb p exponent slightly different from literature to avoid singularities in linear chain\n",
    "       179:[6,0,-10.92,(2.6020,1.)], #special Au 6s only for electrodes\n",
    "       } \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#Cerda's parameters specifically for solid state\n",
    "#Accurate and transferable EHT tight binding parameters, PRB, 2000, 61, 7965. J Cerda and F. Soria\n",
    "#(only available for the TMs and selected main group). Otherwise I have used the Hoffmann parameters\n",
    "#note that coefficients < 1.0 for some of the s and p states even though there is only one component. \n",
    "#This is justified because they are in fact 'double zeta' in character even though only one component is given. \n",
    "#However the other (more contracted) component makes not contribution to diatomic overlap as it is too contracted,\n",
    "#so its coefficient is in any case irrelevant. So it is ignored here. \n",
    "\n",
    "Cerda={1:[1,0,-17.84,(0.87223,0.50494)],                                           #H\n",
    "       2:[2,0,-23.4,(1.688,1.)],                                              #He\n",
    "       3:[[2,0,-5.4,(0.650,1.)],[2,1,-3.5,(0.65,1.)]],                             #Li\n",
    "       4:[[2,0,-10.0,(0.975,1.)],[2,1,-6.0,(0.975,1.)]],                           #Be\n",
    "       5:[[2,0,-21.7174,(1.60645,0.66811)],[2,1,-14.1676,(1.63627,0.99022)]],                           #B                          #C\n",
    "       6:[[2,0,-19.8892,(2.0249,0.76422)],[2,1,-13.08,((2.17687,0.7389),(1.269,0.177))]],  \n",
    "       7:[[2,0,-26.4216,(2.74251,1.)],[2,1,-17.0156,(2.26145,1.)]],                          #N\n",
    "       8:[[2,0,-27.06782,(2.56634,1.)],[2,1,-13.25162,(2.0,1.)]],                          #O\n",
    "       9:[[2,0,-40.0,(2.425,1.)],[2,1,-18.1,(2.425,1.)]],                          #F\n",
    "       10:[[2,0,-43.2,(2.879,1.)],[2,1,-20.0,(2.879,1.)]],                         #Ne\n",
    "       11:[[3,0,-5.1,(1.40,0.7)],[3,1,-3.0,(1.15,0.75)]],                           #Na\n",
    "       12:[[3,0,-9.0,(1.50,0.7)],[3,1,-4.5,(1.20,0.75)]],                           #Mg\n",
    "       13:[[3,0,-13.133,(1.657,0.749)],[3,1,-8.525,((1.312,0.750),(4.679,0.492))]], #Al #,[3,2,-5.141,((4.245,0.717),(0.860,0.609))]],                         #Al\n",
    "       14:[[3,0,-18.137,(1.864,0.720)],[3,1,-11.277,((1.813,0.705),(1.470,0.303))],[3,2,-5.336,((1.705,0.485),(0.675,0.671))]],\n",
    "       14:[[3,0,-18.029,(1.780,0.657)],[3,1,-11.820,(1.614,0.818)]],                       #Si\n",
    "       15:[[3,0,-20.24,(2.131,0.769)],[3,1,-12.437,((1.859,0.633),(2.479,0.384))]],                         #P\n",
    "       16:[[3,0,-20.0,(2.122,0.8)],[3,1,-13.3,(1.827,0.70)]],                         #S\n",
    "       17:[[3,0,-26.3,(2.183,1.)],[3,1,-14.2,(1.733,1.)]],                         #Cl\n",
    "       18:[[3,0,-27.63,(2.585,1.)],[3,1,-15.76,(2.255,1.)]],                       #Ar\n",
    "       19:[[4,0,-4.34,(0.874,0.65)],[4,1,-2.73,(0.874,0.65)]],                         #K  #changed weights from 1 to 0.65 (K not given in Cerda's tables)\n",
    "       20:[[4,0,-7.0,(1.2,1.)],[4,1,-4.0,(1.2,1.)]],                               #Ca\n",
    "       21:[[4,0,-8.419,(1.325,0.575)],[4,1,-5.989,(1.111,0.624)],[3,2,-8.391,((4.172,0.690),(1.332,0.527))]],            #Sc 3d\n",
    "       22:[[4,0,-7.879,(1.337,0.707)],[4,1,-5.950,(1.135,0.617)],[3,2,-8.943,((4.760,0.695),(1.464,0.532))]],       #Ti 3d\n",
    "       23:[[4,0,-8.40,(1.37,0.72)],[4,1,-6.1,(1.18,0.620)],[3,2,-9.8,((4.70,0.70),(1.56,0.52))]], #V 3d nb V not given in Cerda's paper - I have interpolated between Ti and Cr \n",
    "       24:[[4,0,-8.492,(1.426,0.753)],[4,1,-6.269,(1.210,0.632)],[3,2,-10.635,((4.688,0.683),(1.676,0.502))]],           #Cr 3d\n",
    "       25:[[4,0,-8.906,(1.468,0.725)],[4,1,-6.630,(1.233,0.625)],[3,2,-11.162,((4.534,0.720),(1.683,0.447))]],          #Mn 3d\n",
    "       26:[[4,0,-8.994,(1.594,0.777)],[4,1,-6.177,(1.315,0.658)],[3,2,-11.323,((4.845,0.730),(1.755,0.442))]],         #Fe 3d\n",
    "       27:[[4,0,-9.543,(1.561,0.665)],[4,1,-6.685,(1.282,0.616)],[3,2,-11.689,((4.765,0.769),(1.724,0.393))]],         #Co 3d\n",
    "       28:[[4,0,-9.523,(1.616,0.691)],[4,1,-6.553,(1.307,0.630)],[3,2,-11.744,((5.238,0.785),(1.775,0.392))]],        #Ni 3d\n",
    "       29:[[4,0,-10.563,(1.704,0.614)],[4,1,-6.78,(1.340,0.648)],[3,2,-12.896,((6.770,0.842),(1.855,0.367))]],        #Cu 3d\n",
    "       30:[[4,0,-12.96,(2.366,1.)],[4,1,-9.23,(1.63,0.4167)]],                          #Zn 4p\n",
    "       31:[[4,0,-17.629,(2.041,0.662)],[4,1,-10.766,((5.835,0.596),(1.616,0.705))]],   #Ga 4p \n",
    "       32:[[4,0,-16.00,(2.16,1.)],[4,1,-9.00,(1.85,1.)]],                          #Ge 4p\n",
    "       33:[[4,0,-21.764,(2.344,0.634)],[4,1,-12.822,((7.588,0.539),(2.102,0.753))]],                        #As 4p\n",
    "       34:[[4,0,-20.50,(2.44,1.)],[4,1,-14.40,(2.07,1.)]],                         #Se 4p\n",
    "       35:[[4,0,-22.07,(2.588,1.)],[4,1,-13.10,(2.131,1.)]],                       #Br 4p\n",
    "       36:[[4,0,-24.36,(2.829,1.)],[4,1,-13.99,(2.442,1.)]],                       #Kr 4p\n",
    "       37:[[5,0,-4.180,(0.997,1.)],[5,1,-2.60,(0.997,1.)]],                        #Rb 5s\n",
    "       38:[[5,0,-7.0,(1.50,0.69)],[5,1,-3.0,(1.16,0.10)]],                        #Sr 5s p orbital coefficient reduced from 0.5 to 0.1 to prevent singularities\n",
    "       39:[[5,0,-7.8,(1.50,0.69)],[5,1,-3.515,(1.20,0.50)],[4,2,-6.799,((4.20,0.60),(1.60,0.56))]],          #Y  4d  extrapolated from Zr\n",
    "       40:[[5,0,-8.017,(1.539,0.706)],[5,1,-6.033,(1.263,0.530)],[4,2,-9.022,((4.478,0.622416),(1.646,0.578216))]],      #Zr 4d\n",
    "       41:[[5,0,-7.768,(1.615,0.772)],[5,1,-5.246,(1.285,0.602)],[4,2,-9.318,((4.335,0.640101),(1.761,0.551601))]],       #Nb 4d\n",
    "       42:[[5,0,-8.365,(1.662,0.789)],[5,1,-5.666,(1.334,0.638)],[4,2,-10.855,((4.693,0.589879),(1.900,0.589879))]],        #Mo 4d\n",
    "       43:[[5,0,-8.406,(1.647,0.803)],[5,1,-5.804,(1.365,0.623)],[4,2,-11.386,((4.870,0.5715),(1.962,0.6012))]],      #Tc 4d\n",
    "       44:[[5,0,-8.953,(1.729,0.769)],[5,1,-5.778,(1.408,0.667)],[4,2,-12.352,((5.500,0.534242),(2.048,0.636789))]],        #Ru 4d\n",
    "       45:[[5,0,-8.412,(1.697,0.786)],[5,1,-5.854,(1.415,0.638)],[4,2,-12.388,((4.857,0.580698),(2.042,0.568498))]],       #Rh 4d\n",
    "       46:[[5,0,-8.781,(1.816,0.741)],[5,1,-5.627,(1.452,0.695)],[4,2,-12.346,((6.622,0.526436),(2.120,0.637334))]],      #Pd 4d\n",
    "       47:[[5,0,-9.925,(1.846,0.589)],[5,1,-6.437,(1.475,0.610)],[4,2,-14.705,((4.907,0.824441),(2.076,0.328777))]],    #Ag 4d  \n",
    "       48:[[5,0,-10.743,(1.703,0.570)],[5,1,-7.779,(1.281,0.508)],[5,2,-6.441,((1.237,0.453),(1.,0.0))]],      #Cd                  #note Cd 5d, not 4d as in Hoffmann params. Need to change core electrons\n",
    "       53:[[5,0,-22.07,(2.588,1.)],[5,1,-13.10,(2.131,1.)]],                       #note these are for Br, not I - need to find I parameters\n",
    "       57:[[6,0,-3.,(2.0,0.570)]],      #La                  #note Cd 5d, not 4d as in Hoffmann params. Need to change core electrons\n",
    "       74:[[6,0,-10.959,(2.216,0.673)],[6,1,-5.944,(1.642,0.603)],[5,2,-11.337,((5.139,0.665),(2.132,0.546))]],   #Re       \n",
    "       75:[[6,0,-11.013,(2.253,0.723)],[6,1,-6.062,(1.615,0.703)],[5,2,-10.806,((4.926,0.667),(2.194,0.517))]],   #Re\n",
    "       77:[[6,0,-11.548,(2.252,0.651)],[6,1,-6.650,(1.712,0.631)],[5,2,-13.089,((4.929,0.727),(2.287,0.432))]],   #Ir\n",
    "       78:[[6,0,-11.851,(2.494,0.6)],[6,1,-6.304,(2.8,0.3)],[5,2,-13.058,((5.327,0.749),(2.318,0.429))]],   #Pt nb p exponent and coefficient slightly different from literature to avoid singularities in linear chai\n",
    "       79:[[6,0,-12.131,(2.309,0.6)],[6,1,-6.760,(1.740,0.122)],[5,2,-14.000,((5.065,0.799),(2.291,0.349))]],   #Au nb p exponent and coefficient slightly different from literature to avoid singularities in linear chain\n",
    "       179:[6,0,-12.131,(2.309,0.6)], #special Au 6s only for electrodes\n",
    "       82:[[6,0,-12.486,(2.386,1.0)],[6,1,-6.527,(1.88,1.0)]],   #Pb nb Muller's parameters\n",
    "       } \n",
    "\n",
    "\n",
    "modified_Cerda={1:[1,0,-17.84,(0.87223,0.50494)],                                           #H\n",
    "       2:[2,0,-23.4,(1.688,1.)],                                              #He\n",
    "       3:[[2,0,-5.4,(0.650,1.)],[2,1,-3.5,(0.65,1.)]],                             #Li\n",
    "       4:[[2,0,-10.0,(0.975,1.)],[2,1,-6.0,(0.975,1.)]],                           #Be\n",
    "       5:[[2,0,-21.7174,(1.60645,0.66811)],[2,1,-14.1676,(1.63627,0.99022)]],                           #B                          #C\n",
    "       6:[[2,0,-19.8892,(2.0249,0.76422)],[2,1,-13.08,((2.17687,0.7389),(1.269,0.177))]],  \n",
    "       7:[[2,0,-26.4216,(2.74251,1.)],[2,1,-17.0156,(2.26145,1.)]],                          #N\n",
    "       8:[[2,0,-27.06782,(2.56634,1.)],[2,1,-13.25162,(2.0,1.)]],                          #O\n",
    "       9:[[2,0,-40.0,(2.425,1.)],[2,1,-18.1,(2.425,1.)]],                          #F\n",
    "       10:[[2,0,-43.2,(2.879,1.)],[2,1,-20.0,(2.879,1.)]],                         #Ne\n",
    "       11:[[3,0,-5.1,(1.40,0.7)],[3,1,-3.0,(1.15,0.75)]],                           #Na\n",
    "       12:[[3,0,-9.0,(1.50,0.7)],[3,1,-4.5,(1.20,0.75)]],                           #Mg\n",
    "       13:[[3,0,-13.133,(1.657,0.749)],[3,1,-8.525,((1.312,0.750),(4.679,0.492))]], #Al #,[3,2,-5.141,((4.245,0.717),(0.860,0.609))]],                         #Al\n",
    "       14:[[3,0,-18.039,(1.78044,0.65715)],[3,1,-11.82028,(1.6142,0.81839)],[3,2,-6.3232,((2.49718,0.65807),(0.79668,0.56273))]],  \n",
    "       15:[[3,0,-20.24,(2.131,0.769)],[3,1,-12.437,((1.859,0.633),(2.479,0.384))],[3,2,-3.845,((0.797,0.709),(1.,0.))]],                         #P\n",
    "       16:[[3,0,-20.0,(2.122,0.8)],[3,1,-13.3,(1.827,0.70)]],                         #S\n",
    "       17:[[3,0,-26.3,(2.183,1.)],[3,1,-14.2,(1.733,1.)]],                         #Cl\n",
    "       18:[[3,0,-27.63,(2.585,1.)],[3,1,-15.76,(2.255,1.)]],                       #Ar\n",
    "       19:[[4,0,-4.34,(0.874,0.65)],[4,1,-2.73,(0.874,0.65)]],                         #K  #changed weights from 1 to 0.65 (K not given in Cerda's tables)\n",
    "       20:[[4,0,-7.0,(1.2,1.)],[4,1,-4.0,(1.2,1.)]],    \n",
    "       #20:[[4,0,-7.0,(1.2,1.)],[4,1,-4.0,(1.2,1.)],[3,2,-7.0,((3.60,0.690),(1.332,0.527))]],                               #Ca\n",
    "       21:[[4,0,-8.419,(1.325,0.575)],[4,1,-5.989,(1.111,0.624)],[3,2,-8.391,((4.172,0.690),(1.332,0.527))]],            #Sc 3d\n",
    "       22:[[4,0,-7.879,(1.337,0.707)],[4,1,-5.950,(1.135,0.617)],[3,2,-8.943,((4.760,0.695),(1.464,0.532))]],       #Ti 3d\n",
    "       23:[[4,0,-8.40,(1.37,0.72)],[4,1,-6.1,(1.18,0.620)],[3,2,-9.8,((4.70,0.70),(1.56,0.52))]], #V 3d nb V not given in Cerda's paper - I have interpolated between Ti and Cr \n",
    "       24:[[4,0,-8.492,(1.426,0.753)],[4,1,-6.269,(1.210,0.632)],[3,2,-10.635,((4.688,0.683),(1.676,0.502))]],           #Cr 3d\n",
    "       25:[[4,0,-8.906,(1.468,0.725)],[4,1,-6.630,(1.233,0.625)],[3,2,-11.162,((4.534,0.720),(1.683,0.447))]],          #Mn 3d\n",
    "       26:[[4,0,-8.994,(1.594,0.777)],[4,1,-6.177,(1.315,0.658)],[3,2,-11.323,((4.845,0.730),(1.755,0.442))]],         #Fe 3d\n",
    "       27:[[4,0,-9.543,(1.561,0.665)],[4,1,-6.685,(1.282,0.616)],[3,2,-11.689,((4.765,0.769),(1.724,0.393))]],         #Co 3d\n",
    "       28:[[4,0,-9.523,(1.616,0.691)],[4,1,-6.553,(1.307,0.130)],[3,2,-11.744,((5.238,0.785),(1.775,0.392))]],        #Ni 3d 0.63\n",
    "       29:[[4,0,-10.563,(1.704,0.614)],[4,1,-6.78,(1.340,0.648)],[3,2,-12.896,((6.770,0.842),(1.855,0.367))]],        #Cu 3d\n",
    "       30:[[4,0,-12.96,(2.366,1.)],[4,1,-9.23,(1.63,0.4167)]],                          #Zn 4p\n",
    "       31:[[4,0,-17.629,(2.041,0.662)],[4,1,-10.766,((5.835,0.596),(1.616,0.705))],[4,2,-3.507,((1.028,0.636),(1.,0.))]],   #Ga 4p \n",
    "       #32:[[4,0,-16.00,(2.16,1.)],[4,1,-9.00,(1.85,1.)]],\n",
    "       #32:[[4,0,-16.0,(1.341,0.862)],[4,1,-11.,((5.835,0.596),(1.616,0.705))]],                         #Ge 4p\n",
    "       32:[[4,0,-19.256,(1.892,0.472)],[4,1,-11.115,((9.324,0.604),(1.925,0.797))],[4,2,-5.872,((9.038,0.837),(1.233,0.547))]],  #Ge 4d      \n",
    "       33:[[4,0,-21.764,(2.344,0.634)],[4,1,-12.822,((7.588,0.539),(2.102,0.753))],[4,2,-5.488,((3.926,0.681),(0.918,0.660))]],  #As 4p\n",
    "       34:[[4,0,-20.50,(2.44,1.)],[4,1,-14.40,(2.07,1.)]],                         #Se 4p\n",
    "       35:[[4,0,-23.07,(2.588,1.)],[4,1,-15.10,(2.131,1.)]],                       #Br 4p  Hii changed from default (to get Ef for C8Br right)\n",
    "       36:[[4,0,-24.36,(2.829,1.)],[4,1,-13.99,(2.442,1.)]],                       #Kr 4p\n",
    "       37:[[5,0,-4.180,(0.997,1.)],[5,1,-2.60,(0.997,1.)]],                        #Rb 5s\n",
    "       38:[[5,0,-7.0,(1.50,0.69)],[5,1,-3.0,(1.16,0.10)]],                        #Sr 5s\n",
    "       39:[[5,0,-7.8,(1.50,0.69)],[5,1,-3.515,(1.20,0.50)],[4,2,-6.799,((4.20,0.60),(1.60,0.56))]],          #Y  4d  extrapolated from Zr\n",
    "       40:[[5,0,-8.017,(1.539,0.706)],[5,1,-6.033,(1.263,0.530)],[4,2,-9.022,((4.478,0.622416),(1.646,0.578216))]],      #Zr 4d\n",
    "       41:[[5,0,-7.768,(1.615,0.772)],[5,1,-5.246,(1.285,0.602)],[4,2,-9.318,((4.335,0.640101),(1.761,0.551601))]],       #Nb 4d\n",
    "       42:[[5,0,-8.365,(1.662,0.789)],[5,1,-5.666,(1.334,0.638)],[4,2,-10.855,((4.693,0.589879),(1.900,0.589879))]],        #Mo 4d\n",
    "       43:[[5,0,-8.406,(1.647,0.803)],[5,1,-5.804,(1.365,0.623)],[4,2,-11.386,((4.870,0.5715),(1.962,0.6012))]],      #Tc 4d\n",
    "       44:[[5,0,-8.953,(1.729,0.769)],[5,1,-5.778,(1.408,0.667)],[4,2,-12.352,((5.500,0.534242),(2.048,0.636789))]],        #Ru 4d\n",
    "       45:[[5,0,-8.412,(1.697,0.786)],[5,1,-5.854,(1.415,0.638)],[4,2,-12.388,((4.857,0.580698),(2.042,0.568498))]],       #Rh 4d\n",
    "       46:[[5,0,-8.781,(1.816,0.741)],[5,1,-5.627,(1.452,0.695)],[4,2,-12.346,((6.622,0.526436),(2.120,0.637334))]],      #Pd 4d\n",
    "       47:[[5,0,-9.925,(1.846,0.589)],[5,1,-6.437,(1.475,0.610)],[4,2,-14.705,((4.907,0.824441),(2.076,0.328777))]],    #Ag 4d  \n",
    "       48:[[5,0,-10.743,(1.703,0.570)],[5,1,-7.779,(1.281,0.508)],[5,2,-6.441,((1.237,0.453),(1.,0.0))]],      #Cd                  #note Cd 5d, not 4d as in Hoffmann params. Need to change core electrons\n",
    "       53:[[5,0,-22.07,(2.588,1.)],[5,1,-13.10,(2.131,1.)]],                       #note these are for Br, not I - need to find I parameters\n",
    "       57:[[6,0,-3.,(2.0,0.570)]],      #La                  #note Cd 5d, not 4d as in Hoffmann params. Need to change core electrons\n",
    "       74:[[6,0,-10.959,(2.216,0.673)],[6,1,-5.944,(1.642,0.603)],[5,2,-11.337,((5.139,0.665),(2.132,0.546))]],   #Re       \n",
    "       75:[[6,0,-11.013,(2.253,0.723)],[6,1,-6.062,(1.615,0.703)],[5,2,-10.806,((4.926,0.667),(2.194,0.517))]],   #Re\n",
    "       77:[[6,0,-11.548,(2.252,0.651)],[6,1,-6.650,(1.712,0.631)],[5,2,-13.089,((4.929,0.727),(2.287,0.432))]],   #Ir\n",
    "       78:[[6,0,-11.851,(2.494,0.6)],[6,1,-6.304,(2.8,0.3)],[5,2,-13.058,((5.327,0.749),(2.318,0.429))]],   #Pt\n",
    "       #79:[[6,0,-10.92,(2.6020,1.)],[6,1,-5.50,(2.5040,1.)],[5,2,-15.07,((6.163,0.644177),(2.794,0.535576))]],   #nb p exponent slightly different from literature to avoid singularities in linear chain\n",
    "       79:[[6,0,-12.31,(2.3,0.6)],[6,1,-6.76,(2.504,1.0)],[5,2,-14.00,((6.163,0.644177),(2.794,0.535576))]],   #nb p exponent slightly different from literature to avoid singularities in linear chain\n",
    "       179:[[6,0,-12.131,(2.309,0.6)]], #special Au 6s only for electrodes\n",
    "       } \n",
    "\n",
    "#these identify a label for an atomic number\n",
    "atno_to_element={1:\"H\",2:\"He\",3:\"Li\",4:\"Be\",5:\"B\",6:\"C\",7:\"N\",8:\"O\",9:\"F\",10:\"Ne\",11:\"Na\",12:\"Mg\",13:\"Al\",14:\"Si\",15:\"P\",16:\"S\",17:\"Cl\",18:\"Ar\",19:\"K\",20:\"Ca\",21:\"Sc\",22:\"Ti\",23:\"V\",\\\n",
    "        24:\"Cr\",25:\"Mn\",26:\"Fe\",27:\"Co\",28:\"Ni\",29:\"Cu\",30:\"Zn\",31:\"Ga\",32:\"Ge\",33:\"As\",34:\"Se\",35:\"Br\",36:\"Kr\",37:\"Rb\",38:\"Sr\",39:\"Y\",40:\"Zr\",41:\"Nb\",42:\"Mo\",43:\"Tc\",44:\"Ru\",45:\"Rh\",\\\n",
    "        46:\"Pd\",47:\"Ag\",48:\"Cd\",49:\"In\",50:\"Sn\",51:\"Sb\",52:\"Te\",53:\"I\",54:\"Xe\",55:\"Cs\",56:\"Ba\",57:\"La\",58:\"Ce\",59:\"Pr\",60:\"Nd\",61:\"Pm\",62:\"Sm\",63:\"Eu\",64:\"Gd\",65:\"Tb\",66:\"Dy\",67:\"Ho\",68:\"Er\",69:\"Tm\",70:\"Yb\",\\\n",
    "        71:\"Lu\",72:\"Hf\",73:\"Ta\",74:\"W\",75:\"Re\",77:\"Ir\",78:\"Pt\",79:\"Au\",179:\"Au\"\n",
    "}\n",
    "\n",
    "element_to_atno={'H':'1','He':'2','Li':'3','Be':'4','B':'5','C':'6','N':'7','O':'8','F':'9','Ne':'10','Na':'11','Mg':'12','Al':'13','Si':'14','P':'15','S':'16','Cl':'17','Ar':'18','K':'19','Ca':'20','Sc':'21','Ti':'22','V':'23','Cr':'24','Mn':'25','Fe':'26','Co':'27','Ni':'28','Cu':'29','Zn':'30','Ga':'31',\\\n",
    "                 'Ge':'32','As':'33','Se':'34','Br':'35','Kr':'36','Rb':'37','Sr':'38','Y':'39','Zr':'40','Nb':'41','Mo':'42','Tc':'43','Ru':'44','Rh':'45','Pd':'46','Ag':'47','Cd':'48','In':'49','Sn':'50','Sb':'51','Te':'52','I':'53','Xe':'54','Cs':'55','Lu':'71','Hf':'72','Ta':'73','W':'74','Re':'75','Os':'76','Ir':'77','Pt':'78','Au':'79'\n",
    "}\n",
    "#atom colors taken from jmol  http://jmol.sourceforge.net/jscolors/\n",
    "atom_colours={1:(255,255,255),2:(217,255,255),3:(204,128,255),4:(194,255,0),5:(255,181,181),6:(144,144,144),7:(48,80,248),8:(255,13,13),9:(144,224,80),10:(179,227,245),\\\n",
    "        11:(171,92,242),12:(138,255,0),13:(191,166,166),14:(240,200,160),15:(255,128,0),16:(255,255,48),17:(31,240,31),18:(128,209,227),19:(143,64,212),20:(61,255,0),\\\n",
    "        21:(230,230,230),22:(191,194,199),23:(166,166,171),24:(138,153,199),25:(156,122,199),\\\n",
    "        26:(224,102,51),27:(240,144,160),28:(80,208,80),29:(200,128,51),30:(125,128,176),\\\n",
    "        31:(194,143,143),32:(102,143,143),33:(189,128,227),34:(255,161,0),35:(166,41,41),\\\n",
    "        36:(92,184,209),37:(112,46,176),38:(0,255,0),39:(148,255,255),40:(148,224,224),\\\n",
    "        41:(115,194,201),42:(84,181,181),43:(59,158,158),44:(36,143,143),45:(10,125,140),\\\n",
    "        46:(0,105,133),47:(192,192,192),48:(255,217,143),\\\n",
    "        49:(166,117,115),50:(102,128,128),51:(158,99,181),52:(212,122,0),53:(148,0,148),\\\n",
    "        54:(66,158,176),55:(87,23,143),56:(0,201,0),57:(112,212,255),\\\n",
    "        58:(255,255,199),59:(217,255,199),60:(199,255,199),61:(163,255,199),\\\n",
    "        62:(143,255,199),63:(97,255,199),64:(69,255,199),65:(48,255,199),66:(31,255,199),\\\n",
    "        67:(0,255,156),68:(0,230,117),69:(0,212,82),70:(0,191,56),71:(0,171,36),\\\n",
    "        72:(77,194,255),73:(77,166,255),74:(33,148,214),75:(38,125,171),76:(38,102,150),\\\n",
    "        77:(23,84,135),78:(208,208,224),79:(255,209,35),\\\n",
    "        179:(255,209,35)\n",
    "}\n",
    "\n",
    "\n",
    "covalent_radii={1:0.37,2:0.28,3:1.28,4:0.96,5:0.84,6:0.76,7:0.71,8:0.66,9:0.57,10:0.58,11:1.66,12:1.61,13:1.51,14:1.11,15:1.07,16:1.05,17:1.02,18:1.06,19:2.03,20:1.76,21:1.70,22:1.60,23:1.53,\\\n",
    "        24:1.39,25:1.39,26:1.32,27:1.26,28:1.24,29:1.32,30:1.22,31:1.22,32:1.20,33:1.19,34:1.20,35:1.20,36:1.16,37:2.20,38:1.95,39:1.90,40:1.75,41:1.64,42:1.54,43:1.47,44:1.46,45:1.42,\\\n",
    "        46:1.39,47:1.45,48:1.44,49:1.42,50:1.39,51:1.39,52:1.38,53:1.39,54:1.40,69:244,70:215,71:187,72:175,73:170,74:1.62,75:1.51,76:144,77:1.41,78:1.36,79:1.36,80:132,179:1.46\n",
    "}\n",
    "ionic_radii={1:0.8,2:0.6,3:0.9,4:0.59,5:0.41,6:0.30,7:1.34,8:1.26,9:1.19,10:0.58,11:1.16,12:0.86,13:0.68,14:0.54,15:1.8,16:1.7,17:1.67,18:1.06,19:1.52,20:1.14,21:0.89,22:0.80,23:0.68,\\\n",
    "        24:0.58,25:0.60,26:0.39,27:0.70,28:0.62,29:0.68,30:0.88,31:0.88,32:0.67,33:1.90,34:1.84,35:1.82,36:1.8,37:1.66,38:1.32,39:1.04,40:0.86,41:0.78,42:0.73,43:0.74,44:0.71,45:0.70,\\\n",
    "        46:1.00,47:1.30,48:1.09,49:0.90,50:0.83,53:1.98,57:1.1,70:1.,71:1.00,72:0.85,73:0.78,74:0.74,75:1.7,77:1.41,78:1.56,79:1.36,179:1.56\n",
    "}\n",
    "#generally these values are for the highest accessible oxidation state.\n",
    "\n",
    "#decide which to use\n",
    "ionic_or_covalent_radii = {\n",
    "'linear_H':'c','linear_H2':'c','distorted_H2':'c','linear_H4':'c','distorted_H4':'c','linear_C':'c','linear_C2':'c',\n",
    "'distorted_C2':'c','trans_polyacetylene':'c','poly_SN':'c','distorted_trans_polyacetylene':'c',\n",
    "'Pt2H8':'i','distorted_Pt2H8':'i','Pt2CN8':'i','square_H4':'c','square_CuO':'i','square_H':'c','2d_graphene':'c',\n",
    "'2d_MoS2':'i','2d_NbS2':'i','hexagonal_H2':'c','2d_Au':'c','cubic_H':'c','BN':'i','BP':'i','AlN':'i','AlP':'i','AlAs':'i',\n",
    "'AlSb':'i','GaN':'i','GaP':'i','GaAs':'i','GaSb':'i','ZnS':'i','CdS':'i','CuCl':'i','Si':'c','Ge':'c',\n",
    "'Sn':'c','diamond':'c','LiF':'i','NaF':'i','LiCl':'i','NaCl':'i','MgO':'i','NiO':'i','FeO':'i','TiO':'i','VO':'i',\n",
    "'CuO':'i','TiN':'i','VN':'i','CrN':'i','NbN':'i','TiC':'i','NiAs':'i','VS':'i','CrS':'i','WO3':'i','ReO3':'i','SrTiO3':'i',\n",
    "'SrVO3':'i','SrMnO3':'i','SrNbO3':'i','YCrO3':'i','KNiF3':'i','NaVF3':'i','NaWO3':'i','LaRhO3':'i','LaCrO3':'i',\n",
    "'fcc_H':'c','fcc_Ni':'c','fcc_Pd':'c','fcc_Pt':'c','fcc_Cu':'c','fcc_Ca':'c','fcc_Al':'c','fcc_Ag':'c','fcc_Au':'c','bcc_Na':'c',\n",
    "'c_Na':'c','bcc_K':'c', 'bcc_Fe':'c', 'bcc_W':'c', 'bcc_Mo':'c', 'bcc_V':'c', 'bcc_Cr':'c', 'bcc_Nb':'c', \n",
    "'SrVO2H':'i', 'graphite':'c', 'expanded_graphite':'c', 'C8Br':'c', 'hexagonal_BN':'i', 'hcp_Ru':'c','hcp_Al':'c','hcp_Zn':'c',\n",
    "'hcp_Mg':'c','hcp_Co':'c','hcp_Zr':'c','hcp_Be':'c','hcp_Ti':'c','t_TiO2':'i','t_VO2':'i','t_RuO2':'i','t_NbO2':'i',\n",
    "'t_SnO2':'i','t_MnO2':'i','t_CrO2':'i','t_MnF2':'i','t_NiF2':'i','t_ZnF2':'i','m_VO2':'i','TiS2':'i','MoS2':'i',\n",
    "'NbS2':'i','CdI2':'i','WC':'i','Li3N':'i','NbO':'i'\n",
    "}\n",
    "\n",
    "\n",
    "atomic_masses={1:1.008,2:4.003,3:6.941,4:9.012,5:10.811,6:12.011,7:14.007,8:15.999,9:18.998,10:20.180,11:22.990,12:24.305,13:26.982,14:28.086,15:30.974,16:32.066,17:35.453,18:39.948,19:39.098\\\n",
    ",20:40.078,21:44.956,22:47.867,23:50.942,24:51.996,25:53.938,26:55.845,27:58.933,28:59.693,29:63.546,30:65.390\\\n",
    ",31:69.723,32:72.61,33:74.922,34:78.96,35:79.904,36:83.80,37:85.468,38:87.62,39:88.906,40:91.223,41:92.906,42:95.94,43:98,44:101.07,45:102.906,46:106.42,47:107.868,48:112.411\\\n",
    ",49:114.82,50:118.69,51:121.75,52:127.60,53:126.90,54:131.30,55:132.19,56:137.33,57:138.91,58:140.12,59:140.91,60:144.24,61:(145),62:150.4,63:151.96,64:157.25,65:158.93,66:162.50\\\n",
    ",67:164.93,68:167.26,69:168.93,70:173.04,70:132.905,71:137.327,72:178.49,73:190.948,74:183.84,75:186.207,76:190.23,77:192.217,78:195.078,79:196.967,179:196.967}\n",
    "\n",
    "#these identify a label for a particular set of quantum numbers.\n",
    "#used only in print out\n",
    "identifiers={(1,0,0):\"1s     \",(2,0,0):\"2s     \",(2,1,1):\"2px    \",(2,1,0):\"2pz    \",(2,1,-1):\"2py    \",\\\n",
    "(3,0,0):\"3s     \",(3,1,1):\"3px    \",(3,1,0):\"3pz    \",(3,1,-1):\"3py    \",(3,2,2):\"3dx2-y2\",(3,2,1):\"3dxz   \",\\\n",
    "(3,2,0):\"3dz2   \",(3,2,-1):\"3dyz   \",(3,2,-2):\"3dxy   \",(4,0,0):\"4s     \",(4,1,1):\"4px    \",(4,1,0):\"4pz    \",\\\n",
    "(4,1,-1):\"4py    \",(4,2,2):\"4dx2-y2\",(4,2,1):\"4dxz   \",(4,2,0):\"4dz2   \",(4,2,-1):\"4dyz   \",(4,2,-2):\"4dxy   \",\\\n",
    "(5,0,0):\"5s     \",(5,1,1):\"5px    \",(5,1,0):\"5pz    \",(5,1,-1):\"5py    \",(5,2,2):\"5dx2-y2\",(5,2,1):\"5dxz   \",\\\n",
    "(5,2,0):\"5dz2   \",(5,2,-1):\"5dyz   \",(5,2,-2):\"5dxy   \", (6,0,0):\"6s     \",(6,1,1):\"6px    \",(6,1,0):\"6pz    \",\\\n",
    "(6,1,-1):\"6py    \",(6,2,2):\"6dx2-y2\",(6,2,1):\"6dxz   \",(6,2,0):\"6dz2   \",(6,2,-1):\"6dyz   \",(6,2,-2):\"6dxy   \"\n",
    "       } \n",
    "\n",
    "l_identifiers={0:\"s\",1:\"p\",2:\"d\"} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#some physical constants and defaults\n",
    "A0=0.52917721092;NA=6.0221409*10**23\n",
    "parameters=Cerda   #recommended for periodic calculations\n",
    "WH=2.30   #Default value for the Wolfsberg Helmholtz constant, K, is 1.75 for molecular calculations. Cerda recommends 2.3 for solids.\n",
    "interpolate_flag=True   #interpolates the Brillouin zone to get a finer mesh of k points. Saves time.\n",
    "npts_line=1000   #k-point sampling for line plots (band structure). This scales as 1 x npts, so can afford to be generous\n",
    "E_pts=200                 #number of points in energy scan.  This takes up most of the time so only increase it if you can't locate Ef.\n",
    "parameter_file='Cerda'\n",
    "dist_cutoff=7.0/A0     #above this cutoff, ovlp is set to zero without further calculation\n",
    "\n",
    "mesh=1   #determines tolerance in finding Fermi surface (no of dp's within which an energy level must come to Ef)\n",
    "plot_Surface=False  #plot in 3d\n",
    "plot_Band=True      #plot band structure along predefined route through BZ\n",
    "plot_COOP=False   #plot the COOP   ###WARNING  this will take a long time\n",
    "coop_by_bf_pair=False    #pair of orbitals to plot coop for. Set to False if you don't want to do it, otherwise a list [bf1,bf2]\n",
    "coop_by_atom_pair=[0,1]  #pair of atoms to plot coop for (coop is summed over all basis functions on each atom). Set to False if you don't want to do it, otherwise a list [atom_index1,atom_index2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np   #numpy package contains various numerical routines\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~Special Points~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "#these are used to identify special high-symmetry points in the 1st BZ\n",
    "tetragonal_special_points={\"gamma\":[0.,0.,0.],\"X\":[0.5,0.,0.],\"R\":[0.5,0.0,0.5],\"M\":[0.5,0.5,0.],\"A\":[0.5,0.5,0.5],\"Z\":[0.,0.,0.5]}\n",
    "cubic_special_points={\"gamma\":[0.,0.,0.],\"X\":[0.5,0.,0.],\"M\":[0.5,0.5,0.],\"R\":[0.5,0.5,0.5]}\n",
    "orthorhombic_special_points={\"gamma\":[0.,0.,0.],\"X\":[0.5,0.,0.],\"Y\":[0.,0.5,0.],\"Z\":[0.0,0.0,0.5],\"T\":[0.0,0.5,0.5],\"U\":[0.5,0.0,0.5],\"S\":[0.5,0.5,0.],\"R\":[0.5,0.5,0.5]}\n",
    "fcc_special_points={\"gamma\":[0.,0.,0.],\"X\":[0,1/2,1/2],\"L\":[1/2,1/2,1/2],\"W\":[1/4,3/4,1/2],\"U\":[5/8,1/4,5/8],\"K\":[3/8,3/8,3/4]}\n",
    "bcc_special_points={\"gamma\":[0.,0.,0.],\"N\":[0,0,1/2],\"P\":[1/4,1/4,1/4],\"H\":[-1/2,1/2,1/2]}\n",
    "hexagonal_special_points={\"gamma\":[0.,0.,0.],\"K\":[2/3,-1/3,0.],\"A\":[0,0,1/2],\"H\":[2/3,-1/3,1/2],\"M\":[1/2,0,0],\"L\":[1/2,0,1/2]}\n",
    "monoclinic_special_points={\"gamma\":[0.,0.,0.],\"Z\":[0,1/2,0],\"B\":[1/2,0,0],\"Y\":[0,0,1/2],\"C\":[0,1/2,1/2],\"D\":[1/2,1/2,0],\"A\":[1/2,0,-1/2]}\n",
    "special_points_1d={\"gamma\":[0,0,0],\"X\":[0,0,1/2]}\n",
    "special_points_2d_square={\"gamma\":[0,0,0],\"X\":[0,1/2,0],\"M\":[1/2,1/2,0]}\n",
    "special_points_2d_h={\"gamma\":[0,0,0],\"K\":[2/3,-1/3,0],\"M\":[1/2,0,0]}\n",
    "\n",
    "#PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct=crystal_dict[crystal][10]\n",
    "\n",
    "crystal_dict = {\n",
    "'linear_H':('1d',1.5,[1],0.,[[0.,0.,0.0]],(0,0,2000),(0,0,5000),0.05,[-25,-10,200],[True,False],[False,True,False],np.linspace(-20.0,20.0,8),0.0,[5,7],[0],[0.,0.25,0.5]),\n",
    "'linear_H2':('1d',3.0,[1,1],0.,[[0,0,0],[0,0,1/2]],(0,0,1000),(0,0,2000),0.05,[-25,-10,250],[True,False],[False,True,False],np.linspace(-5.0,5.0,16),0.0,[4,1],[1],[0.,0.25,0.5]),\n",
    "'distorted_H2':('1d',3.0,[1,1],0.,[[0,0,0],[0,0,1/2-0.05]],(0,0,1000),(0,0,2000),0.05,[-25,-10,250],[True,False],[False,True,False],np.linspace(-5.0,5.0,16),0.0,[4,3],[1],[0.,0.25,0.5]),\n",
    "'linear_H4':('1d',6.0,[1,1,1,1],0.,[[0,0,0],[0,0,1/4],[0,0,1/2],[0,0,3/4]],(0,0,1000),(0,0,2000),0.05,[-25,-10,250],[True,False],[False,True,False],np.linspace(-5.0,5.0,16),0.0,[2,2],[3],[0.,0.25,0.5]),\n",
    "'distorted_H4':('1d',6.0,[1,1,1,1],-2,[[0,0,0-0.02],[0,0,1/4],[0,0,1/2],[0,0,3/4+0.02]],(0,0,1000),(0,0,2000),0.05,[-25,-10,250],[True,False],[False,True,False],np.linspace(-2.0,2.0,16),0.0,[2,2],[3],[0.,0.25,0.5]),\n",
    "'linear_C':('1d',1.5,[6],0.,[[0.,0.,0.0]],(0,0,500),(0,0,1000),0.05,[-30,5,150],[True,False],[False,False,True],np.linspace(-6.,6.,16),0.0,[3,3],[3],[0.,0.25,0.5]),\n",
    "'linear_C2':('1d',3.0,[6,6],0.,[[0,0,0],[0,0,1/2]],(0,0,400),(0,0,800),0.05,[-30,5,250],[True,False],[False,False,True],np.linspace(-6,6,16),0.0,[2,2],[7],[0.,0.25,0.5]),\n",
    "'distorted_C2':('1d',3.0,[6,6],0.,[[0,0,0],[0,0,1/2-0.05]],(0,0,400),(0,0,800),0.05,[-30,5,250],[True,False],[False,False,True],np.linspace(-5,5,16),0.0,[2,2],[2],[0.,0.25,0.5]),\n",
    "'trans_polyacetylene':('1d',2.42,[6,6,1,1],0.,[[0.35,0.,0.],[-0.35,0.,1/2],[1.35,0.,0.0],[-1.35,0.,1/2]],(0,0,50),(0,0,200),0.05,[-30,0,350],[True,False],[False,True,False],np.linspace(-2.0,2.0,16),0.5,[2,4],[5],[0.,0.25,0.5]),\n",
    "'poly_SN':('1d',3*1.6,[7,16,7,16],0.,[[0,0,0],[0.8*3**0.5,0,1/6],[0.8*3**0.5,0,1/2],[0,0,4/6]],(0,0,50),(0,0,200),0.05,[-30,0,350],[True,False],[False,True,False],np.linspace(-2.0,2.0,16),0.5,[2,4],[5],[0.,0.25,0.5]),\n",
    "'distorted_trans_polyacetylene':('1d',2.52,[6,6,1,1],0.,[[0.35,0.,0.],[-0.35,0.,1/2+0.03],[1.35,0.,0.0],[-1.35,0.,1/2+0.03]],(0,0,50),(0,0,200),0.0005,[-30,0,350],[True,False],[False,True,False],np.linspace(-2.0,2.0,16),0.5,[2,4],[5],[0.,0.25,0.5]),\n",
    "'Pt2H8':('1d',6.0,[78,78,1,1,1,1,1,1,1,1],-4,\\\n",
    "[[0.,0.,0.0],[0.,0.,1/2],[1.66,0.,0.0],[-1.66,0.,0.0],[0.,1.66,0.0],[0.,-1.66,0.0],\\\n",
    "[1.174,1.174,1/2],[-1.174,1.174,1/2],[1.174,-1.174,1/2],[-1.174,-1.174,1/2]],(0,0,250),(0,0,500),0.0005,[-15,-5,150],[True,False],[False,False,True],np.linspace(-0.5,0.5,16),0.0,[1,3],[15],[0.,0.25,0.5]),\n",
    "'distorted_Pt2H8':('1d',5.8,[78,78,1,1,1,1,1,1,1,1],-4,\\\n",
    "[[0.,0.,0.0],[0.,0.,1/2-0.05],[1.66,0.,0.0],[-1.66,0.,0.0],[0.,1.66,0.0],[0.,-1.66,0.0],\\\n",
    "[1.174,1.174,1/2-0.05],[-1.174,1.174,1/2-0.05],[1.174,-1.174,1/2-0.05],[-1.174,-1.174,1/2-0.05]],(0,0,250),(0,0,500),0.0005,[-15,-5,150],[True,False],[False,True,False],np.linspace(-1.0,1.0,16),0.0,[1,3],[13],[0.,0.25,0.5]),\n",
    "'Pt2CN8':('1d',6.0,[78,78,6,6,6,6,7,7,7,7,6,6,6,6,7,7,7,7],-4,\\\n",
    "[[0.,0.,0.0],[0.,0.,1/2-0.05],[2.0,0.,0.0],[-2.0,0.,0.0],[0.,2.0,0.0],[0.,-2.0,0.0],[3.1,0.,0.0],[-3.1,0.,0.0],[0.,3.1,0.0],[0.,-3.1,0.0],\\\n",
    "[1.414,1.414,1/2-0.05],[-1.414,1.414,1/2-0.05],[1.414,-1.414,1/2-0.05],[-1.414,-1.414,1/2-0.05],[2.192,2.192,1/2-0.05],[2.192,-2.192,1/2-0.05],[-2.192,2.192,1/2-0.05],[-2.192,-2.192,1/2-0.05]],(0,0,50),(0,0,100),0.0005,[-15,-5,150],[True,False],[False,False,True],np.linspace(-1.0,1.0,16),0.0,[1,3],[20],[0.,0.25,0.5]),\n",
    "'square_H4':('2d_square',3.0,[1,1,1,1],0.,[[0,0,0],[1/2,0,0],[0,1/2,0],[1/2,1/2,0]],(50,50,0),(100,100,0),0.0005,[-30,-10,100],[True,False],[False,True,False],np.linspace(-2.0,2.0,16),0.0,[2,1],[0],[[0.0,0.0],[0.0,0.5],[0.5,0.5]]),\n",
    "'square_CuO':('2d_square',4.2,[29,8,8,29],0.,[[0,0,0],[1/2,0,0],[0,1/2,0],[1/2,1/2,0]],(9,9,0),(12,12,0),0.0005,[-20,0,150],[True,False],[False,True,False],np.linspace(-1.0,1.0,16),0.0,[1,3],[16],[[0.0,0.0],[0.0,0.5],[0.5,0.5]]),\n",
    "'square_H':('2d_square',1.5,[1],0.,[[0,0,0]],(100,100,0),(200,200,0),0.05,[-30,-10,200],[True,False],[False,True,False],np.linspace(-2.0,2.0,16),0.0,[3,3],[0],[[0.0,0.0],[0.0,0.5],[0.5,0.5]]),\n",
    "'2d_graphene':('2d_h',2.46,[6,6],0.,[[0.,0.,.0],[2/3,1/3,0.]],(30,35,0),(50,55,0),0.0005,[-25,-4,250],[True,False],[False,True,False],np.linspace(-0.5,0.5,16),1.0,[1,2],[3],[[0.0,0.0],[2/3,-1/3],[1/2,0]]),\n",
    "'2d_MoS2':('2d_h',3.16,[16,16,42],0.,[[0.,0.,-1.55],[0.,0.,1.55],[2/3,1/3,0.0]],(12,13,0),(15,16,0),0.0005,[-17,-4,350],[True,False],[False,True,False],np.linspace(-0.3,0.3,16),0.0,[1,1],[8],[[0.0,0.0],[2/3,-1/3],[1/2,0]]),\n",
    "'2d_NbS2':('2d_h',3.16,[16,16,41],0.,[[0.,0.,-1.55],[0.,0.,1.55],[2/3,1/3,0.0]],(12,13,0),(15,16,0),0.0005,[-17,-4,350],[True,False],[False,True,False],np.linspace(-0.3,0.3,16),0.0,[1,1],[8],[[0.0,0.0],[2/3,-1/3],[1/2,0]]),\n",
    "'hexagonal_H2':('2d_h',np.sqrt(3)*1.1,[1,1],0.,[[0.,0.,.0],[2/3,1/3,0.]],(100,102,0),(200,202,0),0.0005,[-35,0,150],[True,False],[False,True,False],np.linspace(-1.0,1.0,16),0.0,[2,2],[1],[[0.0,0.0],[2/3,-1/3],[1/2,0]]),\n",
    "'2d_Au':('2d_h',np.sqrt(3)*2.884,[79,79,79],0.,[[0.,0.,.0],[2/3,1/3,0.],[1/3,2/3,0.]],(5,6,0),(7,8,0),0.0005,[-25,-4,150],[False,True],[False,True,False],np.linspace(-0.3,0.3,16),0.0,[1,1],[10],[[0.0,0.0],[2/3,-1/3],[1/2,0]]),\n",
    "'cubic_H':('c',1.5,[1],0.,[[0.,0.,0.0]],(10,10,10),(20,20,20),0.05,[-35,-5,200],[False,True],[False,True,False],[],[],[2,2],[],[]),\n",
    "'BN':('fcc',3.615,[5,7],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,False,True],[],[],[1,1],[],[]),\n",
    "'BP':('fcc',4.538,[5,15],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'AlN':('fcc',4.38,[13,7],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'AlP':('fcc',5.451,[13,15],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'AlAs':('fcc',5.6605,[13,33],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'AlSb':('fcc',6.1355,[13,51],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'GaN':('fcc',4.52,[31,7],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'GaP':('fcc',5.451,[31,15],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'GaAs':('fcc',5.653,[31,33],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'GaSb':('fcc',6.0959,[31,51],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'ZnS':('fcc',5.42,[30,16],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(5,5,5),(9,9,9),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'CdS':('fcc',6.1355,[48,16],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(6,6,6),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'CuCl':('h',(3.91,6.42),[29,29,17,17],0.,[[2/3,1/3,0.],[1/3,2/3,1/2],[2/3,1/3,3/8],[1/3,2/3,17/24]],(6,6,6),(9,9,9),0.0005,[-17,-4,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'Si':('fcc',5.431,[14,14],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(9,9,9),(12,12,12),0.0005,[-25,0,100],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'Ge':('fcc',5.658,[32,32],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(9,9,9),(12,12,12),0.0005,[-30,10,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'Sn':('fcc',6.489,[52,52],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(9,9,9),(12,12,12),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'diamond':('fcc',3.567,[6,6],0.,[[0.,0.,0.0],[1/4,1/4,1/4]],(7,7,7),(10,10,10),0.0005,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'LiF':('fcc',4.03,[3,9],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-25,5,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'NaF':('fcc',4.63,[11,9],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-25,5,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'LiCl':('fcc',5.14,[3,17],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-25,5,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'NaCl':('fcc',5.6402,[11,17],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-25,5,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'MgO':('fcc',4.212,[12,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-16,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'NiO':('fcc',4.20,[28,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-16,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'FeO':('fcc',4.28,[26,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-16,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'TiO':('fcc',4.17,[22,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-16,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'VO':('fcc',4.08,[23,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.05,[-16,0,250],[False,True],[False,True,False],[],[],[2,2],[],[]),\n",
    "'CuO':('t',(4.20,4.80),[29,29,29,29,8,8,8,8],0.,[[0.,0.,.0],[1/2,1/2,0.],[1/2,0.,1/2],[0.,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-17,0,250],[False,True],[False,True,False],[],[],[1,2],[],[],[]), \n",
    "'TiN':('fcc',4.249,[22,7],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-30,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'VN':('fcc',4.136,[23,7],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-30,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'CrN':('fcc',4.149,[24,7],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-30,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'NbN':('fcc',4.392,[41,7],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-16,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'TiC':('fcc',4.328,[22,6],0.,[[0.,0.,0.0],[1/2,1/2,1/2]],(6,6,6),(9,9,9),0.0005,[-24,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'NiAs':('h',(3.617,5.038),[28,28,33,33],0.,[[0,0,0.],[0.,0.,1/2],[2/3,1/3,1/4],[1/3,2/3,3/4]],(6,6,6),(9,9,9),0.0005,[-17,-4,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'Li3N':('h',(3.651,3.889),[3,3,3,7],0.,[[0,0,1/2],[1/3,2/3,0],[2/3,1/3,0],[0,0,0]],(6,6,6),(9,9,9),0.0005,[-17,-4,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'VS':('h',(3.33,5.82),[23,23,16,16],0.,[[0,0,0.],[0.,0.,1/2],[2/3,1/3,1/4],[1/3,2/3,3/4]],(6,6,6),(9,9,9),0.0005,[-17,-4,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'CrS':('h',(3.42,5.55),[24,24,16,16],0.,[[0,0,0.],[0.,0.,1/2],[2/3,1/3,1/4],[1/3,2/3,3/4]],(6,6,6),(9,9,9),0.0005,[-17,-4,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'WC':('h',(2.928,2.837),[74,6],0.,[[0,0,0.],[2/3,1/3,1/2]],(6,6,6),(9,9,9),0.0005,[-17,-4,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'WO3':('c',3.81,[74,8,8,8],0.,[[0.,0.,0.0],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'NbO':('c',4.261,[41,41,41,8,8,8],0.,[[0.,1/2,1/2],[1/2,1/2,0.],[1/2,0.,1/2],[0.,0.,1/2],[0.,1/2,0.],[1/2,0.,0.]],(5,5,5),(8,8,8),0.005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'ReO3':('c',3.742,[75,8,8,8],0.,[[0.,0.,0.0],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.005,[-18,-5,250],[True,False],[False,True,False],[],[],[1,1],[],[]),\n",
    "'SrTiO3':('c',3.905,[22,38,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'SrVO3':('c',3.890,[23,38,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'SrMnO3':('c',3.806,[25,38,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'SrNbO3':('c',4.016,[22,38,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'SrMoO3':('c',3.975,[22,38,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'YCrO3':('c',3.768,[24,39,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'KNiF3':('c',4.013,[28,19,9,9,9],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'NaVF3':('c',3.94,[23,11,9,9,9],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-21,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'NaWO3':('c',3.87,[74,11,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(6,6,6),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'LaRhO3':('c',4.10,[45,57,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'LaCrO3':('c',3.85,[24,57,8,8,8],0.,[[0.,0.,0.0],[1/2,1/2,1/2],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2]],(5,5,5),(8,8,8),0.0005,[-18,-5,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'fcc_H':('fcc',3.5,[1],0.,[[0.,0.,0.0]],(11,11,11),(14,14,14),0.05,[-30,-10,100],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'fcc_Ni':('fcc',3.524,[28],0.,[[0.,0.,0.0]],(7,7,7),(11,11,11),0.05,[-20,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'fcc_Pd':('fcc',3.891,[46],0.,[[0.,0.,0.0]],(7,7,7),(11,11,11),0.05,[-18,0,100],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'fcc_Pt':('fcc',3.924,[78],0.,[[0.,0.,0.0]],(7,7,7),(11,11,11),0.05,[-20,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'fcc_Cu':('fcc',3.615,[29],0.,[[0.,0.,0.0]],(7,7,7),(11,11,11),0.05,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'fcc_Ca':('fcc',5.58,[20],0.,[[0.,0.,0.0]],(9,9,9),(13,13,13),0.05,[-15,0,100],[False,True],[False,True,False],[],[],[2,1],[],[]),\n",
    "'fcc_Al':('fcc',4.050,[13],0.,[[0.,0.,0.0]],(9,9,9),(13,13,13),0.05,[-25,0,100],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'fcc_Ag':('fcc',4.090,[47],0.,[[0.,0.,0.0]],(7,7,7),(11,11,11),0.05,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'fcc_Au':('fcc',4.080,[79],0.,[[0.,0.,0.0]],(7,7,7),(11,11,11),0.05,[-25,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'bcc_Na':('bcc',4.23,[11],0.,[[0.,0.,.0]],(13,13,13),(17,17,17),0.05,[-8,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'c_Na':('c',4.23,[11,11],0.,[[0.,0.,.0],[1/2,1/2,1/2]],(9,9,9),(13,13,13),0.05,[-8,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]),\n",
    "'bcc_K':('bcc',5.328,[19],0.,[[0.,0.,.0]],(15,15,15),(17,17,17),0.05,[-8,0,100],[False,True],[False,True,False],[],[],[1,2],[],[]), \n",
    "'bcc_Fe':('bcc',2.870,[26],0.,[[0.,0.,.0]],(7,7,7),(11,11,11),0.05,[-20,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]), \n",
    "'bcc_W':('bcc',3.160,[74],0.,[[0.,0.,.0]],(7,7,7),(11,11,11),0.05,[-20,0,150],[False,True],[False,True,False],[],[],[1,2],[],[]), \n",
    "'bcc_Mo':('bcc',3.147,[42],0.,[[0.,0.,.0]],(7,7,7),(11,11,11),0.05,[-20,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]), \n",
    "'bcc_V':('bcc',3.040,[23],0.,[[0.,0.,.0]],(7,7,7),(11,11,11),0.05,[-20,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]), \n",
    "'bcc_Cr':('bcc',2.91,[24],0.,[[0.,0.,.0]],(7,7,7),(11,11,11),0.05,[-20,0,250],[False,True],[False,True,False],[],[],[1,2],[],[]), \n",
    "'bcc_Nb':('bcc',3.30,[41],0.,[[0.,0.,.0]],(7,7,7),(11,11,11),0.05,[-16,-4,250],[False,True],[False,True,False],[],[],[1,2],[],[]), \n",
    "'SrVO2H':('t',(3.93,3.66),[23,8,8,1,38],0.,[[0.,0.,.0],[1/2,0.,0.],[0.,1/2,0.],[0.,0.,1/2],[1/2,1/2,1/2]],(3,3,3),(5,5,5),0.05,[-20,0,350],[False,True],[False,True,False],[],[],[1,1],[],[],[]), \n",
    "'graphite':('h',(2.46,8.685),[6,6,6,6],0.,[[0.,0.,.0],[2/3,1/3,0.],[1/3,2/3,1/2],[0,0,1/2]],(15,15,5),(20,20,7),0.0005,[-25,-4,250],[False,True],[False,True,False],[],[],[1,1],[],[]), \n",
    "'expanded_graphite':('o',(0.5*4*1.42*np.sqrt(3),6*1.42,5.35),[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6],0.,[[0,1/6,0],[0,2/6,0],[0,4/6,0],[0,5/6,0],[1/2,1/6,0],[1/2,2/6,0],[1/2,4/6,0],[1/2,5/6,0],\n",
    "         [1/4,1/12,0],[1/4,5/12,0],[1/4,7/12,0],[1/4,11/12,0],[3/4,1/12,0],[3/4,5/12,0],[3/4,7/12,0],[3/4,11/12,0]],\n",
    "         (6,6,2),(10,10,2),0.0005,[-25,0,200],[False,True],[False,True,False],[],[],[1,1],[],[]), ##this is graphite in the KC8 structure without K i.e. expanded, eclipsed layers and an orthorhombic unit cell\n",
    "'KC8':('o',(0.5*4*1.42*np.sqrt(3),6*1.42,5.35),[19,19,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6],0.,[[0,0,1/2],[1/2,1/2,1/2],[0,1/6,0],[0,2/6,0],[0,4/6,0],[0,5/6,0],[1/2,1/6,0],[1/2,2/6,0],[1/2,4/6,0],[1/2,5/6,0],\n",
    "         [1/4,1/12,0],[1/4,5/12,0],[1/4,7/12,0],[1/4,11/12,0],[3/4,1/12,0],[3/4,5/12,0],[3/4,7/12,0],[3/4,11/12,0]],\n",
    "         (6,6,2),(10,10,2),0.0005,[-25,0,200],[False,True],[False,True,False],[],[],[1,1],[],[]), \n",
    "'C8Br':('o',(0.5*4*1.42*np.sqrt(3),6*1.42,7.05),[35,35,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6],0.,[[0,0,1/2],[1/2,1/2,1/2],[0,1/6,0],[0,2/6,0],[0,4/6,0],[0,5/6,0],[1/2,1/6,0],[1/2,2/6,0],[1/2,4/6,0],[1/2,5/6,0],\n",
    "         [1/4,1/12,0],[1/4,5/12,0],[1/4,7/12,0],[1/4,11/12,0],[3/4,1/12,0],[3/4,5/12,0],[3/4,7/12,0],[3/4,11/12,0]],\n",
    "         (6,6,2),(10,10,2),0.0005,[-25,0,200],[False,True],[False,True,False],[],[],[1,1],[],[]), \n",
    "'hexagonal_BN':('h',(2.504,6.661),[5,7,5,7],0.,[[0.,0.,.0],[2/3,1/3,0.],[0.,0.,1/2],[2/3,1/3,1/2]],(6,6,4),(10,10,6),0.0005,[-25,-4,350],[False,True],[False,True,False],[],[],[1,1],[],[]), \n",
    "'hcp_Ru':('h',(2.706,4.282),[44,44],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(3,4,3),(9,10,10),0.05,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'hcp_Al':('h',(2.973,5.618),[13,13],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(9,10,9),(13,14,13),0.05,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'hcp_Zn':('h',(2.665,4.947),[30,30],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(3,4,3),(9,10,10),0.05,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'hcp_Mg':('h',(3.209,5.209),[12,12],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(10,10,10),(12,12,12),0.05,[-15.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'hcp_Co':('h',(2.507,4.069),[27,27],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(3,4,3),(9,10,10),0.05,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'hcp_Zr':('h',(3.231,5.148),[40,40],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(3,4,3),(9,10,10),0.05,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'hcp_Be':('h',(2.286,3.584),[4,4],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(9,10,9),(13,14,13),0.05,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'hcp_Ti':('h',(2.951,4.686),[22,22],0.,[[0.,0.,0.0],[2/3,1/3,1/2]],(3,4,3),(9,10,10),0.05,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_TiO2':('t',(4.584,2.953),[22,22,8,8,8,8],0.,[[0.,0.,.0],[1/2,1/2,1/2],[0.3001,0.3001,0.],[(1-0.3001),(1-0.3001),0.]\\\n",
    ",[(1/2+0.3001),(1/2-0.3001),1/2],[(1/2-0.3001),(1/2+0.3001),1/2]],(3,3,3),(5,5,5),0.0005,[-20.,0.,250],[False,True],[False,True,False],[],[],[1,1],[],[]), \n",
    "'t_VO2':('t',(4.5546,2.8514),[23,23,8,8,8,8],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3001,0.3001,0.]\\\n",
    ",[(1-0.3001),(1-0.3001),0.],[(0.5+0.3001),(0.5-0.3001),0.5],[(0.5-0.3001),(0.5+0.3001),0.5]], \n",
    " (3,3,3),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_RuO2':('t',(4.480,3.105),[44,44,8,8,8,8],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3048,0.3048,0.]\\\n",
    ",[(1-0.3048),(1-0.3048),0.],[(0.5+0.3048),(0.5-0.3048),0.5],[(0.5-0.3048),(0.5+0.3048),0.5]], \n",
    " (2,2,2),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_NbO2':('t',(4.480,3.105),[41,41,8,8,8,8],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3048,0.3048,0.]\\\n",
    ",[(1-0.3048),(1-0.3048),0.],[(0.5+0.3048),(0.5-0.3048),0.5],[(0.5-0.3048),(0.5+0.3048),0.5]], \n",
    " (2,2,2),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_SnO2':('t',(4.737,3.185),[50,50,8,8,8,8],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3048,0.3048,0.]\\\n",
    ",[(1-0.3048),(1-0.3048),0.],[(0.5+0.3048),(0.5-0.3048),0.5],[(0.5-0.3048),(0.5+0.3048),0.5]], \n",
    " (2,2,2),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_MnO2':('t',(4.396,2.871),[25,25,8,8,8,8],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3001,0.3001,0.]\\\n",
    ",[(1-0.3001),(1-0.3001),0.],[(0.5+0.3001),(0.5-0.3001),0.5],[(0.5-0.3001),(0.5+0.3001),0.5]], \n",
    " (3,3,3),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_CrO2':('t',(4.421,2.916),[24,24,8,8,8,8],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.301,0.301,0.]\\\n",
    ",[(1-0.301),(1-0.301),0.],[(0.5+0.301),(0.5-0.301),0.5],[(0.5-0.301),(0.5+0.301),0.5]], \n",
    " (3,3,3),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_MnF2':('t',(4.8734,3.3099),[25,25,9,9,9,9],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3001,0.3001,0.]\\\n",
    ",[(1-0.3001),(1-0.3001),0.],[(0.5+0.3001),(0.5-0.3001),0.5],[(0.5-0.3001),(0.5+0.3001),0.5]], \n",
    " (3,3,3),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_NiF2':('t',(4.6506,3.0836),[28,28,9,9,9,9],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3001,0.3001,0.]\\\n",
    ",[(1-0.3001),(1-0.3001),0.],[(0.5+0.3001),(0.5-0.3001),0.5],[(0.5-0.3001),(0.5+0.3001),0.5]], \n",
    " (3,3,3),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'t_ZnF2':('t',(4.7034,3.1335),[30,30,9,9,9,9],0.,[[0.,0.,0.0],[0.5,0.5,0.5],[0.3001,0.3001,0.]\\\n",
    ",[(1-0.3001),(1-0.3001),0.],[(0.5+0.3001),(0.5-0.3001),0.5],[(0.5-0.3001),(0.5+0.3001),0.5]], \n",
    " (3,3,3),(5,5,5),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "#'m_MoO2':('m',(5.6109,4.8562,5.6285,120.95),[42,42,42,42,8,8,8,8,8,8,8,8],0.,\n",
    "#[[0.232,0.992,0.016],[0.112,0.217,0.233],[0.391,0.696,0.209]],\n",
    "# (4,4,4),(3,3,3),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'m_VO2':('m',(5.743,4.517,5.375,122.61),[23,23,23,23,8,8,8,8,8,8,8,8],0.,\n",
    "[[0.242,0.975,0.025],[0.1,0.21,0.20],[0.39,0.69,0.29]],\n",
    " (4,3,4),(6,5,6),0.0005,[-20,0,250],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'TiS2':('h',(3.407,5.69),[22,16,16],0.,[[0.,0.,0.],[2/3,1/3,1/4],[1/2,2/3,3/4]],(5,6,3),(9,10,5),0.0005,[-17,-4,350],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'MoS2':('h',(3.19,14.879),[42,42,16,16,16,16],0.,[[1/3,2/3,1/4],[2/3,1/3,3/4],[2/3,1/3,0.1488],[2/3,1/3.,0.3552],[1/3,2/3,0.6448],[1/3,2/3,0.8552]],(6,6,4),(10,10,8),0.0005,[-17,-4,350],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'NbS2':('h',(3.324,11.962),[41,41,16,16,16,16],0.,[[2/3,1/3,1/4],[0.,0.,3/4],[0,0,0.121],[0.,0.,0.379],[1/3,1/3,0.621],[1/3,1/3,0.879]],(6,6,4),(10,10,8),0.0005,[-17,-4,350],[False,True],[False,True,False],[],[],[1,1],[],[]),\n",
    "'CdI2':('h',(4.24,6.84),[48,53,53],0.,[[0.,0.,0.],[2/3,1/3,1/4],[1/2,2/3,3/4]],(5,6,3),(9,10,5),0.0005,[-17,-4,350],[False,True],[False,True,False],[],[],[1,1],[],[])\n",
    "}\n",
    "\n",
    "\n",
    "\n",
    "crystal_comments = {\n",
    "'linear_H':\"a linear chain of hydrogens with a monoatomic basis (1xH) - tip: try changing the lattice parameter or the kpoints to plot\",\n",
    "'linear_H2':\"a linear chain of hydrogens with a diatomic basis (2xH) - tip: compare to linear_H, note the folding of the bands but the DOS is the same. Plot crystal orbitals for both levels (0 and 1)\",\n",
    "'distorted_H2':\"a Peierls distorted chain of hydrogens with a diatomic basis (2xH) and alternating long/short bond lengths - tip: compare the DOS and crystal orbitals to the undistorted version. Plot crystal orbitals for both levels (0 and 1)\",\n",
    "'linear_H4':\"a linear chain of hydrogens with a diatomic basis (2xH) - tip: compare to linear_H and linear_H2, note the further folding of the bands but the DOS is still the same. Plot crystal orbitals for all four levels (0-3)\",\n",
    "'distorted_H4':\"a Peierls distorted chain of hydrogens with a tetraatomic basis (4xH) and alternating long/short/short/long bond lengths. Charge has been set to -2 here to simulate a 3/4 filled band. Compare with distorted H2 and note where the break in the DOS occurs\",\n",
    "'linear_C':\"a linear chain of carbons with a monoatomic basis (1xC) - tip: try changing the lattice parameter or the kpoints to plot. Change the level to plot (0-3)\",\n",
    "'linear_C2':\"a linear chain of carbons with a diatomic basis (2xC) - tip: compare to linear C and note the folding of the bands\",\n",
    "'distorted_C2':\"a Peierls distorted chain of carbons with a diatomic basis (2xC) and alternating long/short bond lengths - tip: compare the DOS and crystal orbitals to the undistorted version.\",\n",
    "'trans_polyacetylene':\"a symmetric polymeric (CH)x chain with a C2H2 basis\",\n",
    "'distorted_trans_polyacetylene':\"a Peierls distorted version of the (CH)x chain: note the break at the Fermi level\",\n",
    "'Pt2H8':\"a symmetric Pt2H8 chain with a PtH4 basis: note the relationship to square planar splitting\",\n",
    "'distorted_Pt2H8':\"a Peierls distorted Pt2H8 chain with a PtH4 basis: tip: contrast to the symmetric form\",\n",
    "'Pt2CN8':\"a symmetric Pt2(CN)8 chain with a Pt(CN)4 basis: note the relationship to square planar splitting\",\n",
    "'square_H4':\"a square array of hydrogens with a tetraatomic basis (4xH) - tip: compare to square_H and note the folding of the bands. plot different levels (0-3) at different k points\",\n",
    "'square_CuO':\"a square array of CuO - note the partially-filled dx2-y2 band. Look at crystal orbitals for this band (select crystal orbital 7)\",\n",
    "'square_H':\"a square array of hydrogens with a monoatomic basis (1xH) - tip: look closely at different combinations of kpoints (kx,ky) to understand how the band structure evolves\",\n",
    "'2d_graphene':\"classic semi-metal with zero DOS at the Fermi level. tip: look at the crystal orbitals at the gamma point (0,0) and also at (2/3,-1/3), where the states near the Fermi level lie\",\n",
    "'2d_MoS2':\"2-d layer structure - note the semi-conductor behaviour\",\n",
    "'2d_NbS2':\"2-d layer structure - note the metallic behaviour because the 4d band cuts the Fermi level\",\n",
    "'2d_H_hex':\"a 2-d hexagonal array of hydrogens: a simple model of graphene\",\n",
    "'2d_Au':\"a 2-d hexagonal array of gold: a simple model of a gold surface\",\n",
    "'cubic_H':\"a cubic array of hydrogens with a monoatomic basis (1xH)\",\n",
    "'fcc_H':\"an fcc array of hydrogens with a diatomic basis (2xH at 0,0,0 and 1/2,1/2,1/2). This is identical to the simple cubic array with a 1xH basis\",\n",
    "'AlN':\"AlN - classic semiconductor. Compare the band gap to Si\",\n",
    "'GaN':\"GaN - classic semiconductor. Compare the band gap to Si\",\n",
    "'GaP':\"GaP - classic semiconductor. Compare the band gap to Si\",\n",
    "'GaAs':\"GaAs - classic semiconductor. Compare the band gap to Si\",\n",
    "'Si':\"Si - the prototype semiconductor. Compare the band gap to Ge/Sn\",\n",
    "'Ge':\"Ge - semiconductor. Compare the band gap to Si/Sn\",\n",
    "'Sn':\"Sn - metallic. Compare the band gap to Si/Ge\",\n",
    "'diamond':\"diamond - classic insulator. Compare the band gap to Si\",\n",
    "'ZnS':\"zincblende structure - semiconductor. Note the band gap\",\n",
    "'NiO':\"Mott Hubbard insulator\",\n",
    "'VO':\"conductor\",\n",
    "'ReO3':\"conducting metallic oxide - note the bands crossing the Fermi level\",\n",
    "'SrTiO3':\"insulating perovskite\",\n",
    "'WO3':\"insulating d0 metal oxide - compare to ReO3 and NaWO3\",\n",
    "'NaWO3-':\"reduced sodium tungstate (as made in the teaching lab) - tip: note how the fermi level lies in the W 5d states for the 1- state. Try changing the charge and see the Fermi level shift\",\n",
    "'NaCl':\"classic ionic material - large band gap, narrow bands due to poor overlap\",\n",
    "'fcc_Ni':\"face-centred cubic nickel lattice\",\n",
    "'fcc_Pd':\"face-centred cubic palladium lattice - compare to Ni/Pt\",\n",
    "'fcc_Pt':\"face-centred cubic platinum lattice - compare to Ni/Pd\",\n",
    "'fcc_Cu':\"face-centred cubic copper lattice - compare to Ni/Pd\",\n",
    "'fcc_Al':\"face-centred cubic aluminium lattice - compare to Ni/Pd\",\n",
    "'fcc_Ca':\"note the overlap of 4s and 4p bands\",\n",
    "'fcc_Pb':\"face-centred cubic lead lattice - compare to diamond/Si/Ge/Sn\",\n",
    "'fcc_Ag':\"face-centred cubic silver lattice - compare to Cu/Au\",\n",
    "'fcc_Au':\"face-centred cubic gold lattice - compare to Cu/Ag\",\n",
    "'bcc_Na':\"body-centred cubic sodium lattice\",\n",
    "'c_Na':\"primitive cubic sodium lattice - tip: compare to bcc_Na - DOS are identical\",\n",
    "'bcc_K':\"body-centred cubic potassium lattice\",\n",
    "'bcc_Fe':\"body-centred cubic iron lattice\",\n",
    "'bcc_W':\"body-centred cubic tungsten lattice\",\n",
    "'bcc_Mo':\"body-centred cubic molybdenum lattice\",\n",
    "'bcc_V':\"body-centred cubic vanadium lattice\",\n",
    "'bcc_Cr':\"body-centred cubic chromium lattice\",\n",
    "'bcc_Nb':\"body-centred cubic niobium lattice\",\n",
    "'CuO':\"distorted rock-salt lattice elongated along c due to Jahn-Teller distortion. tip: try changing compressing and elongating c\",\n",
    "'SrVO2H':\"mixed metal oxide/hydride - 'Hayward chemistry'\",\n",
    "'graphite':\"layered structure - compare to 2d-graphene and note the doubling of the bands. tip: change c0 to move the layers apart\",\n",
    "'hexagonal_BN':\"hexagonal boron nitride - contrast to graphite and note the band gap at the Fermi level\",\n",
    "'graphene_2x2_extension':\"a 2x2 extension of the graphene system - DOS is identical but the bands are folded\",\n",
    "'hcp_Ru':\"hexagonal ruthenium lattice\",\n",
    "'hcp_Al':\"hexagonal aluminium lattice\",\n",
    "'hcp_Zn':\"hexagonal zinc lattice\",\n",
    "'hcp_Mg':\"hexagonal magnesium lattice\",\n",
    "'hcp_Co':\"hexagonal cobalt lattice\",\n",
    "'hcp_Zr':\"hexagonal zirconium lattice\",\n",
    "'hcp_Be':\"hexagonal beryllium lattice\",\n",
    "'hcp_Ti':\"hexagonal titanium lattice\",\n",
    "'t_TiO2':\"rutile structure - insulator, note the band gap\",\n",
    "'t_VO2':\"high-temperature phase of VO2 - note the classic 1-dimensional structure of the DOS. tip: project the DOS onto individual ml to separate out dz2, dxz etc\",\n",
    "'t_RuO2':\"tetragonal RuO2\",\n",
    "'m_MoO2':\"tetragonal MoO2 - 1 more electron/metal compared to V - note where the extra electrons go\",\n",
    "'m_VO2':\"monoclinic low-temperature phase of VO2 - note the distortion of the band. Compare to NbO2\",\n",
    "'TiS2':\"CdI2 structure - layered semiconductor\",\n",
    "'MoS2':\"layered structure - note insulating character. Also note comparison to the 2-d model, 2d_MoS2 (they are very similar)\",\n",
    "'NbS2':\"layered structure - note metallic character. Also note comparison to the 2-d model, 2d_NbS2 (they are very similar)\",\n",
    "'NiAs':\"NiAs - classic 'alloy' rather than ionic - note the metallic behaviour indicated by the large DOS at the Fermi level\",\n",
    "'VS':\"NiAs analogue with fewer electrons\",\n",
    "'CrS':\"NiAs analogue with fewer electrons\",\n",
    "}\n",
    "\n",
    "\n",
    "#the list below is for printing purposes\n",
    "list_of_structures=str(\"the following standard input files are available:\\n\\n\\\n",
    "    Toy hydrogen models:\\n\\n\\\n",
    "    linear_H, linear_H2, linear_H4,\\n\\\n",
    "    distorted_H2, distorted_H4,\\n\\\n",
    "    square_H, square_H4, hexagonal_H,\\n\\\n",
    "    fcc_H\\n\\n\\\n",
    "    1-dimensional systems:\\n\\n\\\n",
    "    Carbon-based systems:\\n\\\n",
    "    linear_C, linear_C2, distorted_C2,\\n\\\n",
    "    trans_polyacetylene, distorted_trans_polyacetylene,\\n\\\n",
    "    Metals:\\n\\\n",
    "    Pt2H8, distorted_Pt2H8, Pt2CN8,\\n\\\n",
    "    poly_SN\\n\\n\\\n",
    "    2-dimensional systems:\\n\\n\\\n",
    "    graphite, diamond, 2d_graphene,\\n\\\n",
    "    2d_Au, 2d_MoS2, 2d_NbS2, square_CuO,\\n\\n\\\n",
    "    Semiconductors:\\n\\\n",
    "    diamond, Si, Ge, Sn, BN, BP, AlN, AlP, AlAs, AlSb, GaN, GaP\\n\\n\\\n",
    "    GaAs, GaSb, CuCl, ZnS, CdS\\n\\n\\\n",
    "    Bulk metals:\\n\\n\\\n",
    "    BCC:\\n\\\n",
    "    bcc_Na, bcc_W, bcc_Fe, bcc_K, bcc_V, bcc_Nb, bcc_Mo, bcc_Cr,\\n\\n\\\n",
    "    HCP:\\n\\\n",
    "    hcp_Al, hcp_Mg, hcp_Ti, hcp_Zr, hcp_Co, hcp_Ru, hcp_Zn,\\n\\n\\\n",
    "    FCC:\\n\\\n",
    "    fcc_Ca, fcc_Cu, fcc_Au, fcc_Pt, fcc_Al, fcc_Ni, fcc_Ag, fcc_Pb, fcc_Pd,\\n\\n\\\n",
    "    Ionic Solids:\\n\\n\\\n",
    "    Rock-salt:\\n\\\n",
    "    NaCl structure, LiF, NaF, LiCl, NaCl, MgO, TiN, TiC, TiO, VO\\n\\n\\\n",
    "    CrO, CrN, FeO, NiO, CuO\\n\\n\\\n",
    "    NiAs structure:\\n\\\n",
    "    alloys: NiAs, CrS, VS:\\n\\n\\\n",
    "    Rutile structure:\\n\\\n",
    "    t_TiO2, t_VO2, t_RuO2, t_CrO2, t_MnF2, t_NiF2, t_ZnF2\\n\\n\\\n",
    "    Perovskite-like:\\n\\\n",
    "    ReO3, WO3, NaWO3, SrTiO3, SrVO3, SrMnO3, SrNbO3, SrMoO3,\\n\\n\\\n",
    "    YCrO3, KNiF3, NaVF3\\n\\n\\\n",
    "    Layered Structures:\\n\\\n",
    "    graphite, hexagonal_BN, KC8, C8Br, TiS2, NbS2, MoS2, SrVO2H\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this just checks that we have a set of coordinates for each atom\n",
    "def check_lengths(coords,atoms):    \n",
    "    if len(atoms)!=len(coords):\n",
    "        print(\"number of atoms\",len(atoms), \"doesn't equal number of coordinates\", len(coords))\n",
    "\n",
    "#function to convert coordinates to atomic units\n",
    "def coord_con_EHT(coords,atoms):\n",
    "    coord_tuple=[];coords_new=coords.copy()    \n",
    "    for a in range(len(coords)):        #convert angstrom to atomic units\n",
    "        #coords_new[a]=coords[a]/A0\n",
    "        coords_new[a]=[x/A0 for x in coords[a]]\n",
    "        coord_tuple.append((atoms[a],coords_new[a][0],coords_new[a][1],coords_new[a][2]))\n",
    "    return coords_new,coord_tuple\n",
    "\n",
    "#sets up a list of the basis functions on each atom\n",
    "def eh_basis_setupb(atoms,parameters):\n",
    "    basis_functs=[]         #set up matrix of basis functions\n",
    "    #print(\"Si basis\",parameters[14])\n",
    "    #keep count of how many basis functions we have    \n",
    "    count=0\n",
    "    for atom_index,atomic_number in enumerate(atoms):\n",
    "        #print(index,item,parameters[item])\n",
    "        if atomic_number<=2:             # H and He (ns)\n",
    "\n",
    "            n=parameters[atomic_number][0]   #principal qu no\n",
    "            l=parameters[atomic_number][1]   #angular mom qu no                         \n",
    "            Hii=parameters[atomic_number][2]  #ionisation energy\n",
    "            zeta=parameters[atomic_number][3] #exponent\n",
    "\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])  #the zero is ml\n",
    "            count+=1\n",
    "\n",
    "        elif 20>=atomic_number>2 or 38>=atomic_number>29:        # main group (ns+np)\n",
    "        \n",
    "            #first deal with the s orbital: note this is the first item in a nested list, hence the extra [0]\n",
    "            n=parameters[atomic_number][0][0]   #principal qu no\n",
    "            l=parameters[atomic_number][0][1]   #angular mom qu no                         \n",
    "            Hii=parameters[atomic_number][0][2]  #ionisation energy\n",
    "            zeta=parameters[atomic_number][0][3] #exponent\n",
    "            \n",
    "            basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])\n",
    "            \n",
    "           #now the p orbitals. We generate 3 from each entry in parameters: px,py,pz which differ only in ml\n",
    "            n=parameters[atomic_number][1][0]   #principal qu no\n",
    "            l=parameters[atomic_number][1][1]   #angular mom qu no                         \n",
    "            Hii=parameters[atomic_number][1][2]  #ionisation energy\n",
    "            zeta=parameters[atomic_number][1][3] #exponent\n",
    "            \n",
    "            basis_functs.append([atomic_number,atom_index,n,l,1,Hii,zeta])   #1,-1,0 are ml\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,-1,Hii,zeta])\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])\n",
    "            count+=4\n",
    "            \n",
    "            #now the d orbitals    #in the case of Cerda\n",
    "            if len(parameters[atomic_number])==3:\n",
    "                n=parameters[atomic_number][2][0]   #principal qu no\n",
    "                l=parameters[atomic_number][2][1]   #angular mom qu no                         \n",
    "                Hii=parameters[atomic_number][2][2]  #ionisation energy\n",
    "                zeta=parameters[atomic_number][2][3] #exponent\n",
    "            \n",
    "                basis_functs.append([atomic_number,atom_index,n,l,2,Hii,zeta])   #2,1,0,-1,-2 are ml\n",
    "                basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])\n",
    "                basis_functs.append([atomic_number,atom_index,n,l,-2,Hii,zeta])\n",
    "                basis_functs.append([atomic_number,atom_index,n,l,1,Hii,zeta])\n",
    "                basis_functs.append([atomic_number,atom_index,n,l,-1,Hii,zeta])\n",
    "                count+=9\n",
    "            \n",
    "        elif 30>atomic_number>20 or 48>atomic_number>38 or 80>=atomic_number>=74:           # transition metals ((n+1)s+(n+1)p+nd) order chosen to be consistent with iconc (pz,px,py: dx2-y2,dz2,dxy,dxz,dyz)\n",
    "            #first deal with the s orbital: note this is the first item in a nested list, hence the extra [0]\n",
    "            n=parameters[atomic_number][0][0]   #principal qu no\n",
    "            l=parameters[atomic_number][0][1]   #angular mom qu no                         \n",
    "            Hii=parameters[atomic_number][0][2]  #ionisation energy\n",
    "            zeta=parameters[atomic_number][0][3] #exponent\n",
    "            \n",
    "            basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])  \n",
    "         \n",
    "            #now the p orbitals. We generate 3 from each entry in parameters: px,py,pz which differ only in ml\n",
    "            n=parameters[atomic_number][1][0]   #principal qu no\n",
    "            l=parameters[atomic_number][1][1]   #angular mom qu no                         \n",
    "            Hii=parameters[atomic_number][1][2]  #ionisation energy\n",
    "            zeta=parameters[atomic_number][1][3] #exponent\n",
    "            \n",
    "            basis_functs.append([atomic_number,atom_index,n,l,1,Hii,zeta])   #1,-1,0 are ml\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,-1,Hii,zeta])\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])\n",
    "            \n",
    "            #now the d orbitals\n",
    "            n=parameters[atomic_number][2][0]   #principal qu no\n",
    "            l=parameters[atomic_number][2][1]   #angular mom qu no                         \n",
    "            Hii=parameters[atomic_number][2][2]  #ionisation energy\n",
    "            zeta=parameters[atomic_number][2][3] #exponent\n",
    "            \n",
    "            basis_functs.append([atomic_number,atom_index,n,l,2,Hii,zeta])   #2,1,0,-1,-2 are ml\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,-2,Hii,zeta])\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,1,Hii,zeta])\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,-1,Hii,zeta])\n",
    "            count+=9\n",
    "        elif atomic_number==179:             # special 6s-only Au for electrodes\n",
    "            n=parameters[atomic_number][0][0]   #principal qu no\n",
    "            l=parameters[atomic_number][0][1]   #angular mom qu no                         \n",
    "            Hii=parameters[atomic_number][0][2]  #ionisation energy\n",
    "            zeta=parameters[atomic_number][0][3] #exponent\n",
    "\n",
    "            basis_functs.append([atomic_number,atom_index,n,l,0,Hii,zeta])  #the zero is ml\n",
    "            count+=1\n",
    "    #print(\"basi_functs 7\",basis_functs)\n",
    "    return basis_functs\n",
    "\n",
    "#count the number of electrons\n",
    "def count_electrons(atoms,Q,parameter_file):\n",
    "        #function to work out how many VALENCE electrons are present    \n",
    "    \n",
    "        no_electrons=-Q   #initial the number of electrons as -Q\n",
    "        #loop over the list of atoms (length len(atoms))\n",
    "        for i in range(len(atoms)):\n",
    "            if atoms[i]<=2:      #H\n",
    "                    no_electrons+=atoms[i]\n",
    "                    #print(atoms[i],\"add\",atoms[i],\"cum\",no_electrons )\n",
    "            elif 2<atoms[i]<=10:   #He to F\n",
    "                    no_electrons+=atoms[i]-2    #atoms[i] is the atomic number.\n",
    "                    #print(atoms[i],\"add\",atoms[i]-2,\"cum\",no_electrons )\n",
    "            elif 10<atoms[i]<=18:  #Ne to Cl    #We need to subtract off number of core electrons\n",
    "                    no_electrons+=atoms[i]-10\n",
    "                    #print(atoms[i],\"add\",atoms[i]-10,\"cum\",no_electrons )\n",
    "            elif 18<atoms[i]<=29:  #Ar to Cu\n",
    "                    no_electrons+=atoms[i]-18\n",
    "            elif atoms[i]==30:  #Zn\n",
    "                #print(\"here\",parameters)\n",
    "                if parameter_file=='Hoffmann':\n",
    "                    no_electrons+=atoms[i]-18\n",
    "                elif parameter_file==('Cerda' or 'modified_Cerda'):\n",
    "                    no_electrons+=atoms[i]-28\n",
    "            elif 30<atoms[i]<=36:  #Ga to Br\n",
    "                    no_electrons+=atoms[i]-28\n",
    "            elif 36<atoms[i]<=48:\n",
    "                    no_electrons+=atoms[i]-36    \n",
    "            elif 54<atoms[i]<=71:\n",
    "                    no_electrons+=atoms[i]-54    \n",
    "            elif 80>=atoms[i]>=74:\n",
    "                    no_electrons+=atoms[i]-68 \n",
    "            elif atoms[i]==179:\n",
    "                    no_electrons+=1 \n",
    "                    #print(atoms[i],\"add 1\",\"cum\",no_electrons )\n",
    "        return no_electrons\n",
    "\n",
    "#calculates direction cosines needed for angular dependence (see wikipidea entry for parameters)            \n",
    "def dircos(i,j,coords,basis_functs):\n",
    "        atomindexi=basis_functs[i][1]\n",
    "        atomindexj=basis_functs[j][1]\n",
    "        coordsi=coords[atomindexi]\n",
    "        coordsj=coords[atomindexj]\n",
    "        #print \"coords are\", coordsi,coordsj\n",
    "        vecij=[(coordsj[0]-coordsi[0]),(coordsj[1]-coordsi[1]),(coordsj[2]-coordsi[2])]\n",
    "        distij=np.linalg.norm(vecij)\n",
    "        if distij==0:           #create exception in case bfs are on the same atom, where vector == null\n",
    "                dcl=0.0\n",
    "                dcm=0.0\n",
    "                dcn=0.0\n",
    "        else:\n",
    "                dcn=vecij[2]/distij\n",
    "                dcm=vecij[1]/distij\n",
    "                dcl=vecij[0]/distij\n",
    "\n",
    "        return distij,dcl,dcm,dcn\n",
    "\n",
    "\n",
    "# functions for Mulliken's A and B coefficients\n",
    "# formulae from Mulliken, Rieke, Orloff and Orloff, J Chem Phys 1949, 17, 1248\n",
    "\n",
    "def A_funct(k,pij):\n",
    "        A=0\n",
    "        for i in range(1,k+2):\n",
    "                A+=np.exp(-pij)*m.factorial(k)*(m.factorial(k-i+1)*(pij**i))**-1\n",
    "        return A\n",
    "\n",
    "def B_funct(k,pij,tij):\n",
    "        if tij==0.:         #exception in case exponents are identical, in which case it reduces to a trivial integral of x**n.\n",
    "            if k%2==0.:     #test for k even, int(x**k)=2/(k+1)\n",
    "                B=2/(k+1)\n",
    "            else:           #if k odd, integral of x**k is zero\n",
    "                B=0\n",
    "        else:               #full function\n",
    "            B=0\n",
    "            for i in range(1,k+2):\n",
    "                B+=-np.exp(-pij*tij)*m.factorial(k)*(m.factorial(k-i+1)*(pij*tij)**i)**-1-np.exp(pij*tij)*m.factorial(k)*((-1.0)**(k-i)*(m.factorial(k-i+1)*(pij*tij)**i)**-1)\n",
    "        return B\n",
    "\n",
    "#Formulae from Stewart, Encyclopedia of Computational Chemistry  (\"Overlap\" chapter)\n",
    "\n",
    "#table of premultipliers that depend only on i,j,ja/jb (from Stewart in Encyclopedia of Computational Chemistry (\"overlap integrals\"))\n",
    "radial_coeff={(0,0,0):1.,                                                                               \n",
    "              (1,0,0):1,\n",
    "              (1,1,0):0.5**0.5,\n",
    "              (2,0,0):1.5,\n",
    "              (2,0,1):-0.5,\n",
    "              (2,1,0):1.5**0.5,\n",
    "              (2,2,0):0.375**0.5}  \n",
    "\n",
    "#function for overlap between any pair of Slater functions (Stewart)\n",
    "def new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,mz):   \n",
    "    #    print(\"called_new_overlap\",l_i,l_j)\n",
    "    #following Stewart.....\n",
    "    prefactor=0.5*zeta_i**(n_i+0.5)*zeta_j**(n_j+0.5)*((2*l_i+1)*(2*l_j+1)/(m.factorial(2*n_i)*m.factorial(2*n_j)))**0.5*distij**(n_i+n_j+1)\n",
    "    #initialise the cumulative overlap (there are many contributions to this which I am going to sum up)\n",
    "#            \n",
    "    sumovlp=0.\n",
    "    for ja,jb,ka,kb in itertools.product(range(int(0.5*(l_i-mz))+1), range(int(0.5*(l_j-mz))+1), range(int(mz+1)), range(int(mz+1))):\n",
    "        for Pa,Pb,qa,qb in itertools.product(range(int(n_i-l_i+2*ja)+1),range(int(n_j-l_j+2*jb)+1),range(int(l_i-mz-2*ja)+1),range(int(l_j-mz-2*jb)+1)):\n",
    "            sumovlp+=prefactor*radial_coeff[(l_i,mz,ja)]*radial_coeff[(l_j,mz,jb)]\\\n",
    "            *m.factorial(l_i-mz-2*ja)*m.factorial(l_j-mz-2*jb)*m.factorial(n_i-l_i+2*ja)*m.factorial(n_j-l_j+2*jb)*(-1)**(ka+kb+mz+Pb+qb)*m.factorial(mz)**2\\\n",
    "            *B_funct((2*ka+Pa+Pb+qa+qb),pij,tij)*A_funct((2*kb+n_i-l_i+2*ja+n_j-l_j+2*jb-Pa-Pb+qa+qb),pij)\\\n",
    "            /(m.factorial(l_i-mz-2*ja-qa)*m.factorial(qa)*m.factorial(l_j-mz-2*jb-qb)*m.factorial(qb)*m.factorial(n_i-l_i+2*ja-Pa)*m.factorial(Pa)\\\n",
    "            *m.factorial(n_j-l_j+2*jb-Pb)*m.factorial(Pb)*m.factorial(mz-ka)*m.factorial(ka)*m.factorial(mz-kb)*m.factorial(kb))\n",
    "    return sumovlp\n",
    "\n",
    "    \n",
    "#constructs the overlap matrix:\n",
    "#first compute the overlap along the z axis (using one of newoverlap/b/c), then multiply by the angular factor from direction cosines\n",
    "def overlap_matrix_new(basis_functs,coords,dist_cutoff):    \n",
    "    dcovlp=np.identity(len(basis_functs))    # automatically sets diagonal atoms to 1.0 \n",
    "    overlaps_dictionary={}\n",
    "    # note \"dcovlp\" used to remind me I use direction cosines\n",
    "    \n",
    "    # now compute all off diagonal elements    \n",
    "    skip=0.;keep=0.  #keep track of how many I keep and how many I throw away based on distance criteria\n",
    "    for i in range(len(basis_functs)):     \n",
    "        for j in range(len(basis_functs)):\n",
    "           #so we loop over pairs of basis functions, i and j\n",
    "            if j>i:  #only do the upper half of the matrix - we will simply copy the top half to the bottom at the end as it must be symmetric\n",
    "                sigma_ovlp=0.;pi_ovlp=0.;delta_ovlp=0.   #initialise all overlaps to zero\n",
    "                    #now calculate the direction cosines. see https://en.wikipedia.org/wiki/Tight_binding\n",
    "                    #if v = vx(x) + vy(y) + vz(z) then l=v.x/|v| = the cosine of the angle between v and x axis\n",
    "                    #distij is the distance between the two centres, i and j\n",
    "                distij,dcl,dcm,dcn=dircos(i,j,coords,basis_functs)\n",
    "                #if 1!=1:                \n",
    "                if distij>dist_cutoff:   #don't bother if the atoms are too far apart\n",
    "                        dcovlp[i,j]=0.0\n",
    "                        skip+=1\n",
    "                else:\n",
    "                    keep+=1\n",
    "                    #now identify the 2 atoms:\n",
    "                    atom_index_i=basis_functs[i][1];atom_index_j=basis_functs[j][1]\n",
    "                    atomic_number_i=basis_functs[i][0];atomic_number_j=basis_functs[i][0]\n",
    "                    #identify the quantum numbers\n",
    "                    n_i=basis_functs[i][2];n_j=basis_functs[j][2]\n",
    "                    l_i=basis_functs[i][3];l_j=basis_functs[j][3]\n",
    "                    #print(\"ls\",l_i,l_j)\n",
    "                    ml_i=basis_functs[i][4];ml_j=basis_functs[j][4]\n",
    "                    Hii_i=basis_functs[i][5];Hii_j=basis_functs[j][5]\n",
    "                    zeta_i_temp=basis_functs[i][6];zeta_j_temp=basis_functs[j][6]    #mistake was here (i instead of j)\n",
    "                    \n",
    "                    if atom_index_i==atom_index_j:                      \n",
    "                            # same atom, different basis functions, set ovlp to 0\n",
    "                            dcovlp[i,j]=0.0\n",
    "                  \n",
    "                  \n",
    "                  \n",
    "                  #now run over all possible pairs: s-s, s-p, s-d, p-p, p-d, d-d\n",
    "                                        #ss overlaps\n",
    "                            \n",
    "                    elif l_i==l_j==0:                 #ss overlap\n",
    "                    #no point in setting up a distionary entry for this as there is only ever 1 ss overlap between 2 atoms\n",
    "                            #print(i,j,zeta_i_temp,zeta_j_temp)\n",
    "                            zeta_i=zeta_i_temp[0];zeta_j=zeta_j_temp[0];coeff_i=zeta_i_temp[1];coeff_j=zeta_j_temp[1]\n",
    "                            #print(zeta_i,coeff_i)                            \n",
    "                            #print(\"here\",i,j,n_i,n_j,l_i,l_j,zeta_i,zeta_j,distij)\n",
    "                        #set the pij,Bpij and tij parameters\n",
    "                            pij=0.5*(zeta_i+zeta_j)*distij\n",
    "                            Bpij=0.5*(zeta_i-zeta_j)*distij\n",
    "                            tij=(zeta_i-zeta_j)/(zeta_i+zeta_j)      \n",
    "                            #calculate the overlap using \"new_overlap\" function\n",
    "                            ss_ovlp=new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,0) \n",
    "                            #set the total overlap: trivial here because there is no angular factor to worry about \n",
    "                            dcovlp[i,j]=coeff_i*coeff_j*ss_ovlp     \n",
    "                            #print(\"here2\",i,j,ss_ovlp)\n",
    "                            #print(i,j,ss_ovlp)\n",
    "                                        #pp overlaps (9 permutations of pxpy etc)\n",
    "                            \n",
    "                    elif l_i==l_j==1:\n",
    "                        #print(\"pp\",i,j)\n",
    "                        sigma_key=(1,atom_index_i,atom_index_j,1,1)\n",
    "                        pi_key=(2,atom_index_i,atom_index_j,1,1)\n",
    "                        #print(sigma_key,pi_key)\n",
    "                        if sigma_key not in overlaps_dictionary: \n",
    "                            #print(\"pp calculated\",i,j)\n",
    "                            \n",
    "                            if type(zeta_i_temp[0]) is float and type(zeta_j_temp[0]) is float: #both p's are single zeta\n",
    "                                #print(\"here 1\")\n",
    "                                zeta_i=zeta_i_temp[0];zeta_j=zeta_j_temp[0];coeff_i=zeta_i_temp[1];coeff_j=zeta_j_temp[1]\n",
    "                                pij=0.5*(zeta_i+zeta_j)*distij\n",
    "                                Bpij=0.5*(zeta_i-zeta_j)*distij\n",
    "                                tij=(zeta_i-zeta_j)/(zeta_i+zeta_j) \n",
    "                            #calculate the pure sigma and pi overlaps. \n",
    "                            #Note the negative sign: 2 p orbitals aligned along the same axis have negative overlap                             \n",
    "                                ppsigma_ovlp=-coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,0) #m=0\n",
    "                                pppi_ovlp=coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,1)     #m=1\n",
    "                                #print(\"ppoverlap\",ppsigma_ovlp,pppi_ovlp)\n",
    "                            elif type(zeta_i_temp[0]) is float and type(zeta_j_temp[0]) is tuple:  #first is single second is double\n",
    "                                ppsigma_ovlp=0.;pppi_ovlp=0.\n",
    "                                for l in [0,1]:    \n",
    "                                    zeta_i=zeta_i_temp[0];coeff_i=zeta_i_temp[1]\n",
    "                                    zeta_j=zeta_j_temp[l][0];coeff_j=zeta_j_temp[l][1]\n",
    "                                    pij=0.5*(zeta_i+zeta_j)*distij\n",
    "                                    Bpij=0.5*(zeta_i-zeta_j)*distij\n",
    "                                    tij=(zeta_i-zeta_j)/(zeta_i+zeta_j)\n",
    "                                    ppsigma_ovlp+=-coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,0) \n",
    "                                    pppi_ovlp+=coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,1)\n",
    "                            elif type(zeta_j_temp[0]) is float and type(zeta_i_temp[0]) is tuple:   #first is double, second is single\n",
    "                                ppsigma_ovlp=0.;pppi_ovlp=0.\n",
    "                                for l in [0,1]:    \n",
    "                                    zeta_j=zeta_j_temp[0];coeff_j=zeta_j_temp[1]\n",
    "                                    zeta_i=zeta_i_temp[l][0];coeff_i=zeta_i_temp[l][1]\n",
    "                                    pij=0.5*(zeta_j+zeta_i)*distij\n",
    "                                    Bpij=0.5*(zeta_i-zeta_j)*distij\n",
    "                                    tij=(zeta_i-zeta_j)/(zeta_j+zeta_i)\n",
    "                                    ppsigma_ovlp+=-coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,0) \n",
    "                                    pppi_ovlp+=coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,1)\n",
    "                            elif type(zeta_j_temp[0]) is tuple and type(zeta_i_temp[0]) is tuple:  #both are double\n",
    "                                #print(\"here\")\n",
    "                                ppsigma_ovlp=0.;pppi_ovlp=0.\n",
    "                                for l in [0,1]:\n",
    "                                    for m in [0,1]:\n",
    "                                        zeta_i=zeta_i_temp[l][0];coeff_i=zeta_i_temp[l][1]\n",
    "                                        zeta_j=zeta_j_temp[m][0];coeff_j=zeta_j_temp[m][1]\n",
    "                                        pij=0.5*(zeta_j+zeta_i)*distij\n",
    "                                        Bpij=0.5*(zeta_i-zeta_j)*distij\n",
    "                                        tij=(zeta_i-zeta_j)/(zeta_j+zeta_i)\n",
    "                                        ppsigma_ovlp+=-coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,0) \n",
    "                                        pppi_ovlp+=coeff_i*coeff_j*new_overlap(n_i,n_j,l_i,l_j,zeta_i,zeta_j,pij,tij,distij,1)\n",
    "                            overlaps_dictionary[sigma_key]=ppsigma_ovlp\n",
    "                            overlaps_dictionary[pi_key]=pppi_ovlp\n",
    "                        else:\n",
    "                            ppsigma_ovlp=overlaps_dictionary[sigma_key]\n",
    "                            pppi_ovlp=overlaps_dictionary[pi_key]\n",
    "                            \n",
    "                            #The angular overlap parameters (in terms of direction cosines) are derived in  \n",
    "                            #https://en.wikipedia.org/wiki/Tight_binding\n",
    "                        if ml_i==1:                         #px on i\n",
    "                            if ml_j==1:                 #pxpx\n",
    "                                dcovlp[i,j]=dcl**2*ppsigma_ovlp+(1-dcl**2)*pppi_ovlp\n",
    "                            elif ml_j==0:               #pxpz\n",
    "                                dcovlp[i,j]=dcl*dcn*ppsigma_ovlp-dcl*dcn*pppi_ovlp\n",
    "                            else:                                     #pxpy\n",
    "                                dcovlp[i,j]=dcl*dcm*ppsigma_ovlp-dcl*dcm*pppi_ovlp\n",
    "                        elif ml_i==0:                       #pz on i\n",
    "                            if ml_j==1:                 #pzpx\n",
    "                                dcovlp[i,j]=dcn*dcl*ppsigma_ovlp-dcn*dcl*pppi_ovlp\n",
    "                            elif ml_j==0:               #pzpz\n",
    "                                dcovlp[i,j]=dcn**2*ppsigma_ovlp+(1-dcn**2)*pppi_ovlp\n",
    "                            else:                                     #pzpy\n",
    "                                dcovlp[i,j]=dcn*dcm*ppsigma_ovlp-dcn*dcm*pppi_ovlp\n",
    "                        else:                                             #py on i\n",
    "                            if ml_j==1:                 #pypx\n",
    "                                dcovlp[i,j]=dcm*dcl*ppsigma_ovlp-dcm*dcl*pppi_ovlp\n",
    "                            elif ml_j==0:               #pypz\n",
    "                                dcovlp[i,j]=dcm*dcn*ppsigma_ovlp-dcm*dcn*pppi_ovlp\n",
    "                            else:                                     #pypy\n",
    "                                dcovlp[i,j]=dcm**2*ppsigma_ovlp+(1-dcm**2)*pppi_ovlp\n",
    "                                            #ps overlaps\n",
    "                                            #3 permutations of px,y,z\n",
    "                                            #(note need to introduce a switch to indicate whether s or p comes first)\n",
    "                                          \n",
    "                    elif (l_i==1 and l_j==0) or (l_i==0 and l_j==1):           #ps overlap\n",
    "                            #(need to test to see which of the two is the d orbital - use temp labels to avoid messing up i and j for later)    \n",
    "                        if basis_functs[i][3]==1:\n",
    "                            itemp=j;jtemp=i\n",
    "                        else:\n",
    "                            itemp=i;jtemp=j\n",
    "                        ml_p=basis_functs[jtemp][4];ml_s=basis_functs[itemp][4]\n",
    "                        zeta_p_temp=basis_functs[jtemp][6]\n",
    "                        zeta_s_temp=basis_functs[itemp][6]\n",
    "                        n_p=basis_functs[jtemp][2];l_p=basis_functs[jtemp][3]\n",
    "                        n_s=basis_functs[itemp][2];l_s=basis_functs[itemp][3]\n",
    "                        sigma_key=(1,atom_index_i,atom_index_j,l_i,l_j)\n",
    "                        pi_key=(2,atom_index_i,atom_index_j,l_i,l_j)\n",
    "                        #if sigma_key not in overlaps_dictionary:\n",
    "                        #print(\"here\")\n",
    "                        if sigma_key not in overlaps_dictionary:\n",
    "                            ps_ovlp=0.\n",
    "                            if type(zeta_s_temp[0]) is float and type(zeta_p_temp[0]) is float:                            \n",
    "                                zeta_s=zeta_s_temp[0];zeta_p=zeta_p_temp[0];coeff_s=zeta_s_temp[1];coeff_p=zeta_p_temp[1]\n",
    "                                pij=0.5*(zeta_s+zeta_p)*distij\n",
    "                                Bpij=0.5*(zeta_s-zeta_p)*distij\n",
    "                                tij=(zeta_s-zeta_p)/(zeta_s+zeta_p)                             \n",
    "                                ps_ovlp=coeff_s*coeff_p*new_overlap(n_s,n_p,l_s,l_p,zeta_s,zeta_p,pij,tij,distij,0)                # function for angle independent ps overlaps (sigma) \n",
    "                            elif type(zeta_s_temp[0]) is tuple:\n",
    "                                zeta_p=zeta_p_temp[0];coeff_p=zeta_p_temp[1]\n",
    "                                for l in [0,1]:    \n",
    "                                    zeta_s=zeta_s_temp[l][0];coeff_s=zeta_s_temp[l][1]\n",
    "                                    pij=0.5*(zeta_s+zeta_p)*distij\n",
    "                                    Bpij=0.5*(zeta_s-zeta_p)*distij\n",
    "                                    tij=(zeta_s-zeta_p)/(zeta_s+zeta_p)\n",
    "                                    ps_ovlp+=coeff_s*coeff_p*new_overlap(n_s,n_p,l_s,l_p,zeta_s,zeta_p,pij,tij,distij,0) \n",
    "                            elif type(zeta_p_temp[0]) is tuple:  \n",
    "                                zeta_s=zeta_s_temp[0];coeff_s=zeta_s_temp[1]\n",
    "                                for l in [0,1]:    \n",
    "                                    zeta_p=zeta_p_temp[l][0];coeff_p=zeta_p_temp[l][1]\n",
    "                                    pij=0.5*(zeta_s+zeta_p)*distij\n",
    "                                    Bpij=0.5*(zeta_s-zeta_p)*distij\n",
    "                                    tij=(zeta_s-zeta_p)/(zeta_s+zeta_p)\n",
    "                                    ps_ovlp+=coeff_s*coeff_p*new_overlap(n_s,n_p,l_s,l_p,zeta_s,zeta_p,pij,tij,distij,0) \n",
    "                            overlaps_dictionary[sigma_key]=ps_ovlp\n",
    "                            #if the atoms are the same, then it doesn't matter which order l_i and l_j come in.\n",
    "                            if atomic_number_i==atomic_number_j:\n",
    "                                complementary_sigma_key=(1,atom_index_j,atom_index_i,l_j,l_i)\n",
    "                                overlaps_dictionary[complementary_sigma_key]=ps_ovlp                            \n",
    "                        else:\n",
    "                            ps_ovlp=overlaps_dictionary[sigma_key]\n",
    "                        #work out which centre the p orbital is on\n",
    "                        if l_i==1:\n",
    "                            mlp=ml_i\n",
    "                        if l_j==1:\n",
    "                            mlp=ml_j\n",
    "                            ps_ovlp=-ps_ovlp                #this is the switch - along z axis, sp overlap is negative but ps is positive (pz defined positive along +z)                         \n",
    "                        if ml_p==-1:                        #pzs\n",
    "                            dcovlp[i,j]=dcm*ps_ovlp\n",
    "                                    #print(\"py s\",ovlp[i,j],dcovlp[i,j])\n",
    "                        elif ml_p==0:                       #pys\n",
    "                            dcovlp[i,j]=dcn*ps_ovlp\n",
    "                                    #print(\"pz s\",ovlp[i,j],dcovlp[i,j])\n",
    "                        elif ml_p==1:                       #px1s\n",
    "                            dcovlp[i,j]=dcl*ps_ovlp\n",
    "                                    #print(\"px s\",ovlp[i,j],dcovlp[i,j])                    \n",
    "                                            #dd overlaps\n",
    "                    \n",
    "                    elif l_i==l_j==2:                 #dd overlap  (loop over two zeta components of d) (this was a massive pain)\n",
    "                         #note in this case zeta_i, zeta_j are lists rather than just numbers\n",
    "                            sigma_key=(1,atom_index_i,atom_index_j,2,2)\n",
    "                            pi_key=(2,atom_index_i,atom_index_j,2,2)\n",
    "                            delta_key=(3,atom_index_i,atom_index_j,2,2)\n",
    "                            if sigma_key not in overlaps_dictionary:  \n",
    "                                ddsigma_ovlp=0.;ddpi_ovlp=0.;delta_ovlp=0.\n",
    "                                for k in [0,1]:    #the range is always 2 as it is a double zeta basis\n",
    "                                #extract the exponents and coefficients for each component of the double zeta basis - \n",
    "                                #these are labelled 'exponent_i, rather than 'zeta_i')\n",
    "                                    exponent_i=zeta_i_temp[k][0];coefficient_i=zeta_i_temp[k][1]                            \n",
    "                                    for l in [0,1]:    \n",
    "                                        exponent_j=zeta_j_temp[l][0];coefficient_j=zeta_j_temp[l][1]\n",
    "                                        pij=0.5*(exponent_i+exponent_j)*distij\n",
    "                                        Bpij=0.5*(exponent_i-exponent_j)*distij\n",
    "                                        tij=(exponent_i-exponent_j)/(exponent_i+exponent_j) \n",
    "                                        ddsigma_ovlp+=coefficient_i*coefficient_j*new_overlap(n_i,n_j,l_i,l_j,exponent_i,exponent_j,pij,tij,distij,0)\n",
    "                                        ddpi_ovlp-=coefficient_i*coefficient_j*new_overlap(n_i,n_j,l_i,l_j,exponent_i,exponent_j,pij,tij,distij,1)\n",
    "                                        delta_ovlp+=coefficient_i*coefficient_j*new_overlap(n_i,n_j,l_i,l_j,exponent_i,exponent_j,pij,tij,distij,2)\n",
    "                                overlaps_dictionary[sigma_key]=ddsigma_ovlp\n",
    "                                overlaps_dictionary[pi_key]=ddpi_ovlp\n",
    "                                overlaps_dictionary[delta_key]=delta_ovlp\n",
    "                            else:\n",
    "                                ddsigma_ovlp=overlaps_dictionary[sigma_key]\n",
    "                                ddpi_ovlp=overlaps_dictionary[pi_key]\n",
    "                                delta_ovlp=overlaps_dictionary[delta_key]\n",
    "                            if ml_i==0:                         #dz2 on i\n",
    "                                if ml_j==0:\n",
    "                                    dcovlp[i,j]=(dcn**2-0.5*(dcl**2+dcm**2))**2*ddsigma_ovlp+3*dcn**2*(dcl**2+dcm**2)*ddpi_ovlp+0.75*(dcl**2+dcm**2)**2*delta_ovlp\n",
    "                                 #dz2 dz2\n",
    "                                elif ml_j==2:\n",
    "                                    #dcovlp[i,j]=3**0.5*((dcl**2-dcm**2)*(dcn**2-(dcl**2+dcm**2)*0.5)*ddsigma_ovlp/2+dcn**2*(dcm**2-dcl**2)*ddpi_ovlp+(1+dcn**2)*0.25*(dcl**2-dcm**2)*delta_ovlp)                                    \n",
    "                                    dcovlp[i,j]=0.5*3**0.5*(dcl**2-dcm**2)*(dcn**2-0.5*(dcl**2+dcm**2))*ddsigma_ovlp+3**0.5*dcn**2*(dcm**2-dcl**2)*ddpi_ovlp+0.25*3**0.5*(1+dcn**2)*(dcl**2-dcm**2)*delta_ovlp\n",
    "                                    #dz2 dx2-y2\n",
    "                                elif ml_j==-2:\n",
    "                                    dcovlp[i,j]=3**0.5*(dcl*dcm*(dcn**2-(dcl**2+dcm**2)*0.5)*ddsigma_ovlp-2*dcl*dcm*dcn**2*ddpi_ovlp+0.5*dcl*dcm*(1+dcn**2)*delta_ovlp)\n",
    "                                    #dz2 dxy\n",
    "                                elif ml_j==1:\n",
    "                                    dcovlp[i,j]=3**0.5*(dcl*dcn*(dcn**2-(dcl**2+dcm**2)*0.5)*ddsigma_ovlp+dcl*dcn*(dcl**2+dcm**2-dcn**2)*ddpi_ovlp-0.5*dcl*dcn*(dcl**2+dcm**2)*delta_ovlp)\n",
    "                                    #dz2 dxz\"\n",
    "                                elif ml_j==-1:\n",
    "                                    dcovlp[i,j]=3**0.5*(dcm*dcn*(dcn**2-(dcl**2+dcm**2)*0.5)*ddsigma_ovlp+dcm*dcn*(dcl**2+dcm**2-dcn**2)*ddpi_ovlp-0.5*dcm*dcn*(dcl**2+dcm**2)*delta_ovlp)\n",
    "                                    #dz2 dyz\n",
    "                            elif ml_i==1:\n",
    "                                if ml_j==1:\n",
    "                                    dcovlp[i,j]=3*dcl**2*dcn**2*ddsigma_ovlp+(dcl**2+dcn**2-4*dcl**2*dcn**2)*ddpi_ovlp+(dcm**2+dcl**2*dcn**2)*delta_ovlp\n",
    "                                    #dxz dxz\n",
    "                                elif ml_j==-2:\n",
    "                                    dcovlp[i,j]=3*dcm*dcl**2*dcn*ddsigma_ovlp+dcm*dcn*(1-4*dcl**2)*ddpi_ovlp+dcm*dcn*(dcl**2-1)*delta_ovlp\n",
    "                                    #print(\"dxz dxy\",dcovlp[i,j])\n",
    "                                elif ml_j==2:\n",
    "                                    dcovlp[i,j]=1.5*dcn*dcl*(dcl**2-dcm**2)*ddsigma_ovlp+dcn*dcl*(1-2*(dcl**2-dcm**2))*ddpi_ovlp-dcn*dcl*(1-0.5*(dcl**2-dcm**2))*delta_ovlp\n",
    "                                    #dxz dx2-y2\n",
    "                                elif ml_j==0:\n",
    "                                    dcovlp[i,j]=3**0.5*dcl*dcn*(dcn**2-0.5*(dcl**2+dcm**2))*ddsigma_ovlp+3**0.5*dcl*dcn*(dcl**2+dcm**2-dcn**2)*ddpi_ovlp-0.5*3**0.5*dcl*dcn*(dcl**2+dcm**2)*delta_ovlp\n",
    "                                    #dxz dz2\n",
    "                                elif ml_j==-1:\n",
    "                                    dcovlp[i,j]=3*dcm*dcn**2*dcl*ddsigma_ovlp+dcm*dcl*(1-4*dcn**2)*ddpi_ovlp+dcm*dcl*(dcn**2-1)*delta_ovlp\n",
    "                                    #dxz dyz\n",
    "                            elif ml_i==-1:\n",
    "                                if ml_j==-1:\n",
    "                                    dcovlp[i,j]=3*dcm**2*dcn**2*ddsigma_ovlp+(dcm**2+dcn**2-4*dcm**2*dcn**2)*ddpi_ovlp+(dcl**2+dcm**2*dcn**2)*delta_ovlp\n",
    "                                    #print(\"dyz dyz\",dcovlp[i,j])\n",
    "                                elif ml_j==-2:\n",
    "                                    dcovlp[i,j]=3*dcl*dcm**2*dcn*ddsigma_ovlp+dcl*dcn*(1-4*dcm**2)*ddpi_ovlp+dcl*dcn*(dcm**2-1)*delta_ovlp\n",
    "                                    #print(\"dyz dxy\",dcovlp[i,j])\n",
    "                                elif ml_j==2:\n",
    "                                    dcovlp[i,j]=1.5*dcm*dcn*(dcl**2-dcm**2)*ddsigma_ovlp-dcm*dcn*(1+2*(dcl**2-dcm**2))*ddpi_ovlp+dcm*dcn*(1+0.5*(dcl**2-dcm**2))*delta_ovlp\n",
    "                                    #print(\"dyz dx2-y2\",dcovlp[i,j])\n",
    "                                elif ml_j==0:\n",
    "                                    dcovlp[i,j]=3**0.5*(dcm*dcn*(dcn**2-(dcl**2+dcm**2)*0.5)*ddsigma_ovlp+dcm*dcn*(dcl**2+dcm**2-dcn**2)*ddpi_ovlp-0.5*dcm*dcn*(dcl**2+dcm**2)*delta_ovlp)\n",
    "                                    #print(\"dyz dz2\",dcovlp[i,j])\n",
    "                                elif ml_j==1:\n",
    "                                    dcovlp[i,j]=3*dcm*dcn**2*dcl*ddsigma_ovlp+dcm*dcl*(1-4*dcn**2)*ddpi_ovlp+dcm*dcl*(dcn**2-1)*delta_ovlp\n",
    "                                    #print(\"dyz dxz\",dcovlp[i,j])\n",
    "                            elif ml_i==-2:\n",
    "                                if ml_j==-2:\n",
    "                                    dcovlp[i,j]=3*dcl**2*dcm**2*ddsigma_ovlp+(dcl**2+dcm**2-4*dcl**2*dcm**2)*ddpi_ovlp+(dcn**2+dcl**2*dcm**2)*delta_ovlp\n",
    "                                    #print(dcl,dcm,dcn,ddsigma_ovlp,ddpi_ovlp,delta_ovlp)                                    \n",
    "                                    #print(\"dxy dxy\",dcovlp[i,j])\n",
    "                                elif ml_j==-1:\n",
    "                                    dcovlp[i,j]=3*dcl*dcm**2*dcn*ddsigma_ovlp+dcl*dcn*(1-4*dcm**2)*ddpi_ovlp+dcl*dcn*(dcm**2-1)*delta_ovlp\n",
    "                                    #print(\"dxy dyz\",dcovlp[i,j])\n",
    "                                elif ml_j==1:\n",
    "                                    dcovlp[i,j]=3*dcm*dcl**2*dcn*ddsigma_ovlp+dcm*dcn*(1-4*dcl**2)*ddpi_ovlp+dcm*dcn*(dcl**2-1)*delta_ovlp\n",
    "                                    #print(\"dxy dxz\",dcovlp[i,j])\n",
    "                                elif ml_j==0:\n",
    "                                    dcovlp[i,j]=3**0.5*(dcl*dcm*(dcn**2-(dcl**2+dcm**2)/2)*ddsigma_ovlp-2*dcl*dcm*dcn**2*ddpi_ovlp+0.5*dcl*dcm*(1+dcn**2)*delta_ovlp)\n",
    "                                    #print(\"dxy dz2\",dcovlp[i,j])\n",
    "                                elif ml_j==2:\n",
    "                                    dcovlp[i,j]=1.5*dcl*dcm*(dcl**2-dcm**2)*ddsigma_ovlp+2*dcl*dcm*(dcm**2-dcl**2)*ddpi_ovlp+0.5*dcl*dcm*(dcl**2-dcm**2)*delta_ovlp\n",
    "                                    #print(\"dxy dx2-y2\",dcovlp[i,j])\n",
    "                            elif ml_i==2:\n",
    "                                if ml_j==2:\n",
    "                                    dcovlp[i,j]=0.75*(dcl**2-dcm**2)**2*ddsigma_ovlp+(dcl**2+dcm**2-(dcl**2-dcm**2)**2)*ddpi_ovlp+(dcn**2+0.25*(dcl**2-dcm**2)**2)*delta_ovlp\n",
    "                                    #print(\"dx2-y2 dx2-y2\",dcovlp[i,j])\n",
    "                                elif ml_j==-2:\n",
    "                                    dcovlp[i,j]=1.5*dcl*dcm*(dcl**2-dcm**2)*ddsigma_ovlp+2*dcl*dcm*(dcm**2-dcl**2)*ddpi_ovlp+0.5*dcl*dcm*(dcl**2-dcm**2)*delta_ovlp\n",
    "                                    #print(\"dx2-y2 dxy \",dcovlp[i,j])\n",
    "                                elif ml_j==-1:\n",
    "                                    dcovlp[i,j]=1.5*dcm*dcn*(dcl**2-dcm**2)*ddsigma_ovlp-dcm*dcn*(1+2*(dcl**2-dcm**2))*ddpi_ovlp+dcm*dcn*(1+0.5*(dcl**2-dcm**2))*delta_ovlp\n",
    "                                    #print(\"dx2-y2 dyz \",dcovlp[i,j])\n",
    "                                elif ml_j==1:\n",
    "                                    dcovlp[i,j]=1.5*dcn*dcl*(dcl**2-dcm**2)*ddsigma_ovlp+dcn*dcl*(1-2*(dcl**2-dcm**2))*ddpi_ovlp-dcn*dcl*(1-0.5*(dcl**2-dcm**2))*delta_ovlp\n",
    "                                    #print(\"dx2-y2 dxz\",dcovlp[i,j])\n",
    "                                elif ml_j==0:\n",
    "                                    dcovlp[i,j]=0.5*3**0.5*(dcl**2-dcm**2)*(dcn**2-0.5*(dcl**2+dcm**2))*ddsigma_ovlp+3**0.5*dcn**2*(dcm**2-dcl**2)*ddpi_ovlp+0.25*3**0.5*(1+dcn**2)*(dcl**2-dcm**2)*delta_ovlp\n",
    "                                    #print(\"dx2-y2 dz2\",dcovlp[i,j])\n",
    "                           #sd overlaps\n",
    "                                \n",
    "                    elif (l_i==0 and l_j==2) or (l_i==2 and l_j==0):\n",
    "                            #(need to test to see which of the two is the d orbital - use temp labels to avoid messing up i and j for later) \n",
    "                            if basis_functs[i][3]==2:\n",
    "                                itemp=j;jtemp=i\n",
    "                            else:\n",
    "                                itemp=i;jtemp=j\n",
    "                            #identify the quantum numbers and exponents (note again zeta_d is a list, not a number)\n",
    "                            ml_d=basis_functs[jtemp][4]   #ml for the d orbital \n",
    "                            zeta_d=basis_functs[jtemp][6];zeta_s_temp=basis_functs[itemp][6]\n",
    "                            n_d=basis_functs[jtemp][2];l_d=basis_functs[jtemp][3]\n",
    "                            n_s=basis_functs[itemp][2];l_s=basis_functs[itemp][3]\n",
    "                            zeta_s=zeta_s_temp[0];coeff_s=zeta_s_temp[1]\n",
    "                            #print(\"Qu numbers\",n_s,n_d,l_s,l_d)\n",
    "                            #loop over components of d orbital]\n",
    "                            sigma_key=(1,atom_index_i,atom_index_j,l_i,l_j)\n",
    "                            #pi_key=(2,atom_index_i,atom_index_j,l_i,l_j)\n",
    "                            if sigma_key not in overlaps_dictionary:\n",
    "                                sdsigma_ovlp=0.\n",
    "                                #print(\"not in dict\",i,j,sigma_key)\n",
    "                                for k in [0,1]:\n",
    "                                    exponent_d=zeta_d[k][0];coefficient_d=zeta_d[k][1]\n",
    "                                    pij=0.5*(zeta_s+exponent_d)*distij\n",
    "                                    Bpij=0.5*(zeta_s-exponent_d)*distij\n",
    "                                    tij=(zeta_s-exponent_d)/(zeta_s+exponent_d)\n",
    "                                    sdsigma_ovlp+=coefficient_d*new_overlap(n_s,n_d,l_s,l_d,zeta_s,exponent_d,pij,tij,distij,0) #m=0\n",
    "                                overlaps_dictionary[sigma_key]=sdsigma_ovlp\n",
    "                                if atomic_number_i==atomic_number_j:\n",
    "                                    complementary_sigma_key=(1,atom_index_j,atom_index_i,l_j,l_i)\n",
    "                                    overlaps_dictionary[complementary_sigma_key]=sdsigma_ovlp   \n",
    "                            else:\n",
    "                                sdsigma_ovlp=overlaps_dictionary[sigma_key]    \n",
    "                            #deal with angular dependence\n",
    "                            if ml_d==0:\n",
    "                                dcovlp[i,j]=sdsigma_ovlp*(dcn**2-0.5*(dcl**2+dcm**2))\n",
    "                                #print(\"dz2 s\",ovlp[i,j],dcovlp[i,j])\n",
    "                            elif ml_d==2:\n",
    "                                dcovlp[i,j]=3**0.5*(dcl**2-dcm**2)*sdsigma_ovlp/2\n",
    "                                #print(\"dx2-y2 s\",ovlp[i,j],dcovlp[i,j])\n",
    "                            elif ml_d==-2:\n",
    "                                dcovlp[i,j]=3**0.5*dcl*dcm*sdsigma_ovlp\n",
    "                                #print(\"dxy s\",ovlp[i,j],dcovlp[i,j])\n",
    "                            elif ml_d==1:\n",
    "                                dcovlp[i,j]=3**0.5*dcl*dcn*sdsigma_ovlp\n",
    "                                #print(\"dxz s\",ovlp[i,j],dcovlp[i,j])                                \n",
    "                                #print(\"dxz s\",ovlp[i,j])\n",
    "                            elif ml_d==-1:\n",
    "                                dcovlp[i,j]=3**0.5*dcm*dcn*sdsigma_ovlp\n",
    "                                #print(\"dyz s\",ovlp[i,j],dcovlp[i,j])                                 \n",
    "                             #print(\"dyz s\",ovlp[i,j])\n",
    "                            dcovlp[i,j]=coeff_s*dcovlp[i,j]   \n",
    "                            \n",
    "                                                #pd overlaps    note we need switches again to change sign of ovlp depending on which comes first\n",
    "                                \n",
    "                    elif (l_i==2 and l_j==1) or (l_i==1 and l_j==2):\n",
    "                        #print(\"pd\",i,j)\n",
    "                            #(need to test to see which of the two is the d orbital - use temp labels to avoid messing up i and j for later)    \n",
    "                        if basis_functs[i][3]==2:\n",
    "                                #print(\"here\",i,j)\n",
    "                            itemp=j;jtemp=i\n",
    "                        else:\n",
    "                            itemp=i;jtemp=j\n",
    "                                #print(i,j)\n",
    "                        ml_d=basis_functs[jtemp][4];ml_p=basis_functs[itemp][4]   \n",
    "                        zeta_d=basis_functs[jtemp][6]\n",
    "                        zeta_p_temp=basis_functs[itemp][6]\n",
    "                        n_d=basis_functs[jtemp][2];l_d=basis_functs[jtemp][3]\n",
    "                        n_p=basis_functs[itemp][2];l_p=basis_functs[itemp][3]\n",
    "                        sigma_key=(1,atom_index_i,atom_index_j,l_i,l_j)\n",
    "                        pi_key=(2,atom_index_i,atom_index_j,l_i,l_j)\n",
    "                        if sigma_key not in overlaps_dictionary:\n",
    "                            #print(\"not in dict\",i,j,sigma_key)\n",
    "                            pdsigma_ovlp=0.;pdpi_ovlp=0.\n",
    "                            if type(zeta_p_temp[0]) is float:   \n",
    "                                zeta_p=zeta_p_temp[0];coeff_p=zeta_p_temp[1]\n",
    "                            #loop over components of d orbital\n",
    "                                for k in [0,1]:\n",
    "                                    exponent_d=zeta_d[k][0];coeff_d=zeta_d[k][1]\n",
    "                                    #print(\"single pd params\",exponent_d,zeta_p,coeff_d,coeff_p)\n",
    "                                    pij=0.5*(zeta_p+exponent_d)*distij\n",
    "                                    Bpij=0.5*(zeta_p-exponent_d)*distij\n",
    "                                    tij=(zeta_p-exponent_d)/(zeta_p+exponent_d)\n",
    "                                    pdsigma_ovlp+=coeff_p*coeff_d*new_overlap(n_p,n_d,l_p,l_d,zeta_p,exponent_d,pij,tij,distij,0) #m=0\n",
    "                                    pdpi_ovlp+=coeff_p*coeff_d*new_overlap(n_p,n_d,l_p,l_d,zeta_p,exponent_d,pij,tij,distij,1) #m=0\n",
    "                            elif type(zeta_p_temp[0]) is tuple:\n",
    "                                for k in [0,1]:\n",
    "                                    for l in [0,1]:\n",
    "                                        exponent_d=zeta_d[k][0];coeff_d=zeta_d[k][1]\n",
    "                                        zeta_p=zeta_p_temp[l][0];coeff_p=zeta_p_temp[l][1]\n",
    "                                        pij=0.5*(zeta_p+exponent_d)*distij\n",
    "                                        Bpij=0.5*(zeta_p-exponent_d)*distij\n",
    "                                        tij=(zeta_p-exponent_d)/(zeta_p+exponent_d)\n",
    "                                        pdsigma_ovlp+=coeff_p*coeff_d*new_overlap(n_p,n_d,l_p,l_d,zeta_p,exponent_d,pij,tij,distij,0) #m=0\n",
    "                                        pdpi_ovlp+=coeff_p*coeff_d*new_overlap(n_p,n_d,l_p,l_d,zeta_p,exponent_d,pij,tij,distij,1) #m=0 \n",
    "                            overlaps_dictionary[sigma_key]=pdsigma_ovlp\n",
    "                            overlaps_dictionary[pi_key]=pdpi_ovlp\n",
    "                            if atomic_number_i==atomic_number_j:\n",
    "                                complementary_sigma_key=(1,atom_index_j,atom_index_i,l_j,l_i)\n",
    "                                complementary_pi_key=(2,atom_index_j,atom_index_i,l_j,l_i)\n",
    "                                overlaps_dictionary[complementary_sigma_key]=pdsigma_ovlp\n",
    "                                overlaps_dictionary[complementary_pi_key]=pdpi_ovlp \n",
    "                        else:\n",
    "                            pdsigma_ovlp=overlaps_dictionary[sigma_key]\n",
    "                            pdpi_ovlp=overlaps_dictionary[pi_key]\n",
    "                        if l_i==2:  \n",
    "                            pdsigma_ovlp=-pdsigma_ovlp          #this is the switch - along z axis, dp sigma overlap is negative but pd is positive (pz defined positive along +z)\n",
    "                        if l_j==2:         #swap ml indices if d comes second in list                               \n",
    "                            pdpi_ovlp=-pdpi_ovlp                #this is the switch - along z axis, dp pi overlap is positive but pd is negative (pz defined positive along +z)                        \n",
    "                            #now deal with angular variations                            \n",
    "                            #5 x 3 = 15 possible combinations of d x p\n",
    "                        if ml_d==0 and ml_p==0:\n",
    "                            dcovlp[i,j]=dcn*(dcn**2-0.5*(dcl**2+dcm**2))*pdsigma_ovlp+3**0.5*dcn*(dcl**2+dcm**2)*pdpi_ovlp\n",
    "                                #print(\"dz2 pz\",dcovlp[i,j])\n",
    "                        elif ml_d==0 and ml_p==1:\n",
    "                            dcovlp[i,j]=dcl*(dcn**2-0.5*(dcl**2+dcm**2))*pdsigma_ovlp-3**0.5*dcl*dcn**2*pdpi_ovlp\n",
    "                                #print(\"dz2 px\",dcovlp[i,j],dcovlp[i,j])\n",
    "                        elif ml_d==0 and ml_p==-1:\n",
    "                            dcovlp[i,j]=dcm*(dcn**2-0.5*(dcl**2+dcm**2))*pdsigma_ovlp-3**0.5*dcm*dcn**2*pdpi_ovlp\n",
    "                                #print(\"dz2 py\",dcovlp[i,j],dcovlp[i,j])\n",
    "                        elif ml_d==1 and ml_p==0:\n",
    "                            dcovlp[i,j]=3**0.5*dcn**2*dcl*pdsigma_ovlp+dcl*(1-2*dcn**2)*pdpi_ovlp\n",
    "                                #print(\"dxz pz\",dcovlp[i,j],dcovlp[i,j])\n",
    "                        elif ml_d==1 and ml_p==1:\n",
    "                            dcovlp[i,j]=3**0.5*dcl**2*dcn*pdsigma_ovlp+dcn*(1-2*dcl**2)*pdpi_ovlp\n",
    "                                #print(\"dxz px\",ovlp[i,j],dcovlp[i,j])                                \n",
    "                                #print(\"dxz px\",dcovlp[i,j])\n",
    "                        elif ml_d==1 and ml_p==-1:\n",
    "                            dcovlp[i,j]=3**0.5*dcl*dcm*dcn*pdsigma_ovlp-2*dcl*dcm*dcn*pdpi_ovlp\n",
    "                                #print(\"dxz py\",dcovlp[i,j],dcovlp[i,j])  \n",
    "                        elif ml_d==-1 and ml_p==0:\n",
    "                            dcovlp[i,j]=3**0.5*dcn**2*dcm*pdsigma_ovlp+dcm*(1-2*dcn**2)*pdpi_ovlp\n",
    "                                #print(\"dyz pz\",dcovlp[i,j],dcovlp[i,j])           \n",
    "                        elif ml_d==-1 and ml_p==1:\n",
    "                            dcovlp[i,j]=3**0.5*dcl*dcm*dcn*pdsigma_ovlp-2*dcl*dcm*dcn*pdpi_ovlp\n",
    "                                #print(\"dyz px\",dcovlp[i,j],dcovlp[i,j])\n",
    "                        elif ml_d==-1 and ml_p==-1:\n",
    "                            dcovlp[i,j]=3**0.5*dcm**2*dcn*pdsigma_ovlp+dcn*(1-2*dcm**2)*pdpi_ovlp\n",
    "                                #print(\"dyz py\",dcovlp[i,j],dcovlp[i,j])  \n",
    "                        elif ml_d==2 and ml_p==0:\n",
    "                            dcovlp[i,j]=3**0.5*dcn*(dcl**2-dcm**2)*pdsigma_ovlp/2-dcn*(dcl**2-dcm**2)*pdpi_ovlp\n",
    "                                #print(\"dx2-y2 pz\",dcovlp[i,j],dcovlp[i,j]) \n",
    "                        elif ml_d==2 and ml_p==1:\n",
    "                            dcovlp[i,j]=3**0.5*dcl*(dcl**2-dcm**2)*pdsigma_ovlp/2+dcl*(1-dcl**2+dcm**2)*pdpi_ovlp\n",
    "                                #print(\"dx2-y2 px\",dcovlp[i,j],dcovlp[i,j])\n",
    "                        elif ml_d==2 and ml_p==-1:\n",
    "                            dcovlp[i,j]=3**0.5*dcm*(dcl**2-dcm**2)*pdsigma_ovlp/2-dcm*(1-dcm**2+dcl**2)*pdpi_ovlp\n",
    "                                #print(\"dx2-y2 py\",ovlp[i,j],dcovlp[i,j])\n",
    "                                #print(\"dx2-y2 py\",dcovlp[i,j])\n",
    "                        elif ml_d==-2 and ml_p==0:\n",
    "                            dcovlp[i,j]=3**0.5*dcl*dcm*dcn*pdsigma_ovlp-2*dcl*dcm*dcn*pdpi_ovlp\n",
    "                                #print(\"dxy pz\",dcovlp[i,j])                                \n",
    "                                #print(\"dxy pz\",dcovlp[i,j])\n",
    "                        elif ml_d==-2 and ml_p==1:           \n",
    "                            dcovlp[i,j]=3**0.5*dcl**2*dcm*pdsigma_ovlp+dcm*(1-2*dcl**2)*pdpi_ovlp\n",
    "                                #print(\"dxy px\",dcovlp[i,j])\n",
    "                                #print(\"dxy px\",ovlp[i,j])\n",
    "                        elif ml_d==-2 and ml_p==-1:\n",
    "                            dcovlp[i,j]=3**0.5*dcm**2*dcl*pdsigma_ovlp+dcl*(1-2*dcm**2)*pdpi_ovlp\n",
    "                                #print(\"dxy py\",dcovlp[i,j],dcovlp[i,j])\n",
    "                        dcovlp[i,j]=dcovlp[i,j]\n",
    "\n",
    "\n",
    "    for i in range(len(basis_functs)):                                      #copy the upper half to the lower half of ovlp\n",
    "        for j in range(len(basis_functs)):\n",
    "                if j<i:\n",
    "                        dcovlp[i,j]=dcovlp[j,i]\n",
    "    #this is the overlap matrix complete\n",
    "    return dcovlp\n",
    "\n",
    "def Hamiltonian_matrix(basis_functs,ovlp,WH):    \n",
    "    H=np.identity(len(basis_functs))    #   initialise Hamiltonian matrix\n",
    "    for i in range(len(basis_functs)):\n",
    "        for j in range(len(basis_functs)):\n",
    "            Hii_i=basis_functs[i][5];Hii_j=basis_functs[j][5]\n",
    "            if i==j:\n",
    "                H[i,i]=Hii_i\n",
    "            else:\n",
    "                H[i,j]=0.5*WH*(Hii_i+Hii_j)*ovlp[i,j]                   #Wolfsberg Helmoltz formula with K = 1.75\n",
    "    return H\n",
    " \n",
    " \n",
    " \n",
    "#standard diagonalisation for the generalised eigenvalue problem \n",
    "def diagonalise(H,ovlp,no_electrons):\n",
    "    e,v=linalg.eigh(H,ovlp)    \n",
    "    vtrans=np.transpose(v)                                  #transpose eigenvectors to row format\n",
    "#normalise eigenvectors:\n",
    "    #must be a better way to do this\n",
    "    norm=np.zeros((1,len(vtrans)),dtype=float)              \n",
    "    normvtrans=np.zeros((len(vtrans),len(vtrans)))\n",
    "    for k in range(len(vtrans)):                            #sum over all MOs\n",
    "        for i in range(len(vtrans)):                    #sum over first index\n",
    "                for j in range(len(vtrans)):            #sum over second index\n",
    "                        norm[0][k]=norm[0][k]+vtrans[k,i]*vtrans[k,j]*ovlp[i,j]\n",
    "        normvtrans[k]=vtrans[k]*(1/(norm[0][k])**0.5)\n",
    "\n",
    "    normv=np.transpose(normvtrans)                          #transpose back to column format once they are normalised\n",
    "#sort normalised eigenvectors\n",
    "    eref=np.argsort(e)                                      #indices for sorting eigenvectors\n",
    "    e=np.sort(e)                                            # sort eigenvalues\n",
    "    e=e.real\n",
    "    for i in range (len(e)):                                # format eigenvalues\n",
    "        e[i]='{:4.3f}'.format(e[i])\n",
    "        \n",
    "    eigsort=np.zeros((len(e),len(e)),dtype=float)           #generate list of eigenvectors in ascending order of eigenvalue\n",
    "\n",
    "    for i in range(len(e)):\n",
    "        for j in range(len(e)):\n",
    "                eigsort[i,j]='{:6.5f}'.format(normv[i,eref[j]])\n",
    "\n",
    "#generate occupation numbers\n",
    "    occupations=np.zeros((1,len(normv)),dtype=float)        \n",
    "    electrons=0.0                           \n",
    "    for i in range(len(e)):\n",
    "        if electrons==no_electrons-1:\n",
    "            occupations[0,i]='{:3.2f}'.format(1.0)\n",
    "            electrons+=1.0\n",
    "        elif electrons<no_electrons:\n",
    "            occupations[0,i]='{:3.2f}'.format(2.0)\n",
    "            electrons+=2.0\n",
    "    #print(\"occ\",occupations)\n",
    "    return eigsort,e,occupations \n",
    " \n",
    " \n",
    " \n",
    "#this is only needed for periodic calculations \n",
    "def diagonalise_periodic(H,ovlp,no_electrons):\n",
    "    e,v=scipy.linalg.eigh(H,ovlp)                                  # diagonalise matrix\n",
    "    vtrans=np.transpose(v)                                  #transpose eigenvectors to row format\n",
    "\n",
    "#normalise eigenvectors:\n",
    "#    norm=np.zeros((1,len(vtrans)),dtype=float)              \n",
    "#    normvtrans=np.zeros((len(vtrans),len(vtrans)))\n",
    "#    for k in range(len(vtrans)):                            #sum over all MOs\n",
    "#        for i in range(len(vtrans)):                    #sum over first index\n",
    "#                for j in range(len(vtrans)):            #sum over second index\n",
    "#                    norm[0][k]=norm[0][k]+vtrans[k,i].conjugate()*vtrans[k,j]*ovlp[i,j]\n",
    "#                \n",
    "#        print(k,norm[0][k])\n",
    "#        normvtrans[k]=vtrans[k]*(1/(norm[0][k])**0.5)\n",
    "#\n",
    "#    normv=np.transpose(normvtrans)                          #transpose back to column format once they are normalised\n",
    "#    print(normv)\n",
    "##sort normalised eigenvectors\n",
    "    eref=np.argsort(e)                                      #indices for sorting eigenvectors\n",
    "    e=np.sort(e)                                            # sort eigenvalues\n",
    "    e=e.real\n",
    "    for i in range (len(e)):                                # format eigenvalues\n",
    "        e[i]='{:4.3f}'.format(e[i])\n",
    "    #    \n",
    "    eigsort=np.zeros((len(e),len(e)),dtype=complex)           #generate list of eigenvectors in ascending order of eigenvalue#\n",
    "\n",
    "    for i in range(len(e)):\n",
    "        for j in range(len(e)):\n",
    "                eigsort[i,j]=v[i,eref[j]]\n",
    "\n",
    "#generate occupation numbers\n",
    "    occupations=np.zeros((1,len(e)),dtype=float)        \n",
    "    electrons=0.0                           \n",
    "    for i in range(len(e)):\n",
    "        if electrons==no_electrons-1:\n",
    "            occupations[0,i]='{:3.2f}'.format(1.0)\n",
    "            electrons+=1.0\n",
    "        elif electrons<no_electrons:\n",
    "            occupations[0,i]='{:3.2f}'.format(2.0)\n",
    "            electrons+=2.0\n",
    "\n",
    "    return eigsort,e,occupations\n",
    "\n",
    "#Mulliken population analysis\n",
    "def EH_mulliken(eigsort,occupations,ovlp):     \n",
    "    Mulliken=np.zeros((len(eigsort),len(eigsort)),dtype=float)  # initialise Mulliken matrix\n",
    "    reduced_Mulliken=np.zeros((len(eigsort),len(eigsort)),dtype=float)  # initialise Mulliken matrix\n",
    "    for k in range(len(eigsort)):                             #sum over MOs\n",
    "        for i in range(len(eigsort)):                     # sum over first index\n",
    "                for j in range(len(eigsort)):             #sum over second index\n",
    "                        reduced_Mulliken[i,j]='{:3.5f}'.format(Mulliken[i,j]+eigsort[i,k]*eigsort[j,k]*ovlp[i,j]*occupations[0,k])\n",
    "                        Mulliken[i,j]='{:3.5f}'.format(Mulliken[i,j]+eigsort[i,k]*eigsort[j,k]*ovlp[i,j]*occupations[0,k])\n",
    "\n",
    "    #reduced_Mulliken=Mulliken.copy()                        # initialise reduced Mulliken matrix\n",
    "\n",
    "    for i in range(len(eigsort)):\n",
    "        for j in range(len(eigsort)):\n",
    "                if j!=i:\n",
    "                        reduced_Mulliken[i,i]='{:3.5f}'.format(reduced_Mulliken[i,i]+Mulliken[i,j])\n",
    "\n",
    "    total_pop=np.trace(reduced_Mulliken)\n",
    "    return Mulliken,reduced_Mulliken,total_pop\n",
    "\n",
    "def contributions_to_PDOS(v,occupations,ovlp,plot_COOP):\n",
    "    contributions=[];coop=[]\n",
    "    for i in range(len(v)):\n",
    "        contributions.append(np.zeros(len(v)))\n",
    "        coop.append(np.empty((len(v),len(v))))\n",
    "    #Mulliken=np.zeros((len(v),len(v)),dtype=complex)  # initialise Mulliken matrix\n",
    "    #reduced_Mulliken=np.zeros((len(v),len(v)),dtype=complex)  # initialise Mulliken matrix\n",
    "    #print(\"v\",v)\n",
    "    for k in range(len(v)):                             #sum over MOs\n",
    "        for i in range(len(v)):\n",
    "            cont=0.\n",
    "            for j in range(len(v)):\n",
    "                cont+=np.real(np.conj(v[i,k])*v[j,k]*ovlp[i,j])                    # sum over first index\n",
    "            contributions[k][i]=cont\n",
    "    if plot_COOP:\n",
    "        for k in range(len(v)):                             #sum over MOs\n",
    "            for i in range(len(v)):\n",
    "                for j in range(len(v)):\n",
    "                    coop[k][i,j]=np.real(np.conj(v[i,k])*v[j,k]*ovlp[i,j])                   # sum over first index\n",
    "        #print(\"sums\",k,sum(contributions[k]))\n",
    "    #print(\"coop0\",coop[0])\n",
    "    return contributions,coop\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_fcc_structure(a0,atoms,coords):\n",
    "    a=np.asarray([a0/2,a0/2,0.]);b=np.asarray([0.,a0/2,a0/2]);c=np.asarray([a0/2,0.,a0/2])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],a0*coordinate[1],a0*coordinate[2]]) \n",
    "    #print(\"lattice vectors\",a,b,c)\n",
    "    return atoms_temp,a,b,c,coords_temp\n",
    "\n",
    "def generate_bcc_structure(a0,atoms,coords):\n",
    "    a=np.asarray([-a0/2,a0/2,a0/2]);b=np.asarray([a0/2,-a0/2,a0/2]);c=np.asarray([a0/2,a0/2,-a0/2])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],a0*coordinate[1],a0*coordinate[2]])        \n",
    "    return atoms_temp,a,b,c,coords_temp   \n",
    "\n",
    "def generate_primitive_cubic_structure(a0,atoms,coords):\n",
    "    a=np.asarray([a0,0.,0.]);b=np.asarray([0.,a0,0.]);c=np.asarray([0.,0.,a0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],a0*coordinate[1],a0*coordinate[2]])        \n",
    "    return atoms_temp,a,b,c,coords_temp       \n",
    "\n",
    "def generate_primitive_tetragonal_structure(a0,c0,atoms,coords):\n",
    "    a=np.asarray([a0,0.,0.]);b=np.asarray([0.,a0,0.]);c=np.asarray([0.,0.,c0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],a0*coordinate[1],c0*coordinate[2]])        \n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "\n",
    "def generate_bc_tetragonal_structure(a0,c0,atoms,coords):\n",
    "    a=np.asarray([a0/2,0.,0.]);b=np.asarray([0.,a0/2,0.]);c=np.asarray([0.,0.,c0/2])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],a0*coordinate[1],c0*coordinate[2]])   \n",
    "    return atoms_temp,a,b,c,coords_temp  \n",
    "\n",
    "def generate_primitive_orthorhombic_structure(a0,b0,c0,atoms,coords):\n",
    "    a=np.asarray([a0,0.,0.]);b=np.asarray([0.,b0,0.]);c=np.asarray([0.,0.,c0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],b0*coordinate[1],c0*coordinate[2]])        \n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "    \n",
    "def generate_bc_orthorhombic_structure(a0,b0,c0,atoms,coords):\n",
    "    a=np.asarray([a0/2,0.,0.]);b=np.asarray([0.,b0/2,0.]);c=np.asarray([0.,0.,c0/2])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],b0*coordinate[1],c0*coordinate[2]]) \n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "\n",
    "def generate_fc_orthorhombic_structure(a0,b0,c0,atoms,coords):\n",
    "    a=np.asarray([a0,0.,0.]);b=np.asarray([0.,b0,0.]);c=np.asarray([0.,0.,c0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],b0*coordinate[1],c0*coordinate[2]])                 \n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "\n",
    "def generate_ec_orthorhombic_structure(a0,b0,c0,atoms,coords):     #end centred lattoce\n",
    "    a=np.asarray([a0,0.,0.]);b=np.asarray([0.,b0,0.]);c=np.asarray([0.,0.,c0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],b0*coordinate[1],c0*coordinate[2]])                 \n",
    "        coords_temp.append([a0*(coordinate[0]+0.5),b0*(coordinate[1]+0.5),a0*coordinate[2]])\n",
    "    return atoms_temp,a,b,c,coords_temp   \n",
    "     \n",
    "def generate_hexagonal_structure(a0,c0,atoms,coords):\n",
    "    b=np.asarray([-a0/2,np.sqrt(3)*a0/2,0.]);a=np.asarray([a0,0.,0.]);c=np.asarray([0.,0.,c0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coord_gena=[coordinate[0]*i for i in a];coord_genb=[coordinate[1]*i for i in b];coord_genc=[coordinate[2]*i for i in c]\n",
    "        #coord_gen=[i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)]        \n",
    "        coords_temp.append([i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)])   \n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "#determines symmetry of lattice and displacement vectors for nearest neighbours\n",
    "\n",
    "def generate_monoclinic_structure(a0,b0,c0,beta,atoms,coords):\n",
    "    beta=np.pi*(beta/180)\n",
    "    a=np.asarray([0.,0.,-a0]);b=np.asarray([-b0,0.,0.]);c=np.asarray([0.,c0*np.sin(beta),-c0*np.cos(beta)])\n",
    "    #print(a,b,c)\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        #place four atoms at the general Wyckoff positions (4e): ±(x, y, z), ±(x, 1/2−y, 1/2+z).\n",
    "        coord_gena=[coordinate[0]*i for i in a];coord_genb=[coordinate[1]*i for i in b];coord_genc=[coordinate[2]*i for i in c]      \n",
    "        coords_temp.append([i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)])        \n",
    "        coords_temp.append([-i-j-k for i,j,k in zip(coord_gena,coord_genb,coord_genc)]) \n",
    "        coord_gena=[coordinate[0]*i for i in a];coord_genb=[(0.5-coordinate[1])*i for i in b];coord_genc=[(0.5+coordinate[2])*i for i in c]\n",
    "        coords_temp.append([i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)]) \n",
    "        coords_temp.append([-i-j-k for i,j,k in zip(coord_gena,coord_genb,coord_genc)]) \n",
    "        #coord_gen=[i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)]   \n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "    \n",
    "def generate_ec_monoclinic_structure(a0,b0,c0,beta,atoms,coords):\n",
    "    beta=np.pi*(beta/180)\n",
    "    a=np.asarray([0.,0.,-a0]);b=np.asarray([-b0,0.,0.]);c=np.asarray([0.,c0*np.sin(beta),-c0*np.cos(beta)])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coord_gena=[coordinate[0]*i for i in a];coord_genb=[coordinate[1]*i for i in b];coord_genc=[coordinate[2]*i for i in c] \n",
    "        coord_genaa=[(coordinate[0]+0.5)*i for i in a];coord_genbb=[(coordinate[1]+0.5)*i for i in b];coord_gencc=[coordinate[2]*i for i in c]\n",
    "        coords_temp.append([i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)])\n",
    "        coords_temp.append([i+j+k for i,j,k in zip(coord_genaa,coord_genbb,coord_gencc)])\n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "\n",
    "def generate_rhombohedral_structure(a0,beta,atoms,coords):\n",
    "    beta=np.pi*(beta/180)\n",
    "    a=np.asarray([a0,0.,0.]);b=np.asarray([np.cos(theta)*a0,np.sin(theta)*a0,0.]);c=np.asarray([(np.cos(theta))**2*a0,np.sin(theta)*a0,np.cos(theta)*np.sin(theta)*a0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coord_gena=[coordinate[0]*i for i in a];coord_genb=[coordinate[1]*i for i in b];coord_genc=[coordinate[2]*i for i in c] \n",
    "        coords_temp.append([i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)])\n",
    "    return atoms_temp,a,b,c,coords_temp    \n",
    "\n",
    "#def generate_triclinic_structure(a0,bo,c0,theta1,theta2,theta3,atoms,coords):   #not done\n",
    "#    a=[a0,0.,0.];b=[np.cos(theta1)*b0,np.sin(theta1)*b0,0.];c=[(np.cos(theta2)*np.cos(theta3)*c0,np.sin(theta)*c0,np.sin(theta2)*np.sin(theta3)*c0]\n",
    "#    atoms_temp=[];coords_temp=[]\n",
    "#    for atom in atoms:\n",
    "#        atoms_temp+=[atom]\n",
    "#    for coordinate in coords:\n",
    "#        coord_gena=[coordinate[0]*i for i in a];coord_genb=[coordinate[1]*i for i in b];coord_genc=[coordinate[2]*i for i in c] \n",
    "#        coords_temp.append([i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)])\n",
    "#    return atoms_temp,a,b,c,coords_temp   \n",
    "    \n",
    "\n",
    "def generate_1d_structure(c0,atoms,coords):\n",
    "    #a=[100.,0.,0.];b=[0.,100.,0.];c=[0.,0.,c0]\n",
    "    a=np.asarray([100.,0.,0.]);b=np.asarray([0.,100.,0.]);c=np.asarray([0.,0.,c0])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([coordinate[0],coordinate[1],c0*coordinate[2]]) \n",
    "    #print(\"lattice vectors\",a,b,c)\n",
    "    #print(coords_temp)\n",
    "    return atoms_temp,a,b,c,coords_temp\n",
    "    \n",
    "def generate_2d_square_structure(a0,atoms,coords):\n",
    "    a=np.asarray([a0,0.,0.]);b=np.asarray([0.,a0,0.]);c=np.asarray([0.,0.,100.])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    for coordinate in coords:\n",
    "        coords_temp.append([a0*coordinate[0],a0*coordinate[1],coordinate[2]]) \n",
    "    #print(\"lattice vectors\",a,b,c)\n",
    "    #print(coords_temp)\n",
    "    return atoms_temp,a,b,c,coords_temp\n",
    "\n",
    "def generate_2d_hexagonal_structure(a0,atoms,coords):\n",
    "    b=np.asarray([-a0/2,np.sqrt(3)*a0/2,0.]);a=np.asarray([a0,0.,0.]);c=np.asarray([0.,0.,100.])\n",
    "    atoms_temp=[];coords_temp=[]\n",
    "    for atom in atoms:\n",
    "        atoms_temp+=[atom]\n",
    "    coords=np.asarray(coords)\n",
    "    for coordinate in coords:\n",
    "        #coords_temp.append(np.dot((a+b+c),coordinate))\n",
    "        coord_gena=[coordinate[0]*i for i in a];coord_genb=[coordinate[1]*i for i in b];coord_genc=[0.,0.,coordinate[2]]\n",
    "        coord_gen=[i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)]        \n",
    "        coords_temp.append([i+j+k for i,j,k in zip(coord_gena,coord_genb,coord_genc)])   \n",
    "    return atoms_temp,a,b,c,coords_temp \n",
    "\n",
    "def read_from_library(title,parameters,cartesian):\n",
    "    a0=0;b0=0;c0=0;beta=0;d1=False;d2=False;d3=False\n",
    "    crystal=title\n",
    "    #Read the parameters from the crystal_dictionary\n",
    "    symmetry=crystal_dict[crystal][0]\n",
    "    if symmetry=='fcc':  #cubic: primitive, face or body centred\n",
    "        a0=crystal_dict[crystal][1];d3=True  \n",
    "    elif symmetry=='bcc':\n",
    "        a0=crystal_dict[crystal][1];d3=True \n",
    "    elif symmetry=='c':\n",
    "        a0=crystal_dict[crystal][1];d3=True \n",
    "    elif symmetry=='t' or symmetry=='bct':   #tetragonal: primitive or body centred\n",
    "        a0,c0=crystal_dict[crystal][1];d3=True \n",
    "    elif symmetry=='o' :  #orthorhombic: primitive\n",
    "        a0,b0,c0=crystal_dict[crystal][1];d3=True \n",
    "    elif symmetry=='h':\n",
    "        a0,c0=crystal_dict[crystal][1];d3=True \n",
    "    elif symmetry=='m':  #monoclinic: primitive \n",
    "        a0,b0,c0,beta=crystal_dict[crystal][1];d3=True \n",
    "    elif symmetry=='1d':  #monoclinic: primitive \n",
    "        c0=crystal_dict[crystal][1];d1=True \n",
    "    elif symmetry=='2d_square':\n",
    "        a0=crystal_dict[crystal][1];d2=True \n",
    "    elif symmetry=='2d_rectangular':\n",
    "        a0,b0=crystal_dict[crystal][1];d2=True \n",
    "    elif symmetry=='2d_h':\n",
    "        a0=crystal_dict[crystal][1];d2=True \n",
    "    atoms=crystal_dict[crystal][2]\n",
    "    Q=crystal_dict[crystal][3]\n",
    "    coords=crystal_dict[crystal][4]     \n",
    "    nptsx,nptsy,nptsz=crystal_dict[crystal][5]\n",
    "    interp_pointsx,interp_pointsy,interp_pointsz=crystal_dict[crystal][6]\n",
    "    span=crystal_dict[crystal][7]\n",
    "    DOS_min,DOS_max,E_pts=crystal_dict[crystal][8]\n",
    "    plot_all,plot_DOS=crystal_dict[crystal][9]\n",
    "    PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct=crystal_dict[crystal][10]\n",
    "    levels=crystal_dict[crystal][11]\n",
    "    offset=crystal_dict[crystal][12]\n",
    "    nneighbours,repeats=crystal_dict[crystal][13]\n",
    "    bloch_orbitals=crystal_dict[crystal][14]\n",
    "    bloch_kpts=crystal_dict[crystal][15]\n",
    "\n",
    "    if d1:    \n",
    "        print(\"treating the system as 1-dimensional (no dispersion in x and y directions)\",'\\n')\n",
    "        atoms,a,b,c,coords_to_print=generate_1d_structure(c0,atoms,coords)  \n",
    "    elif d2:    \n",
    "        print(\"treating the system as 2-dimensional (no dispersion in z direction)\",'\\n')  \n",
    "        if symmetry=='2d_square':        \n",
    "            print(\"lattice is square\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_2d_square_structure(a0,atoms,coords)\n",
    "        if symmetry=='2d_rectangular':        \n",
    "            print(\"lattice is rectangular\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_2d_rectangular_structure(a0,b0,atoms,coords)\n",
    "        elif symmetry=='2d_h':        \n",
    "            print(\"lattice is hexagonal\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_2d_hexagonal_structure(a0,atoms,coords)\n",
    "            if cartesian:\n",
    "                coords_to_print=coords\n",
    "    elif d3:    \n",
    "        print(\"treating the system as 3-dimensional (dispersion in x, y and z directions)\",'\\n')  \n",
    "        if symmetry=='fcc':  #cubic: primitive, face or body centred\n",
    "            print(\"lattice is face-centred cubic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_fcc_structure(a0,atoms,coords)\n",
    "        elif symmetry=='bcc':\n",
    "            print(\"lattice is body-centred cubic\",'\\n') \n",
    "            atoms,a,b,c,coords_to_print=generate_bcc_structure(a0,atoms,coords)\n",
    "        elif symmetry=='c':\n",
    "            print(\"lattice is primitive cubic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_primitive_cubic_structure(a0,atoms,coords)\n",
    "        elif symmetry=='t':   #tetragonal: primitive \n",
    "            print(\"lattice is primitive tetragonal\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_primitive_tetragonal_structure(a0,c0,atoms,coords)\n",
    "        elif symmetry=='o' :  #orthorhombic: primitive\n",
    "            print(\"lattice is orthorhombic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_primitive_orthorhombic_structure(a0,b0,c0,atoms,coords)\n",
    "        elif symmetry=='h':\n",
    "            print(\"lattice is hexagonal\",'\\n') \n",
    "            atoms,a,b,c,coords_to_print=generate_hexagonal_structure(a0,c0,atoms,coords)\n",
    "        elif symmetry=='m':  #monoclinic: primitive \n",
    "            print(\"lattice is monoclinic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_monoclinic_structure(a0,b0,c0,beta,atoms,coords)\n",
    "    \n",
    "    eh_basis_functs=eh_basis_setupb(atoms,parameters) # set up a list of basis functions (I only need this here to count the number of bf's)\n",
    "\n",
    "    if a0 and b0 and c0 and beta:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c = \", c0,\"Angstrom\",\"beta = \",beta,\"degrees\")\n",
    "    elif a0 and b0 and c0:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "    elif a0 and c0:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\",\"c = \",c0,\"Angstrom\")\n",
    "    elif a0:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\")\n",
    "    elif c0:\n",
    "        print(\"lattice parameters: c = \",c0,\"Angstrom\")\n",
    "    print('\\n')\n",
    "    unique_atoms=list(set(atoms))\n",
    "    occurences=[]\n",
    "    for element in unique_atoms:\n",
    "        occurences.append(atoms.count(element))        \n",
    "    print(\"formula unit: \")\n",
    "    for i in range(len(occurences)):\n",
    "        print(atno_to_element[unique_atoms[i]],occurences[i])\n",
    "    print('\\n')    \n",
    "    print(\"charge per unit cell\",Q,'\\n')\n",
    "    print(\"atomic coordinates\",'\\n')\n",
    "    for i in range(len(atoms)):\n",
    "        print(\"%-15s\"%(atno_to_element[atoms[i]]),\"%-15.5f\"%(coords_to_print[i][0]),\"%-15.5f\"%(coords_to_print[i][1]),\"%-15.5f\"%(coords_to_print[i][2]))\n",
    "    print('\\n\\n',\"**********************************************\")\n",
    "    print(\"Computational Details\",'\\n')\n",
    "    print(\"sampling Brillouin zone on an\",nptsx,\"x\",nptsy,\"x\",nptsz,\" grid\")\n",
    "    print(\"interpolated to \",interp_pointsx,\"x\",interp_pointsy,\"x\",interp_pointsz,\" grid\")\n",
    "    print(\"overlap with \",nneighbours,\" unit cells is considered\")\n",
    "    print('\\n\\n',\"**********************************************\")\n",
    "    #print(\"Plotting options\",'\\n')    \n",
    "    #print(\"Plotting DOS and PDOS per atom and angular momentum\")\n",
    "    #if bloch_orbitals:\n",
    "    #    print(\"plotting level \",bloch_orbitals[0],\" at the following k points\",np.round(bloch_kpts[0],decimals=2),np.round(bloch_kpts[1],decimals=2),np.round(bloch_kpts[2],decimals=2))\n",
    "    #    print(\"using \",2*repeats+1,\" repeats of the unit cell\",'\\n')\n",
    "    OK=input(\"Do you want to change any of these parameters?, Y/N  \")    \n",
    "    while OK=='Y' or OK=='y':\n",
    "        print('\\n')\n",
    "        print(\"Choose a parameter to change\")\n",
    "        print(\"1  lattice parameters\")\n",
    "        print(\"2  charge\")\n",
    "        print(\"3  Brillouin zone sampling\")\n",
    "        print(\"4  Fermi level scanning options\")\n",
    "        #print(\"5  plotting options\")\n",
    "        #print(\"6  PDOS plotting options\")\n",
    "        #print(\"7  Crystal orbital plotting options\")\n",
    "        print(\"10 Exit\")\n",
    "        print('\\n')    \n",
    "        parameter_change=int(input(\"input a number  (10 to carry on)  \"))\n",
    "        print(parameter_change)\n",
    "        if parameter_change==1:\n",
    "            if a0 and b0 and c0 and beta:\n",
    "                print(\"original lattice parameters: a = \",a0,\"Angstrom \",\" b = \",b0,\"Angstrom \",\" c =  \",c0,\"Angstrom \",\" beta = \",beta,\" degrees\")              \n",
    "                latt_params=input(\"input comma separated list of lattice parameters:  a0, b0, c0, beta  \")\n",
    "                a0,b0,c0,beta=[float(s) for s in latt_params.split(',')]\n",
    "                print(\"new lattice parameters: a = \",a0,\"Angstrom \",\" b = \",b0,\"Angstrom \",\" c =  \",c0,\"Angstrom \",\" beta = \",beta,\" degrees\")\n",
    "            elif a0 and b0 and c0:\n",
    "                print(\"original lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "                latt_params=input(\"input comma separated list of lattice parameters:  a0, b0, c0  \")\n",
    "                a0,b0,c0=[float(s) for s in latt_params.split(',')]\n",
    "                print(\"new lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "            elif a0 and c0:\n",
    "                print(\"original lattice parameters: a = \",a0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "                latt_params=input(\"input comma separated list of lattice parameters:  a0, c0  \")\n",
    "                a0,c0=[float(s) for s in latt_params.split(',')]\n",
    "                print(\"new lattice parameters: a = \",a0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "            elif a0:\n",
    "                print(\"original lattice parameter: a = \",a0)\n",
    "                a0=float(input(\"input lattice parameter: a0  \"))\n",
    "                print(\"new lattice parameter: a = \",a0,\"Angstrom\")\n",
    "            elif c0:\n",
    "                print(\"original lattice parameter: c =  \",c0,\"Angstrom\")\n",
    "                c0=float(input(\"input lattice parameter: c0  \"))\n",
    "                print(\"new lattice parameter: c = \",c0,\"Angstrom\")   \n",
    "        #recompute the coordinates with the new lattice parameters        \n",
    "            if d1:    \n",
    "                atoms,a,b,c,coords_to_print=generate_1d_structure(c0,atoms,coords)  \n",
    "            elif d2:    \n",
    "                if symmetry=='2d_square':        \n",
    "                    atoms,a,b,c,coords_to_print=generate_2d_square_structure(a0,atoms,coords)\n",
    "                elif symmetry=='2d_rectangular':        \n",
    "                    atoms,a,b,c,coords_to_print=generate_2d_hexagonal_structure(a0,b0,atoms,coords)\n",
    "                elif symmetry=='2d_h':  \n",
    "                    atoms,a,b,c,coords_to_print=generate_2d_hexagonal_structure(a0,atoms,coords)\n",
    "            elif d3:    \n",
    "                if symmetry=='fcc':  #cubic: primitive, face or body centred\n",
    "                    atoms,a,b,c,coords_to_print=generate_fcc_structure(a0,atoms,coords)\n",
    "                elif symmetry=='bcc':\n",
    "                    atoms,a,b,c,coords_to_print=generate_bcc_structure(a0,atoms,coords)\n",
    "                elif symmetry=='c':\n",
    "                    atoms,a,b,c,coords_to_print=generate_primitive_cubic_structure(a0,atoms,coords)\n",
    "                elif symmetry=='t':   #tetragonal: primitive \n",
    "                    atoms,a,b,c,coords_to_print=generate_primitive_tetragonal_structure(a0,c0,atoms,coords)\n",
    "                elif symmetry=='o' :  #orthorhombic: primitive\n",
    "                    atoms,a,b,c,coords_to_print=generate_primitive_orthorhombic_structure(a0,b0,c0,atoms,coords)\n",
    "                elif symmetry=='h':\n",
    "                    atoms,a,b,c,coords_to_print=generate_hexagonal_structure(a0,c0,atoms,coords)\n",
    "                elif symmetry=='m':  #monoclinic: primitive \n",
    "                    atoms,a,b,c,coords_to_print=generate_monoclinic_structure(a0,b0,c0,beta,atoms,coords)\n",
    "            print(\"atomic coordinates recomputed with the new lattice parameters\",'\\n')\n",
    "            for i in range(len(atoms)):\n",
    "                print(atno_to_element[atoms[i]],\"  \",coords_to_print[i][0],\"  \",coords_to_print[i][1],\"  \",coords_to_print[i][2])\n",
    "            print('\\n\\n',\"**********************************************\")\n",
    "        elif parameter_change==2:\n",
    "            print(\"original charge on the unit cell = \", Q)\n",
    "            Q=float(input(\"input new value of charge\"  ))\n",
    "            print(\"new charge value: \",Q)\n",
    "        elif parameter_change==3:\n",
    "            print(\"original Brillouin zone sampling grid: \", nptsx,\" x \",nptsy,\" x \",nptsz,'\\n')\n",
    "            coord_temp=input(\"input comma separated list of integers:  nptsx,nptsy,nptsz  \"  )\n",
    "            nptsx,nptsy,nptsz=[int(s) for s in coord_temp.split(',')]\n",
    "            print(\"new Brillouin zone sampling grid: \", nptsx,\" x \",nptsy,\" x \",nptsz,'\\n')\n",
    "            print(\"original interpolated Brillouin zone sampling grid: \", interp_pointsx,\" x \",interp_pointsy,\" x \",interp_pointsz,'\\n')\n",
    "            coord_temp=input(\"input comma separated list of integers:  nptsx,nptsy,nptsz  \"  )\n",
    "            interp_pointsx,interp_pointsy,interp_pointsz=[int(s) for s in coord_temp.split(',')]\n",
    "            print(\"new Brillouin zone interpolated sampling grid: \", interp_pointsx,\" x \",interp_pointsy,\" x \",interp_pointsz,'\\n')\n",
    "        elif parameter_change==4:\n",
    "            print(\"original threshold for Fermi level scanning = \", span)\n",
    "            print(\"the energy is scanned from below looking for a point where the cumulative number of occupied levels is approximately equal to 1/2 the number of electrons\")\n",
    "            print(\"'span' controls how close: default is 0.0005 - make it larger i.e. (0.05) if the Fermi level can't be located\")\n",
    "            span=float(input(\"input new value of 'span'\"  ))\n",
    "            print(\"new scan value: \",span)\n",
    "        elif parameter_change==5:\n",
    "            plot_choice=int(input(\"1 to plot DOS and band structure, 2 for DOS, band structure and crystal orbitals (only available for 1d and 2d)  \"  ))\n",
    "            if plot_choice==1:\n",
    "                plot_all=False,plot_DOS==True\n",
    "                print(\"plotting unit cell and DOS\")\n",
    "            elif plot_choice==2:\n",
    "                plot_all==True,plot_DOS==False\n",
    "                print(\"plotting unit cell, DOS and crystal orbitals\")\n",
    "        elif parameter_change==6:\n",
    "            plot_choice=int(input(\"1 to plot PDOS projected onto atoms, 2 for PDOS projected onto separate angular momentum components (l), 3 to plot PDOS projected onto separate ml  \"  ))\n",
    "            if plot_choice==1:\n",
    "                PDOS_by_atom==True;PDOS_by_atom_and_l==False;PDOS_by_basis_funct==False      #project DOS onto atoms\n",
    "            elif plot_choice==2:\n",
    "                PDOS_by_atom==False;PDOS_by_atom_and_l==True;PDOS_by_basis_funct==False      #project DOS onto atoms\n",
    "            elif plot_choice==3:\n",
    "                PDOS_by_atom==False;PDOS_by_atom_and_l==False;PDOS_by_basis_funct==True      #project DOS onto atoms\n",
    "            #print(\"here\")\n",
    "            print(\"original plot range: \", DOS_min,\" to \",DOS_max,\" in \",E_pts,' steps','\\n')\n",
    "            range_choice=input(\"input new plot range as comma separated list of integers:  Emin, Emax  \"  )\n",
    "            DOS_min,DOS_max=[float(s) for s in range_choice.split(',')]\n",
    "            E_pts=int(input(\"input number of steps for the energy scan (more will give a better sample but may be noisy)  \"  ))\n",
    "            print(\"new plot range: \", DOS_min,\" to \",DOS_max,\" in \",E_pts,' steps','\\n')\n",
    "        elif parameter_change==7:\n",
    "            if d3:\n",
    "                print(\"plotting of crystal orbitals is not available for 3-dimensional systems\")\n",
    "            elif d1 or d2:\n",
    "                print(\"choose the level to plot: available range is 0 to \",len(eh_basis_functs)-1) \n",
    "                bloch_orbitals=[]\n",
    "                bloch_orbitals.append(int(input(\"level?\"  )))\n",
    "                if d1:\n",
    "                    kpts_temp=input(\"choose three k points to plot (as comma separated list of floats:  kpt1,kpt2,kpt3)  \")\n",
    "                    bloch_kpts=[float(s) for s in kpts_temp.split(',')]\n",
    "                elif d2:\n",
    "                    bloch_kpts=[]\n",
    "                    kpts_temp1=input(\"choose first k point to plot (as comma separated list of floats:  kptx,kpty)  \")\n",
    "                    kpts_temp2=input(\"choose second k point to plot (as comma separated list of floats:  kptx,kpty)  \")\n",
    "                    kpts_temp3=input(\"choose third k point to plot (as comma separated list of floats:  kptx,kpty)  \")\n",
    "                    bloch_kpts.append([float(s) for s in kpts_temp1.split(',')],[float(s) for s in kpts_temp2.split(',')],[float(s) for s in kpts_temp3.split(',')])\n",
    "        elif parameter_change==10:\n",
    "            break\n",
    "        print('\\n')\n",
    "        OK=input(\"Do you want to change another parameter?, Y/N  \")\n",
    "\n",
    "    #coords=coords_to_print\n",
    "    \n",
    "    return a0,b0,c0,beta,crystal,symmetry,atoms,Q,coords,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,DOS_min,DOS_max,E_pts,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts\n",
    "\n",
    "\n",
    "#i have written the function below to allow for reading from an external input file (*.input). This should in principle allow people to write their own files\n",
    "#but would require them to pickle and unpickle them\n",
    "def read_from_file(title,parameters):\n",
    "    input_file=title+'.input'    \n",
    "    #title=str(title)\n",
    "    print(\"Reading data from \",input_file,'\\n')\n",
    "    a0=0;b0=0;c0=0;beta=0;d1=False;d2=False;d3=False\n",
    "    input_data=pickle.load(open(input_file,'rb'))\n",
    "    title=input_data['title']\n",
    "    comment=input_data['comment']\n",
    "    symmetry=input_data['symmetry']\n",
    "    atoms=input_data['atoms']\n",
    "    coords=input_data['coords']\n",
    "    Q=input_data['Q']\n",
    "    span=input_data['span']\n",
    "    a0,b0,c0,beta=input_data['latt_params']\n",
    "    nptsx,nptsy,nptsz=input_data['npts']\n",
    "    interp_pointsx,interp_pointsy,interp_pointsz=input_data['interp_pts']\n",
    "    DOS_min,DOS_max,E_pts=input_data['DOS_params']\n",
    "    plot_all,plot_DOS=input_data['plot_options']\n",
    "    PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct=input_data['pdos_options']\n",
    "    levels_setup=input_data['level_options']\n",
    "    levels=np.linspace(levels_setup[0],levels_setup[1],levels_setup[2])\n",
    "    offset=input_data['offset']\n",
    "    nneighbours,repeats=input_data['repeat_options']\n",
    "    bloch_orbitals=input_data['bloch_orbitals']\n",
    "    bloch_kpts=input_data['bloch_kpts']    \n",
    "    print(comment)\n",
    "    print('\\n')\n",
    "    input('press any key to continue')    \n",
    "    #from title import a0,b0,c0,beta,atoms,coords,Q,symmetry,levels,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,offset,span,nneighbours,repeats,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,DOS_min,DOS_max,E_pts,c0,bloch_orbitals,bloch_kpts\n",
    "    if symmetry=='fcc' or symmetry=='bcc' or symmetry=='c' or symmetry=='t' or symmetry=='bct' or symmetry=='o' or symmetry=='h' or symmetry=='m':  #cubic: primitive, face or body centred\n",
    "        d3=True  \n",
    "    elif symmetry=='1d':   \n",
    "        d1=True \n",
    "    if symmetry=='2d_square' or symmetry=='2d_rectangular' or symmetry=='2d_h':\n",
    "        d2=True \n",
    "    #note I do the following steps again in 'setup' - the steps below are just to set up the coordinates to print. I could pass the results to setup rather than recompute them, but it's quick.\n",
    "    if d1:    \n",
    "        print(\"treating the system as 1-dimensional (no dispersion in x and y directions)\",'\\n')\n",
    "        atoms,a,b,c,coords_to_print=generate_1d_structure(c0,atoms,coords)  \n",
    "    elif d2:    \n",
    "        print(\"treating the system as 2-dimensional (no dispersion in z direction)\",'\\n')  \n",
    "        if symmetry=='2d_square':        \n",
    "            print(\"lattice is square\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_2d_square_structure(a0,atoms,coords)\n",
    "        if symmetry=='2d_rectangular':        \n",
    "            print(\"lattice is rectangular\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_2d_rectangular_structure(a0,b0,atoms,coords)\n",
    "        elif symmetry=='2d_h':        \n",
    "            print(\"lattice is hexagonal\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_2d_hexagonal_structure(a0,atoms,coords)            \n",
    "    elif d3:    \n",
    "        print(\"treating the system as 3-dimensional (dispersion in x, y and z directions)\",'\\n')  \n",
    "        if symmetry=='fcc':  #cubic: primitive, face or body centred\n",
    "            print(\"lattice is face-centred cubic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_fcc_structure(a0,atoms,coords)\n",
    "        elif symmetry=='bcc':\n",
    "            print(\"lattice is body-centred cubic\",'\\n') \n",
    "            atoms,a,b,c,coords_to_print=generate_bcc_structure(a0,atoms,coords)\n",
    "        elif symmetry=='c':\n",
    "            print(\"lattice is primitive cubic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_primitive_cubic_structure(a0,atoms,coords)\n",
    "        elif symmetry=='t':   #tetragonal: primitive \n",
    "            print(\"lattice is primitive tetragonal\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_primitive_tetragonal_structure(a0,c0,atoms,coords)\n",
    "        elif symmetry=='o' :  #orthorhombic: primitive\n",
    "            print(\"lattice is orthorhombic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_primitive_orthorhombic_structure(a0,b0,c0,atoms,coords)\n",
    "        elif symmetry=='h':\n",
    "            print(\"lattice is hexagonal\",'\\n') \n",
    "            atoms,a,b,c,coords_to_print=generate_hexagonal_structure(a0,c0,atoms,coords)\n",
    "        elif symmetry=='m':  #monoclinic: primitive \n",
    "            print(\"lattice is monoclinic\",'\\n')\n",
    "            atoms,a,b,c,coords_to_print=generate_monoclinic_structure(a0,b0,c0,beta,atoms,coords)\n",
    "    \n",
    "    eh_basis_functs=eh_basis_setupb(atoms,parameters) # set up a list of basis functions (I only need this here to count the number of bf's)\n",
    "\n",
    "    if a0 and b0 and c0 and beta:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c = \", c0,\"Angstrom\",\"beta = \",beta,\"degrees\")\n",
    "    elif a0 and b0 and c0:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "    elif a0 and c0:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\",\"c = \",c0,\"Angstrom\")\n",
    "    elif a0:\n",
    "        print(\"lattice parameters: a = \",a0,\"Angstrom\")\n",
    "    elif c0:\n",
    "        print(\"lattice parameters: c = \",c0,\"Angstrom\")\n",
    "    print('\\n')\n",
    "    unique_atoms=list(set(atoms))\n",
    "    occurences=[]\n",
    "    for element in unique_atoms:\n",
    "        occurences.append(atoms.count(element))        \n",
    "    print(\"formula unit: \",'\\n')\n",
    "    for i in range(len(occurences)):\n",
    "        print(atno_to_element[unique_atoms[i]],occurences[i])\n",
    "    print('\\n')    \n",
    "    print(\"charge per unit cell\",Q,'\\n')\n",
    "    print(\"atomic coordinates\",'\\n')\n",
    "    for i in range(len(atoms)):\n",
    "        print(atno_to_element[atoms[i]],\"  \",coords_to_print[i][0],\"  \",coords_to_print[i][1],\"  \",coords_to_print[i][2])\n",
    "    print('\\n\\n',\"**********************************************\")\n",
    "    print(\"Computational Details\",'\\n')\n",
    "    print(\"sampling Brillouin zone on an\",nptsx,\"x\",nptsy,\"x\",nptsz,\" grid\")\n",
    "    print(\"interpolated to \",interp_pointsx,\"x\",interp_pointsy,\"x\",interp_pointsz,\" grid\")\n",
    "    print(\"overlap with \",nneighbours,\" unit cells is considered\")\n",
    "    print('\\n\\n',\"**********************************************\")\n",
    "    print(\"Plotting options\",'\\n')    \n",
    "    print(\"Plotting DOS and PDOS per atom and angular momentum\")\n",
    "    if (d1 or d2):\n",
    "        print(\"plotting level \",bloch_orbitals[0],\" at the following k points\",np.round(bloch_kpts[0],decimals=2),np.round(bloch_kpts[1],decimals=2),np.round(bloch_kpts[2],decimals=2))\n",
    "        print(\"using \",2*repeats+1,\" repeats of the unit cell\",'\\n')\n",
    "    OK=input(\"Do you want to change any of these parameters?, y/n  \")    \n",
    "    while OK=='Y' or OK=='y':\n",
    "        print('\\n')\n",
    "        print(\"Choose a parameter to change\")\n",
    "        print(\"1  lattice parameters\")\n",
    "        print(\"2  charge\")\n",
    "        print(\"3  Interpolation options\")\n",
    "        print(\"4  Brillouin zone sampling\")\n",
    "        print(\"5  Fermi level scanning options\")\n",
    "        print(\"6  plotting options\")\n",
    "        print(\"7  PDOS plotting options\")\n",
    "        print(\"8  Crystal orbital plotting options\")        \n",
    "        print(\"10 Exit\")\n",
    "        print('\\n')    \n",
    "        parameter_change=int(input(\"input a number  (10 to carry on)  \"))\n",
    "        print(parameter_change)\n",
    "        if parameter_change==1:\n",
    "            if a0 and b0 and c0 and beta:\n",
    "                print(\"original lattice parameters: a = \",a0,\"Angstrom \",\" b = \",b0,\"Angstrom \",\" c =  \",c0,\"Angstrom \",\" beta = \",beta,\" degrees\")              \n",
    "                latt_params=input(\"input comma separated list of lattice parameters:  a0, b0, c0, beta  \")\n",
    "                a0,b0,c0,beta=[float(s) for s in latt_params.split(',')]\n",
    "                print(\"new lattice parameters: a = \",a0,\"Angstrom \",\" b = \",b0,\"Angstrom \",\" c =  \",c0,\"Angstrom \",\" beta = \",beta,\" degrees\")\n",
    "            elif a0 and b0 and c0:\n",
    "                print(\"original lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "                latt_params=input(\"input comma separated list of lattice parameters:  a0, b0, c0  \")\n",
    "                a0,b0,c0=[float(s) for s in latt_params.split(',')]\n",
    "                print(\"new lattice parameters: a = \",a0,\"Angstrom\",\" b = \",b0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "            elif a0 and c0:\n",
    "                print(\"original lattice parameters: a = \",a0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "                latt_params=input(\"input comma separated list of lattice parameters:  a0, c0  \")\n",
    "                a0,c0=[float(s) for s in latt_params.split(',')]\n",
    "                print(\"new lattice parameters: a = \",a0,\"Angstrom\",\"c =  \",c0,\"Angstrom\")\n",
    "            elif a0:\n",
    "                print(\"original lattice parameter: a = \",a0)\n",
    "                a0=float(input(\"input lattice parameter: a0  \"))\n",
    "                print(\"new lattice parameter: a = \",a0,\"Angstrom\")\n",
    "            elif c0:\n",
    "                print(\"original lattice parameter: c =  \",c0,\"Angstrom\")\n",
    "                c0=float(input(\"input lattice parameter: c0  \"))\n",
    "                print(\"new lattice parameter: c = \",c0,\"Angstrom\")   \n",
    "        #recompute the coordinates with the new lattice parameters        \n",
    "            if d1:    \n",
    "                atoms,a,b,c,coords_to_print=generate_1d_structure(c0,atoms,coords)  \n",
    "            elif d2:    \n",
    "                if symmetry=='2d_square':        \n",
    "                    atoms,a,b,c,coords_to_print=generate_2d_square_structure(a0,atoms,coords)\n",
    "                elif symmetry=='2d_rectangular':        \n",
    "                    atoms,a,b,c,coords_to_print=generate_2d_hexagonal_structure(a0,b0,atoms,coords)\n",
    "                elif symmetry=='2d_h':  \n",
    "                    atoms,a,b,c,coords_to_print=generate_2d_hexagonal_structure(a0,atoms,coords)\n",
    "            elif d3:    \n",
    "                if symmetry=='fcc':  #cubic: primitive, face or body centred\n",
    "                    atoms,a,b,c,coords_to_print=generate_fcc_structure(a0,atoms,coords)\n",
    "                elif symmetry=='bcc':\n",
    "                    atoms,a,b,c,coords_to_print=generate_bcc_structure(a0,atoms,coords)\n",
    "                elif symmetry=='c':\n",
    "                    atoms,a,b,c,coords_to_print=generate_primitive_cubic_structure(a0,atoms,coords)\n",
    "                elif symmetry=='t':   #tetragonal: primitive \n",
    "                    atoms,a,b,c,coords_to_print=generate_primitive_tetragonal_structure(a0,c0,atoms,coords)\n",
    "                elif symmetry=='o' :  #orthorhombic: primitive\n",
    "                    atoms,a,b,c,coords_to_print=generate_primitive_orthorhombic_structure(a0,b0,c0,atoms,coords)\n",
    "                elif symmetry=='h':\n",
    "                    atoms,a,b,c,coords_to_print=generate_hexagonal_structure(a0,c0,atoms,coords)\n",
    "                elif symmetry=='m':  #monoclinic: primitive \n",
    "                    atoms,a,b,c,coords_to_print=generate_monoclinic_structure(a0,b0,c0,beta,atoms,coords)\n",
    "            print(\"atomic coordinates recomputed with the new lattice parameters\",'\\n')\n",
    "            for i in range(len(atoms)):\n",
    "                print(atno_to_element[atoms[i]],\"  \",coords_to_print[i][0],\"  \",coords_to_print[i][1],\"  \",coords_to_print[i][2])\n",
    "            print('\\n\\n',\"**********************************************\")\n",
    "        elif parameter_change==2:\n",
    "            print(\"original charge on the unit cell = \", Q)\n",
    "            Q=float(input(\"input new value of charge\"  ))\n",
    "            print(\"new charge value: \",Q)\n",
    "        elif parameter_change==3:\n",
    "            interp_switch=float(input(\"Turn interpolation of Brillouin zone off? y/n   \"  ))\n",
    "            if interp_switch=='y':\n",
    "                interpolate_flag=False\n",
    "                print(\"interpolation turned off\")\n",
    "            else:\n",
    "                print(\"interpolation still on\")\n",
    "        elif parameter_change==4:\n",
    "            print(\"original Brillouin zone sampling grid: \", nptsx,\" x \",nptsy,\" x \",nptsz,'\\n')\n",
    "            coord_temp=input(\"input comma separated coordinate list of integers:  nptsx,nptsy,nptsz  \"  )\n",
    "            nptsx,nptsy,nptsz=[int(s) for s in coord_temp.split(',')]\n",
    "            print(\"new Brillouin zone sampling grid: \", nptsx,\" x \",nptsy,\" x \",nptsz,'\\n')\n",
    "            print(\"original interpolated Brillouin zone sampling grid: \", interp_pointsx,\" x \",interp_pointsy,\" x \",interp_pointsz,'\\n')\n",
    "            coord_temp=input(\"input comma separated coordinate list of integers:  nptsx,nptsy,nptsz  \"  )\n",
    "            interp_pointsx,interp_pointsy,interp_pointsz=[int(s) for s in coord_temp.split(',')]\n",
    "            print(\"new Brillouin zone interpolated sampling grid: \", interp_pointsx,\" x \",interp_pointsy,\" x \",interp_pointsz,'\\n')\n",
    "        elif parameter_change==5:\n",
    "            print(\"original threshold for Fermi level scanning = \", span)\n",
    "            print(\"the energy is scanned from below looking for a point where the cumulative number of occupied levels is approximately equal to 1/2 the number of electrons\")\n",
    "            print(\"'span' controls how close: default is 0.0005 - make it larger i.e. (0.05) if the Fermi level can't be located\")\n",
    "            span=float(input(\"input new value of 'span'\"  ))\n",
    "            print(\"new scan value: \",span)\n",
    "        elif parameter_change==6:\n",
    "            plot_choice=int(input(\"1 to plot DOS and band structure, 2 for DOS, band structure and crystal orbitals (only available for 1d and 2d)  \"  ))\n",
    "            if plot_choice==1:\n",
    "                plot_all=False;plot_DOS=True\n",
    "                print(\"plotting unit cell and DOS\")\n",
    "            elif plot_choice==2:\n",
    "                plot_all=True;plot_DOS=False\n",
    "                print(\"plotting unit cell, DOS and crystal orbitals\")\n",
    "        elif parameter_change==7:\n",
    "            plot_choice=int(input(\"1 to plot PDOS projected onto atoms, 2 for PDOS projected onto separate angular momentum components (l), 3 to plot PDOS projected onto separate ml  \"  ))\n",
    "            if plot_choice==1:\n",
    "                PDOS_by_atom=True;PDOS_by_atom_and_l=False;PDOS_by_basis_funct=False      #project DOS onto atoms\n",
    "            elif plot_choice==2:\n",
    "                PDOS_by_atom=False;PDOS_by_atom_and_l=True;PDOS_by_basis_funct=False      #project DOS onto atoms\n",
    "            elif plot_choice==3:\n",
    "                PDOS_by_atom=False;PDOS_by_atom_and_l=False;PDOS_by_basis_funct=True      #project DOS onto atoms\n",
    "            #print(plot_by_basis_funct)\n",
    "            print(\"original plot range: \", DOS_min,\" to \",DOS_max,\" in \",E_pts,' steps','\\n')\n",
    "            range_choice=input(\"input new plot range as comma separated coordinate list of integers:  Emin, Emax  \"  )\n",
    "            DOS_min,DOS_max=[float(s) for s in range_choice.split(',')]\n",
    "            E_pts=int(input(\"input number of steps for the energy scan (more will give a better sample but may be noisy)  \"  ))\n",
    "            print(\"new plot range: \", DOS_min,\" to \",DOS_max,\" in \",E_pts,' steps','\\n')\n",
    "        elif parameter_change==8:\n",
    "            if d3:\n",
    "                print(\"plotting of crystal orbitals is not available for 3-dimensional systems\")\n",
    "            elif (d1 or d2):\n",
    "                print(\"choose the level to plot: available range is 0 to \",len(eh_basis_functs)-1) \n",
    "                bloch_orbitals=[]\n",
    "                bloch_orbitals.append(int(input(\"level?\"  )))\n",
    "                if d1:\n",
    "                    kpts_temp=input(\"choose three k points to plot (as comma separated list of floats:  kpt1,kpt2,kpt3)  \")\n",
    "                    bloch_kpts=[float(s) for s in kpts_temp.split(',')]\n",
    "                elif d2:\n",
    "                    bloch_kpts=[]\n",
    "                    kpts_temp1=input(\"choose first k point to plot (as comma separated list of floats:  kptx,kpty)  \")\n",
    "                    kpts_temp2=input(\"choose second k point to plot (as comma separated list of floats:  kptx,kpty)  \")\n",
    "                    kpts_temp3=input(\"choose third k point to plot (as comma separated list of floats:  kptx,kpty)  \")\n",
    "                    bloch_kpts.append([float(s) for s in kpts_temp1.split(',')],[float(s) for s in kpts_temp2.split(',')],[float(s) for s in kpts_temp3.split(',')])\n",
    "        elif parameter_change==10:\n",
    "            break\n",
    "        print('\\n')\n",
    "        OK=input(\"Do you want to change another parameter?, y/n  \")\n",
    "\n",
    "    #coords=coords_to_print\n",
    "    #print(PDOS_by_basis_funct)\n",
    "    return a0,b0,c0,beta,symmetry,atoms,Q,coords,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,DOS_min,DOS_max,E_pts,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def setup(cartesian,a0,b0,c0,beta,title,symmetry,atoms,Q,coords,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,DOS_min,DOS_max,E_pts,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts):\n",
    "    d1=False;d2=False;d3=False\n",
    "    #cartesian=False\n",
    "    if symmetry=='fcc':  #cubic: primitive, face or body centred\n",
    "        d3=True\n",
    "        #a0=crystal_dict[crystal][1]  \n",
    "        atoms,a,b,c,coords_in_angstrom=generate_fcc_structure(a0,atoms,coords)\n",
    "        BZ_labels=[\"L\",r'$\\Gamma$',\"X\",\"W\",r'$\\Gamma$']#,\"R\",\"X\"]\n",
    "        BZ_path=[fcc_special_points[\"L\"],fcc_special_points[\"gamma\"],fcc_special_points[\"X\"],fcc_special_points[\"W\"],fcc_special_points[\"gamma\"]]#,\\\n",
    "    elif symmetry=='bcc':\n",
    "        d3=True\n",
    "        print(\"here\")\n",
    "        #a0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_bcc_structure(a0,atoms,coords)\n",
    "        BZ_labels=[r'$\\Gamma$',\"H\",\"N\",r'$\\Gamma$',\"P\"]#,\"R\",\"X\"]\n",
    "        BZ_path=[bcc_special_points[\"gamma\"],bcc_special_points[\"H\"],bcc_special_points[\"N\"],bcc_special_points[\"gamma\"],bcc_special_points[\"P\"]]#,\\\n",
    "    elif symmetry=='c':\n",
    "        d3=True\n",
    "        #a0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_primitive_cubic_structure(a0,atoms,coords)\n",
    "        BZ_labels=[\"X\",\"R\",\"M\",r'$\\Gamma$','R',]#,\"R\",\"X\"]\n",
    "        BZ_path=[cubic_special_points[\"X\"],cubic_special_points[\"R\"],cubic_special_points[\"M\"],cubic_special_points[\"gamma\"],cubic_special_points[\"R\"]]#,\\\n",
    "    elif symmetry=='t' or symmetry=='bct':   #tetragonal: primitive or body centred\n",
    "        d3=True\n",
    "        #a0,c0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_primitive_tetragonal_structure(a0,c0,atoms,coords)\n",
    "        BZ_labels=['Z',r'$\\Gamma$',\"X\",\"M\",r'$\\Gamma$']#,\"Z\",\"R\",\"A\",\"Z\"]\n",
    "        BZ_path=[tetragonal_special_points[\"Z\"],tetragonal_special_points[\"gamma\"],tetragonal_special_points[\"X\"],tetragonal_special_points[\"M\"],tetragonal_special_points[\"gamma\"]]#,\\\n",
    "    elif symmetry=='o' :  #orthorhombic: primitive\n",
    "        d3=True\n",
    "        #a0,b0,c0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_primitive_orthorhombic_structure(a0,c0,atoms,coords)\n",
    "        BZ_labels=[r'$\\Gamma$',\"X\",\"S\",\"R\"]\n",
    "        BZ_path=[orthorhombic_special_points[\"gamma\"],orthorhombic_special_points[\"X\"],orthorhombic_special_points[\"S\"],orthorhombic_special_points[\"R\"]]\n",
    "    elif symmetry=='h':\n",
    "        d3=True\n",
    "        #a0,c0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_hexagonal_structure(a0,c0,atoms,coords)\n",
    "        BZ_labels=[r'$\\Gamma$',\"K\",\"H\",\"A\",r'$\\Gamma$']#,\"A\",\"L\",\"H\"]\n",
    "        BZ_path=[hexagonal_special_points[\"gamma\"],hexagonal_special_points[\"K\"],hexagonal_special_points[\"H\"],hexagonal_special_points[\"A\"],hexagonal_special_points[\"gamma\"]]#,\\\n",
    "    elif symmetry=='m':  #monoclinic: primitive \n",
    "        d3=True\n",
    "        #a0,b0,c0,beta=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_monoclinic_structure(a0,b0,c0,beta,atoms,coords)\n",
    "        BZ_labels=[r'$\\Gamma$',\"Z\",\"C\",\"Y\",\"B\",\"D\",r'$\\Gamma$']#,\"A\",\"L\",\"H\"]\n",
    "        BZ_path=[monoclinic_special_points[\"gamma\"],monoclinic_special_points[\"Z\"],monoclinic_special_points[\"C\"],monoclinic_special_points[\"Y\"]\\\n",
    "        ,monoclinic_special_points[\"B\"],monoclinic_special_points[\"D\"],monoclinic_special_points[\"gamma\"]]#,\\\n",
    "    elif symmetry=='1d':  #monoclinic: primitive \n",
    "        d1=True\n",
    "        #c0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_1d_structure(c0,atoms,coords)\n",
    "        BZ_labels=[r'$\\Gamma$',r'$\\Pi$'+'/a']#,\"A\",\"L\",\"H\"]\n",
    "        BZ_path=[special_points_1d[\"gamma\"],special_points_1d[\"X\"]]#,\\\n",
    "    elif symmetry=='2d_square':\n",
    "        d2=True\n",
    "        #a0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_2d_square_structure(a0,atoms,coords)\n",
    "        BZ_labels=[r'$\\Gamma$',\"X\",\"M\",r'$\\Gamma$']#,\"A\",\"L\",\"H\"]\n",
    "        BZ_path=[special_points_2d_square[\"gamma\"],special_points_2d_square[\"X\"],special_points_2d_square[\"M\"],special_points_2d_square[\"gamma\"]]#,\\\n",
    "    elif symmetry=='2d_h':\n",
    "        d2=True\n",
    "        #a0=crystal_dict[crystal][1]\n",
    "        atoms,a,b,c,coords_in_angstrom=generate_2d_hexagonal_structure(a0,atoms,coords)\n",
    "        if cartesian:\n",
    "            coords_in_angstrom=coords            \n",
    "        BZ_labels=[r'$\\Gamma$',\"K\",\"M\",r'$\\Gamma$']#,\"A\",\"L\",\"H\"]\n",
    "        BZ_path=[special_points_2d_h[\"gamma\"],special_points_2d_h[\"K\"],special_points_2d_h[\"M\"],special_points_2d_h[\"gamma\"]]#,\\\n",
    "    \n",
    "    #work out the volume and density    \n",
    "    volume=np.dot(a,np.cross(b,c))\n",
    "    mass_in_unit_cell=0.\n",
    "    for element in atoms:\n",
    "        mass_in_unit_cell+=atomic_masses[element]\n",
    "    mass_in_unit_cell/=NA\n",
    "    density=10**24*mass_in_unit_cell/volume\n",
    "    #print('\\n\\n',\"**********************************************\",'\\n')\n",
    "    if d3:\n",
    "        print(\"Volume of unit cell= \",np.round(volume,decimals=3),'Angstrom^3','  Density = ',np.round(density,decimals=3),'g cm^-3','\\n')\n",
    "    \n",
    "    #convert to atomic units (vectors and coordinates)\n",
    "    a=a/A0;b=b/A0;c=c/A0    \n",
    "    #a=[x/A0 for x in a];b=[x/A0 for x in b];c=[x/A0 for x in c]\n",
    "    coords_in_au,element_coord=coord_con_EHT(coords_in_angstrom,atoms)\n",
    "    #construct reciprocal lattice vectors   \n",
    "    A=2*np.pi*np.cross(b,c)/np.dot(a,np.cross(b,c))\n",
    "    B=2*np.pi*np.cross(a,c)/np.dot(b,np.cross(a,c))\n",
    "    C=2*np.pi*np.cross(a,b)/np.dot(c,np.cross(a,b))\n",
    "    #print(\"ABC\",A,B,C)\n",
    "    #global hexagonal,cubic,tetragonal,orthorhombic,monoclinic\n",
    "    \n",
    "    #print(\"Determine displacement vectors\")\n",
    "    #now set up the vectors to generate nearest neighbours (there are 13 in 3d, 4 in 2d and 1 in 1d \n",
    "    #(for one nearest neighbour) - I will generate the negative vectors formed by reflecting in the origin later on in BZ_sample)\n",
    "    displacements=[]  \n",
    "    #nneighbours=1\n",
    "    if d3:\n",
    "        #if symmetry=='bcc':\n",
    "        #    displacements2=[a,b,c,a+b+c,a+b,a+c,b+c,a-c,b-c,a-b,a+b+2*c,a+2*b+c,2*a+b+c]\n",
    "        #elif symmetry=='fcc':\n",
    "        #    displacements2=[a,b,c,a-b,b-c,a-c,a-b+c,a+b-c,-a+b+c]\n",
    "        #else:\n",
    "        for i in range(-nneighbours,nneighbours+1):\n",
    "                for j in range(-nneighbours,nneighbours+1):\n",
    "                    for k in range(-nneighbours,nneighbours+1):\n",
    "                        displacements.append(i*a+j*b+k*c)      \n",
    "        #discard the last half of the displacements as I will generate these by transposing the S and H matrices. Saves 50% on calculating S.\n",
    "        displacements=displacements[:int(((2*nneighbours+1)**3-1)/2)]\n",
    "\n",
    "    elif d2:\n",
    "        displacements=[]\n",
    "        for i in range(-nneighbours,nneighbours+1):\n",
    "            for j in range(-nneighbours,nneighbours+1):\n",
    "                displacements.append(i*a+j*b)\n",
    "        displacements=displacements[:int(((2*nneighbours+1)**2-1)/2)]\n",
    "    elif d1:\n",
    "        for i in range(1,nneighbours+1):\n",
    "            displacements.append(i*c)\n",
    "\n",
    "    return a,b,c,A,B,C,atoms,coords_in_angstrom,coords_in_au,element_coord,Q,displacements,\\\n",
    "    BZ_path,BZ_labels,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,DOS_min,\\\n",
    "    DOS_max,E_pts,symmetry,d1,d2,d3,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts\n",
    "#determines reciprocal lattice vectors\n",
    "\n",
    "def define_BZ(symmetry,A,B,C,nptsx,nptsy,nptsz,d1,d2,d3):\n",
    "    kx=0.;ky=0.;kz=0.\n",
    "    if d3:\n",
    "        if symmetry=='c' or symmetry=='t' or symmetry=='o':\n",
    "            kx_min=0.;ky_min=0.;kz_min=0.\n",
    "            kx_max=0.5*A.max();ky_max=0.5*B.max();kz_max=0.5*C.max()    \n",
    "        elif symmetry=='fcc' or symmetry=='bcc': \n",
    "            kx_min=0.;ky_min=0.;kz_min=0.\n",
    "            kx_max=ky_max=kz_max=A.max()\n",
    "        elif symmetry=='h': \n",
    "            kx_min=0.;ky_min=0.;kz_min=0.\n",
    "            ky_max=B.max()/4;kx_max=(A*2/3-B/3).max();kz_max=C.max()/2\n",
    "    #interpolate_flag=False\n",
    "        elif symmetry=='m':\n",
    "            kx_min=0;ky_min=0.;kz_min=-1.2*np.sqrt(3)/4\n",
    "    #work out intersections of Y,C and U to get maximum values of kz:\n",
    "    #print(B,B.max())\n",
    "            kx_max=-B.min()/2;ky_max=C.max()/2;kz_max=1.2*np.sqrt(3)/4\n",
    "    #print(\"maxima\",kx_min,ky_min,kz_min,kx_max,ky_max,kz_max)\n",
    "        kx=np.linspace(kx_min,kx_max,nptsx)\n",
    "        ky=np.linspace(ky_min,ky_max,nptsy)\n",
    "        kz=np.linspace(kz_min,kz_max,nptsz)\n",
    "    elif d1:\n",
    "        #print(\"here\")\n",
    "        kz_min=0.;kz_max=C.max()/2 \n",
    "        #print(kz_max)\n",
    "        kz=np.linspace(kz_min,kz_max,nptsz)\n",
    "    elif d2:\n",
    "        if symmetry=='2d_square':\n",
    "            kx_min=0.;ky_min=0.\n",
    "            kx_max=0.5*A.max();ky_max=0.5*B.max()\n",
    "        elif symmetry=='2d_h':\n",
    "            kx_min=0.;ky_min=0.;\n",
    "            ky_max=B.max()/4+0.02;kx_max=(A*2/3-B/3).max()+0.02\n",
    "            #print(\"BZ\",B,2/3*A-1/3*B)\n",
    "            #print(kx_max,ky_max)\n",
    "        kx=np.linspace(kx_min,kx_max,nptsx)\n",
    "        ky=np.linspace(ky_min,ky_max,nptsy)\n",
    "    return kx,ky,kz\n",
    "    \n",
    "#Now run a calculation on the isolated unit cell (standard EH theory, calling on modules in EH_module5.py)\n",
    "#We will need S and H for periodic calculation\n",
    "def isolated_unit_cell(coords,atoms,element_coord,parameters,parameter_file,Q,dist_cutoff,title,WH):\n",
    "    print(\"Calculating Properties of the Isolated Unit Cell\")\n",
    "    #print(\"parameters\",parameters[14],\"atoms\",atoms)\n",
    "    eh_basis_functs=eh_basis_setupb(atoms,parameters) # set up a list of basis functions\n",
    "    #print(\"lens\",len(atoms),len(eh_basis_functs))\n",
    "    #print(\"basis\",eh_basis_functs)\n",
    "    #index the basis functions - I need this later to plot the Bloch eigenfunctions\n",
    "    bf_index=[]\n",
    "    for item in eh_basis_functs:\n",
    "        bf_index.append(item[1])\n",
    "    no_electrons=count_electrons(atoms,Q,parameter_file)  # count the electrons (just to work out what's occupied at the end - has no impact on eigenvalues)\n",
    "    print(\"electrons\",no_electrons,\"    basis functions\",len(bf_index),'\\n')\n",
    "    S=overlap_matrix_new(eh_basis_functs,coords,dist_cutoff)  #calculates overlap matrix\n",
    "    H=Hamiltonian_matrix(eh_basis_functs,S,WH)   #calculates Hamiltonian matrix\n",
    "    v,e,occupations=diagonalise_periodic(H,S,no_electrons)  #Solves generalised eigenvalue equation\n",
    "    e=e.real;v=v.real\n",
    "    S=S.real;H=H.real\n",
    "    #e,v.S and H are in fact pure real for the isolated unit cell, but diagonalise_periodic initialises them as complex\n",
    "    #so I need to discard the imaginary part to make them compaticle with Mulliken and print functions.\n",
    "    \n",
    "    emin=min(e)\n",
    "    Mulliken,reduced_Mulliken,total_pop=EH_mulliken(v,occupations,S)  #calculates Mulliken populations\n",
    "    v=np.round(v,decimals=2)\n",
    "    #EH_print(parameters,title,element_coord,Q,eh_basis_functs,no_electrons,S,H,v,e,occupations,reduced_Mulliken,total_pop,WH)\n",
    "    return S,H,eh_basis_functs,bf_index,v,no_electrons,emin    \n",
    "\n",
    "def extended_S_and_H(coords,atoms,displacements,parameters,dist_cutoff,eh_basis_functs,WH):\n",
    "# create lists to contain the S and H extension matrices\n",
    "    #print(\"inside extend\",len(coords))\n",
    "    map_S=[];map_S_tran=[];map_H=[];map_H_tran=[]\n",
    "#create coordinates of extended unit cell\n",
    "    for k in range(len(displacements)):\n",
    "        extension_coords=coords[:]\n",
    "        extension_atoms=atoms[:]\n",
    "        for i in range(len(coords)):\n",
    "            extension_coords.append([sum(xyz) for xyz in zip(coords[i], displacements[k])])\n",
    "            extension_atoms.append(atoms[i])\n",
    "        #print(\"ext\",extension_coords)\n",
    "#set up matrices for unit cell + 1 extension    \n",
    "        #extension_coords_au,extension_element_coord=coord_con_EHT(extension_coords,extension_atoms)   #convert coordinates\n",
    "        extension_eh_basis_functs=eh_basis_setupb(extension_atoms,parameters) # set up a list of basis functions\n",
    "        #extension_no_electrons=count_electrons(extension_atoms,Q)  # count the electrons (just to work out what's occupied at the end - has no impact on eigenvalues)     \n",
    "        extension_S=overlap_matrix_new(extension_eh_basis_functs,extension_coords,dist_cutoff)  #calculates overlap matrix\n",
    "        extension_H=Hamiltonian_matrix(extension_eh_basis_functs,extension_S,WH)   #calculates Hamiltonian matrix\n",
    "#slice out the relevant part of the matrix (the overlap between the unit cell and its neighbouring image)    \n",
    "        map_S.append(extension_S[0:len(eh_basis_functs),len(eh_basis_functs):len(extension_eh_basis_functs)])\n",
    "        map_H.append(extension_H[0:len(eh_basis_functs),len(eh_basis_functs):len(extension_eh_basis_functs)])\n",
    "#transpose the S and H matrices (need these for -ve points in k-space)\n",
    "        map_S_tran.append(np.transpose(extension_S[0:len(eh_basis_functs),len(eh_basis_functs):len(extension_eh_basis_functs)]))\n",
    "        map_H_tran.append(np.transpose(extension_H[0:len(eh_basis_functs),len(eh_basis_functs):len(extension_eh_basis_functs)]))\n",
    "        #print(\"map_S\",len(map_S),map_S)\n",
    "    return map_S,map_H,map_S_tran,map_H_tran\n",
    "\n",
    "#a function to test whether a matrix is positive definite (for debugging purposes only, S should always be PSD)\n",
    "def is_pos_def(S):\n",
    "    return np.all(np.linalg.eigvals(S) > 0)\n",
    "\n",
    "#sample the full BZ: various filters are in place to get the first BZ for various Bravais lattices\n",
    "def full_BZ_sample(kx,ky,kz,nptsx,nptsy,nptsz,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,symmetry,eh_basis_functs,plot_COOP,d1,d2,d3):\n",
    "    fail_count=0.\n",
    "    all_pts=[]\n",
    "    all_energies=[];all_contributions=[];all_coop=[];all_pts_x=[];all_pts_y=[];all_pts_z=[]\n",
    "    #print(A,B,C)\n",
    "    #print(0.5*A.max(),0.5*B.max(),0.5*C.max())\n",
    "    hit=0;miss=0\n",
    "    if d3:    \n",
    "        for kx_line in kx:\n",
    "            for ky_line in ky:\n",
    "                for kz_line in kz:\n",
    "                    carry_on=True\n",
    "                    ktot=[kx_line,ky_line,kz_line]\n",
    "                    if symmetry=='h':\n",
    "                        M_point=0.5*A\n",
    "                        plane_vector=ktot-M_point\n",
    "                        if np.dot(plane_vector,A)>0. or ky_line>kx_line/np.sqrt(3):  #check to see if point is outside the 1st BZ\n",
    "                            carry_on=False  \n",
    "                    elif symmetry=='m':\n",
    "                    #need to do half the first BZ here as symmetry is lower\n",
    "                        A_reflect=np.array([A[0],A[1],-A[2]])\n",
    "                        U_point=0.5*(A_reflect-C);B_point=0.5*A_reflect;Y_point=0.5*C;neg_U_point=-U_point\n",
    "                        plane_vectorU=[sum(xy) for xy in zip(ktot,[-1*z for z in U_point])]\n",
    "                        plane_vector_negU=[sum(xy) for xy in zip(ktot,[-1*z for z in neg_U_point])]\n",
    "                        plane_vectorB=[sum(xy) for xy in zip(ktot,[-1*z for z in B_point])]\n",
    "                        plane_vectorY=[sum(xy) for xy in zip(ktot,[-1*z for z in Y_point])]\n",
    "                        if (np.dot(plane_vectorU,(A_reflect-C))>0. or np.dot(plane_vectorB,A_reflect)>0. or np.dot(plane_vectorY,C)>0. or np.dot(plane_vector_negU,-U_point)>0.):  #check to see if point is inside the 1st BZ  #check to see if point is outside the 1st BZ\n",
    "                            carry_on=False   \n",
    "                    elif symmetry=='fcc':\n",
    "                        L_point=0.5*(A+B+C)\n",
    "                        plane_vector=ktot-L_point\n",
    "                        if np.dot(plane_vector,(A+B+C))>0.:  #check to see if point is outside the 1st BZ\n",
    "                            carry_on=False    \n",
    "                    elif symmetry=='bcc':\n",
    "                        #print(A,B,C)\n",
    "                        N_point1=0.5*A;N_point2=0.5*B;N_point3=0.5*C\n",
    "                        #print(N_point1,N_point2,N_point3)\n",
    "                        plane_vector1=[sum(xy) for xy in zip(ktot,[-1*z for z in N_point1])]\n",
    "                        plane_vector2=[sum(xy) for xy in zip(ktot,[-1*z for z in N_point2])]\n",
    "                        plane_vector3=[sum(xy) for xy in zip(ktot,[-1*z for z in N_point3])]                        \n",
    "                        if (np.dot(plane_vector1,[0.,0.,1.])>0. or np.dot(plane_vector2,[1.,0.,1.])>0. or np.dot(plane_vector3,[1.,1.,0.])>0.):  #check to see if point is inside the 1st BZ  #check to see if point is outside the 1st BZ\n",
    "                            carry_on=False  \n",
    "                            miss+=1;#print(\"miss\",kx_line,ky_line,kz_line);\n",
    "                        #else:\n",
    "                            #print(\"hit\",kx_line,ky_line,kz_line);hit+=1\n",
    "                    \n",
    "                    if carry_on==True:\n",
    "                #ktot=kx_line*A+ky_line*B+kz_line*C\n",
    "                #print(kx_line,ky_line,kz_line,\"in\")\n",
    "                        all_pts_x.append(ktot[0]);all_pts_y.append(ktot[1]);all_pts_z.append(ktot[2])\n",
    "            #compute S and H by superimposing contributions from neighbouring cells onto S. Need to initialise S and H as complex, even though unit cell S and H are real.\n",
    "                        final_S=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex);final_H=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex)            \n",
    "                        final_S+=S;final_H+=H\n",
    "                        for i in range(len(displacements)):\n",
    "                        #nb. the \"-1j\" and S/H_tran are used because the relevant matrix for displacement along -ve displacement vector is\n",
    "                        #just the transpose of the matrix for the +ve vector. This cuts the time for computing displacement vectors in half.\n",
    "                            final_S+=1.0*np.exp(1j*np.dot(ktot,displacements[i]))*map_S[i]+1.0*np.exp(-1j*np.dot(ktot,displacements[i]))*map_S_tran[i]\n",
    "                            final_H+=1.0*np.exp(1j*np.dot(ktot,displacements[i]))*map_H[i]+1.0*np.exp(-1j*np.dot(ktot,displacements[i]))*map_H_tran[i]\n",
    "                        if is_pos_def(final_S)==True:\n",
    "                    #print(kx_line,ky_line,kz_line,\"pass\")\n",
    "                            v,e,occupations=diagonalise_periodic(final_H,final_S,no_electrons)  #Solves generalised eigenvalue equation\n",
    "                            e=e.real\n",
    "                            all_energies.append([kx_line,ky_line,kz_line,e])\n",
    "                            all_pts.append([kx_line,ky_line,kz_line])\n",
    "                            contributions,coop=contributions_to_PDOS(v,occupations,final_S,plot_COOP)   #this works out the various contributions to each level (for PDOS)\n",
    "                            all_contributions.append([kx_line,ky_line,kz_line,contributions])\n",
    "                            if plot_COOP:            \n",
    "                                all_coop.append([kx_line,ky_line,kz_line,coop])\n",
    "                        else:\n",
    "                #    print(kx_line,ky_line,kz_line,\"fail\")\n",
    "                            fail_count+=1\n",
    "        #print(\"hit/miss\",hit,miss)\n",
    "    elif d2:    \n",
    "        for kx_line in kx:\n",
    "            for ky_line in ky:\n",
    "                carry_on=True\n",
    "                ktot=[kx_line,ky_line,0.]\n",
    "                if symmetry=='2d_h':\n",
    "                    M_point=0.5*A\n",
    "                    plane_vector=ktot-M_point\n",
    "                    if np.dot(plane_vector,A)>0. or ky_line>kx_line/np.sqrt(3):  #check to see if point is outside the 1st BZ\n",
    "                        carry_on=False  \n",
    "                        miss+=1\n",
    "                    else:\n",
    "                        hit+=1\n",
    "                if carry_on==True:\n",
    "                    all_pts_x.append(ktot[0]);all_pts_y.append(ktot[1])\n",
    "            #compute S and H by superimposing contributions from neighbouring cells onto S. Need to initialise S and H as complex, even though unit cell S and H are real.\n",
    "                    final_S=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex);final_H=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex)            \n",
    "                    final_S+=S;final_H+=H\n",
    "                    for i in range(len(displacements)):\n",
    "                        #nb. the \"-1j\" and S/H_tran are used because the relevant matrix for displacement along -ve displacement vector is\n",
    "                        #just the transpose of the matrix for the +ve vector. This cuts the time for computing displacement vectors in half.\n",
    "                        final_S+=1.0*np.exp(1j*np.dot(ktot,displacements[i]))*map_S[i]+1.0*np.exp(-1j*np.dot(ktot,displacements[i]))*map_S_tran[i]\n",
    "                        final_H+=1.0*np.exp(1j*np.dot(ktot,displacements[i]))*map_H[i]+1.0*np.exp(-1j*np.dot(ktot,displacements[i]))*map_H_tran[i]\n",
    "                    if is_pos_def(final_S)==True:\n",
    "                    #print(kx_line,ky_line,kz_line,\"pass\")\n",
    "                        v,e,occupations=diagonalise_periodic(final_H,final_S,no_electrons)  #Solves generalised eigenvalue equation\n",
    "                        e=e.real\n",
    "                        all_energies.append([kx_line,ky_line,0.,e])\n",
    "                        all_pts.append([kx_line,ky_line,0.])\n",
    "                        contributions,coop=contributions_to_PDOS(v,occupations,final_S,plot_COOP)   #this works out the various contributions to each level (for PDOS)\n",
    "                        all_contributions.append([kx_line,ky_line,0.,contributions])\n",
    "                        if plot_COOP:            \n",
    "                            all_coop.append([kx_line,ky_line,0.,coop])\n",
    "                    else:\n",
    "                #    print(kx_line,ky_line,kz_line,\"fail\")\n",
    "                        fail_count+=1\n",
    "        #print(\"hit/miss\",hit,miss)\n",
    "    elif d1:    \n",
    "        for kz_line in kz:\n",
    "            ktot=[0.,0.,kz_line]\n",
    "                #ktot=kx_line*A+ky_line*B+kz_line*C\n",
    "                #print(kx_line,ky_line,kz_line,\"in\")\n",
    "            all_pts_z.append(ktot[2])\n",
    "            #compute S and H by superimposing contributions from neighbouring cells onto S. Need to initialise S and H as complex, even though unit cell S and H are real.\n",
    "            final_S=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex);final_H=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex)            \n",
    "            final_S+=S;final_H+=H\n",
    "            for i in range(len(displacements)):\n",
    "                        #nb. the \"-1j\" and S/H_tran are used because the relevant matrix for displacement along -ve displacement vector is\n",
    "                        #just the transpose of the matrix for the +ve vector. This cuts the time for computing displacement vectors in half.\n",
    "                final_S+=1.0*np.exp(1j*np.dot(ktot,displacements[i]))*map_S[i]+1.0*np.exp(-1j*np.dot(ktot,displacements[i]))*map_S_tran[i]\n",
    "                final_H+=1.0*np.exp(1j*np.dot(ktot,displacements[i]))*map_H[i]+1.0*np.exp(-1j*np.dot(ktot,displacements[i]))*map_H_tran[i]\n",
    "            if is_pos_def(final_S)==True:\n",
    "                    #print(kx_line,ky_line,kz_line,\"pass\")\n",
    "                v,e,occupations=diagonalise_periodic(final_H,final_S,no_electrons)  #Solves generalised eigenvalue equation\n",
    "                e=e.real\n",
    "                all_energies.append([0.,0.,kz_line,e])\n",
    "                all_pts.append([0.,0.,kz_line])\n",
    "                contributions,coop=contributions_to_PDOS(v,occupations,final_S,plot_COOP)   #this works out the various contributions to each level (for PDOS)\n",
    "                all_contributions.append([0.,0.,kz_line,contributions])\n",
    "                if plot_COOP:            \n",
    "                    all_coop.append([0.,0.,kz_line,coop])\n",
    "            else:\n",
    "                #    print(kx_line,ky_line,kz_line,\"fail\")\n",
    "                fail_count+=1\n",
    "\n",
    "    #if d3:\n",
    "        #print(\"success\",nptsx*nptsy*nptsz-fail_count,\"fail_count\",fail_count)\n",
    "#    elif d2:\n",
    "#        print(\"success\",nptsx*nptsy-fail_count,\"fail_count\",fail_count)\n",
    "#    elif d1:\n",
    "#        print(\"success\",nptsz-fail_count,\"fail_count\",fail_count)\n",
    "    return all_energies,all_pts_x,all_pts_y,all_pts_z,all_contributions,all_coop,all_pts\n",
    "   \n",
    "#NOTES\n",
    "#all_energies is a list containing [kx,ky,[energies]]. its dimensions are nptsx x nptsy\n",
    "#all_contributions is a list of contributions to each MO. its dimensions are len(basis) x len(basis).\n",
    "#all_contributions[0] contains a list of contributions of each basis function to MO 1 etc.\n",
    "#all_coop is a 2-dimensional list of COOPS per basis function. So all_coop[0][3][0] is a 2D array of dimension len(basis) x len(basis)\n",
    "#containing the contributions to COOP from basis function pair[i,j] for MO1 etc. \n",
    "\n",
    "\n",
    "#sample the full BZ: various filters are in place to get the first BZ for various Bravais lattices\n",
    "\n",
    "\n",
    "\n",
    "#function that interpolates the k-point grid on a finer mesh\n",
    "def interpolate_BZ(interp_pointsx,interp_pointsy,interp_pointsz,kx,ky,kz,all_energies,eh_basis_functs,d1,d2,d3):\n",
    "    #set up an empty list for the kx,ky points        \n",
    "    all_pts=[]\n",
    "    #set up the kx,ky grid\n",
    "    if d3:\n",
    "        #print(\"here\")\n",
    "        #print(all_energies)\n",
    "        kxmax=kx.max();kxmin=kx.min();kymax=ky.max();kymin=ky.min();kzmax=kz.max();kzmin=kz.min()\n",
    "        #print(kxmax,kymax,kzmax,interp_pointsx,interp_pointsy,interp_pointsz,d1,d2,d3)\n",
    "        grid_kx,grid_ky,grid_kz=np.mgrid[kxmin:kxmax:interp_pointsx*1j, kymin:kymax:interp_pointsy*1j,kzmin:kzmax:interp_pointsz*1j]\n",
    "    #set up empty lists for various things    \n",
    "        points=[];grid_energies=[];grid=[]\n",
    "    #grid_energies will hold a list of the form  \n",
    "    #[[eigenval1 at kpt1,eigenval1 at kpt2,...],[eigenval2 at kpt1,....],[],.....]\n",
    "    #grid holds the corresponding data on the finer mesh\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid_energies.append([]);grid.append([])\n",
    "        #for every MO in the list, add an empty list to grid_energies\n",
    "        #so we now have a nested list  [[],[],[],.......]  one \n",
    "        #likewise for grid\n",
    "        for item in all_energies:   #recall all energies is a list containing [kx,ky,kz,[list of energies]] for each kpt\n",
    "            points.append([item[0],item[1],item[2]])   #add the kpts to points\n",
    "            for i in range(len(item[3])):    #for each MO in the list\n",
    "                grid_energies[i].append(item[3][i])   #add it to grid energies [i]\n",
    "    #so now we have a nested list of grid_energies   [[eigenval1 at kpt1,eigenval1 at kpt2,...],[eigenval2 at kpt1,....],[],.....]    \n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid[i]=interpolate.griddata(points,grid_energies[i],(grid_kx,grid_ky,grid_kz),method='linear')\n",
    "        #note that if point on the grid falls outside the original 1st BZ, an array of Nans will be returned.\n",
    "        #print(min(grid))\n",
    "    #now grid each sublist of grid_energies in turn\n",
    "    \n",
    "    #now we need to put the lists back into their original format (i.e. n different eigenvalues for each kpt)\n",
    "        eigenvalue_list=[]\n",
    "    #loop over components of fine grid twice\n",
    "        for i in range(np.shape(grid)[1]):\n",
    "            for j in range(np.shape(grid)[2]):\n",
    "                for k in range(np.shape(grid)[3]):\n",
    "            #collect the kpt location\n",
    "                    all_pts.append([grid_kx[i][j][k],grid_ky[i][j][k],grid_kz[i][j][k]])\n",
    "            #each combination i,j corresponds to a unique kpt in the interpolated space\n",
    "            #now collect together the n eigenvalues for this kpt \n",
    "                    one_cell_eigenvalue_list=[]\n",
    "            #loop over all the kpts in the fine grid, picking out the kth eigenvalue\n",
    "                    for m in range(np.shape(grid)[0]):\n",
    "                        one_cell_eigenvalue_list.append(grid[m][i][j][k])\n",
    "            #collect these together as a list of format [kx,ky,[eigenvalues]], precisely as the original all_energies was\n",
    "                    eigenvalue_list.append([grid_kx[i][j][k],grid_ky[i][j][k],grid_kz[i][j][k],np.array(one_cell_eigenvalue_list)])\n",
    "    elif d2:\n",
    "        kxmax=kx.max();kxmin=kx.min();kymax=ky.max();kymin=ky.min()\n",
    "        grid_kx,grid_ky=np.mgrid[kxmin:kxmax:interp_pointsx*1j, kymin:kymax:interp_pointsy*1j]\n",
    "    #set up empty lists for various things    \n",
    "        points=[];grid_energies=[];grid=[]\n",
    "    #grid_energies will hold a list of the form  \n",
    "    #[[eigenval1 at kpt1,eigenval1 at kpt2,...],[eigenval2 at kpt1,....],[],.....]\n",
    "    #grid holds the corresponding data on the finer mesh\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid_energies.append([]);grid.append([])\n",
    "        #for every MO in the list, add an empty list to grid_energies\n",
    "        #so we now have a nested list  [[],[],[],.......]  one \n",
    "        #likewise for grid\n",
    "        for item in all_energies:   #recall all energies is a list containing [kx,ky,kz,[list of energies]] for each kpt\n",
    "            points.append([item[0],item[1]])   #add the kpts to points\n",
    "            for i in range(len(item[3])):    #for each MO in the list\n",
    "                grid_energies[i].append(item[3][i])   #add it to grid energies [i]\n",
    "    #so now we have a nested list of grid_energies   [[eigenval1 at kpt1,eigenval1 at kpt2,...],[eigenval2 at kpt1,....],[],.....]    \n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid[i]=interpolate.griddata(points,grid_energies[i],(grid_kx,grid_ky),method='linear')\n",
    "        #note that if point on the grid falls outside the original 1st BZ, an array of Nans will be returned.\n",
    "        #print(min(grid))\n",
    "    #now grid each sublist of grid_energies in turn\n",
    "    \n",
    "    #now we need to put the lists back into their original format (i.e. n different eigenvalues for each kpt)\n",
    "        eigenvalue_list=[]\n",
    "    #loop over components of fine grid twice\n",
    "        for i in range(np.shape(grid)[1]):\n",
    "            for j in range(np.shape(grid)[2]):\n",
    "                \n",
    "            #collect the kpt location\n",
    "                all_pts.append([grid_kx[i][j],grid_ky[i][j],0.])\n",
    "            #each combination i,j corresponds to a unique kpt in the interpolated space\n",
    "            #now collect together the n eigenvalues for this kpt \n",
    "                one_cell_eigenvalue_list=[]\n",
    "            #loop over all the kpts in the fine grid, picking out the kth eigenvalue\n",
    "                for m in range(np.shape(grid)[0]):\n",
    "                    one_cell_eigenvalue_list.append(grid[m][i][j])\n",
    "            #collect these together as a list of format [kx,ky,[eigenvalues]], precisely as the original all_energies was\n",
    "                eigenvalue_list.append([grid_kx[i][j],grid_ky[i][j],0.,np.array(one_cell_eigenvalue_list)])\n",
    "\n",
    "    elif d1:\n",
    "        kzmax=kz.max();kzmin=kz.min()\n",
    "        grid_kz=np.linspace(kzmin,kzmax,interp_pointsz)\n",
    "        points=[];grid_energies=[];grid=[]\n",
    "    #grid_energies will hold a list of the form  \n",
    "    #[[eigenval1 at kpt1,eigenval1 at kpt2,...],[eigenval2 at kpt1,....],[],.....]\n",
    "    #grid holds the corresponding data on the finer mesh\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid_energies.append([]);grid.append([])\n",
    "        for item in all_energies:   #recall all energies is a list containing [kx,ky,kz,[list of energies]] for each kpt\n",
    "            points.append(item[2])   #add the kpts to points\n",
    "            for i in range(len(item[3])):    #for each MO in the list\n",
    "                grid_energies[i].append(item[3][i])   #add it to grid energies [i]\n",
    "        #print(grid_kz,points,grid_energies)\n",
    "        for i in range(len(item[3])):    #for each MO in the list\n",
    "            grid[i]=np.interp(grid_kz,points,grid_energies[i])#add it to grid energies [i]\n",
    "                #note that if point on the grid falls outside the original 1st BZ, an array of Nans will be returned.\n",
    "        #print(min(grid))\n",
    "    #now grid each sublist of grid_energies in turn\n",
    "    \n",
    "    #now we need to put the lists back into their original format (i.e. n different eigenvalues for each kpt)\n",
    "        eigenvalue_list=[]\n",
    "    #loop over components of fine grid twice\n",
    "        for i in range(interp_pointsz):                \n",
    "            #collect the kpt location\n",
    "                all_pts.append([0.,0.,grid_kz[i]])\n",
    "            #each combination i,j corresponds to a unique kpt in the interpolated space\n",
    "            #now collect together the n eigenvalues for this kpt \n",
    "                one_cell_eigenvalue_list=[]\n",
    "            #loop over all the kpts in the fine grid, picking out the kth eigenvalue\n",
    "                for m in range(np.shape(grid)[0]):\n",
    "                    one_cell_eigenvalue_list.append(grid[m][i])\n",
    "            #collect these together as a list of format [kx,ky,[eigenvalues]], precisely as the original all_energies was\n",
    "                eigenvalue_list.append([0.,0.,grid_kz[i],np.array(one_cell_eigenvalue_list)])\n",
    "    #print(eigenvalue_list)\n",
    "    return eigenvalue_list,all_pts\n",
    "#eigenvalue_list is a list containing [kx,ky,[energies]] interpolated over the large grid (interp_ptsx x interp_ptsy)\n",
    "#format is exactly the same as \"all_energies\" produced in full_BZ_sample\n",
    "\n",
    "#function that interpolates the k-point grid on a finer mesh\n",
    "\n",
    "def interpolate_coop_BZ(interp_pointsx,interp_pointsy,interp_pointsz,kx,ky,kz,all_coop,eh_basis_functs):\n",
    "    #set up an empty list for the kx,ky points    \n",
    "    #set up the kx,ky grid\n",
    "    kxmax=kx.max();kxmin=kx.min();kymax=ky.max();kymin=ky.min();kzmax=kz.max();kzmin=kz.min()\n",
    "    grid_kx,grid_ky,grid_kz=np.mgrid[kxmin:kxmax:interp_pointsx*1j, kymin:kymax:interp_pointsy*1j,kzmin:kzmax:interp_pointsz*1j]\n",
    "    #print(\"grid len\",len(grid_kx))\n",
    "    #set up empty lists for various things    \n",
    "    points=[];grid_coops=[];grid=[]\n",
    "    #grid_energies will hold a list of the form  \n",
    "    #[[eig1 at kpt1,eig1 at kpt2,...],[eig2 at kpt1,....],[],.....]\n",
    "    #grid holds the corresponding data on the finer mesh\n",
    "    \n",
    "    #set up the arrays to store the coops of the coarse grid\n",
    "    for i in range(len(eh_basis_functs)):\n",
    "        grid_coops.append([]);grid.append([])\n",
    "        #for every MO in the list, add an empty list to grid_energies\n",
    "        #so we now have a nested list  [[],[],[],.......]  one \n",
    "        #likewise for grid\n",
    "        for i2 in range(len(eh_basis_functs)):\n",
    "            grid_coops[i].append([]);grid[i].append([])\n",
    "            for i3 in range(len(eh_basis_functs)):\n",
    "                grid_coops[i][i2].append([]);grid[i][i2].append([])\n",
    "        #now we add an extra level of nesting to contain the components of each MO  \n",
    "            #[[[comp1 of eig1 at kpt1,comp1 of eig1 at kpt2,comp1 of eig1 at kpt3],....]\\\n",
    "            #,[comp2 of eig1 at kpt1,comp2 of eig1 at kpt2,.......],[],[]...]\\\n",
    "            #[comp1 of eig2 at kpt1],......\n",
    "            #[compn of eign at kptx]]]\n",
    "    \n",
    "    #now fill them in\n",
    "    for item in all_coop:   #recall all contributions is a list containing [kx,ky,[[list of components of eig1],[componenst of eig2],...]] for each kpt\n",
    "        points.append([item[0],item[1],item[2]])   #add the kpts to points\n",
    "        for i in range(len(item[3])):    #this is the mo\n",
    "            for i2 in range(len(item[3][0])):  #this is the contribution\n",
    "                for i3 in range(len(item[3][0])):\n",
    "                    #print(item[2])\n",
    "                    grid_coops[i][i2][i3].append(item[3][i][i2][i3])   #add it to grid contributions [i]\n",
    "\n",
    "            \n",
    "    for i in range(len(eh_basis_functs)):\n",
    "        for j in range(len(eh_basis_functs)):\n",
    "            for k in range(len(eh_basis_functs)):\n",
    "                grid[i][j][k]=interpolate.griddata(points,grid_coops[i][j][k],(grid_kx,grid_ky,grid_kz),method='linear')\n",
    "                #note that if point on the grid falls outside the original 1st BZ, an array of Nans will be returned.\n",
    "    #now grid each sublist of grid_contributions in turn\n",
    "    \n",
    "    #now we need to put the lists back into their original format (i.e. n different eigenvalues for each kpt)\n",
    "    #set up the list    \n",
    "    coop_list=[]\n",
    "    #loop over components of fine grid twice (to define the kpt)\n",
    "    for i in range(len(grid[0][0][0])):\n",
    "        for j in range(len(grid[0][0][0])):\n",
    "            for k in range(len(grid[0][0][0])):\n",
    "            #collect the kpt location\n",
    "            #all_pts.append([grid_kx[i][j],grid_ky[i][j]])\n",
    "            #each combination i,j corresponds to a unique kpt in the interpolated space\n",
    "            #now collect together the n eigenvalues for this kpt \n",
    "            \n",
    "            #loop over all the kpts in the fine grid, picking out the kth eigenvalue and lth contribution to it\n",
    "                cum_coop_list=[]\n",
    "                for l in range(len(grid)):\n",
    "                #print(\"lenb\",len(grid))\n",
    "                #create a container for the reconstituted coops\n",
    "                    one_cell_coop_list=[]\n",
    "                    for x in range(len(eh_basis_functs)):\n",
    "                        one_cell_coop_list.append([])\n",
    "                        for y in range(len(eh_basis_functs)):\n",
    "                            one_cell_coop_list[x].append([])\n",
    "                    \n",
    "                #now fill it\n",
    "                    for m in range(len(grid)):\n",
    "                        for n in range(len(grid)):\n",
    "                            #print(m,n,one_cell_coop_list[m][n])\n",
    "                            one_cell_coop_list[m][n].append(grid[l][m][n][i][j][k])\n",
    "                            #one_cell_coop_list[m][n].append(grid[l][m][n][i][j][k])\n",
    "                    cum_coop_list.append(one_cell_coop_list)    #list of conts to all eigs at one kpt\n",
    "            #collect these together as a list of format [kx,ky,[eigenvalues]], precisely as the original all_energies was\n",
    "                coop_list.append([grid_kx[i][j][k],grid_ky[i][j][k],grid_kz[i][j][k],np.array(cum_coop_list)])\n",
    "\n",
    "    return coop_list\n",
    "\n",
    "#function that interpolates the k-point grid on a finer mesh\n",
    "def interpolate_contributions_BZ(interp_pointsx,interp_pointsy,interp_pointsz,kx,ky,kz,all_contributions,eh_basis_functs,d1,d2,d3):\n",
    "    #set up an empty list for the kx,ky points    \n",
    "    #set up the kx,ky grid\n",
    "    if d3:    \n",
    "        kxmax=kx.max();kxmin=kx.min();kymax=ky.max();kymin=ky.min();kzmax=kz.max();kzmin=kz.min()\n",
    "        grid_kx,grid_ky,grid_kz=np.mgrid[kxmin:kxmax:interp_pointsx*1j, kymin:kymax:interp_pointsy*1j,kzmin:kzmax:interp_pointsz*1j]\n",
    "    #print(\"grid len\",len(grid_kx))\n",
    "    \n",
    "    #set up empty lists for various things    \n",
    "        points=[];grid_contributions=[];grid=[]\n",
    "    #grid_energies will hold a list of the form  \n",
    "    #[[eig1 at kpt1,eig1 at kpt2,...],[eig2 at kpt1,....],[],.....]\n",
    "    #grid holds the corresponding data on the finer mesh\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid_contributions.append([]);grid.append([])\n",
    "        #for every MO in the list, add an empty list to grid_energies\n",
    "        #so we now have a nested list  [[],[],[],.......]  one \n",
    "        #likewise for grid\n",
    "            for i2 in range(len(eh_basis_functs)):\n",
    "                grid_contributions[i].append([]);grid[i].append([])\n",
    "        #now we add an extra level of nesting to contain the components of each MO  \n",
    "            #[[[comp1 of eig1 at kpt1,comp1 of eig1 at kpt2,comp1 of eig1 at kpt3],....]\\\n",
    "            #,[comp2 of eig1 at kpt1,comp2 of eig1 at kpt2,.......],[],[]...]\\\n",
    "            #[comp1 of eig2 at kpt1],......\n",
    "            #[compn of eign at kptx]]]\n",
    "    \n",
    "        for item in all_contributions:   #recall all contributions is a list containing [kx,ky,[[list of components of eig1],[componenst of eig2],...]] for each kpt\n",
    "            points.append([item[0],item[1],item[2]])   #add the kpts to points\n",
    "            for i in range(len(item[3])):    #this is the mo\n",
    "                for i2 in range(len(item[3])):  #this is the contribution\n",
    "                    grid_contributions[i][i2].append(item[3][i][i2])   #add it to grid contributions [i]\n",
    "\n",
    "            \n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            for j in range(len(eh_basis_functs)):\n",
    "                grid[i][j]=interpolate.griddata(points,grid_contributions[i][j],(grid_kx,grid_ky,grid_kz),method='linear')\n",
    "            #note that if point on the grid falls outside the original 1st BZ, an array of Nans will be returned.\n",
    "    #now grid each sublist of grid_contributions in tur\n",
    "    \n",
    "    #now we need to put the lists back into their original format (i.e. n different eigenvalues for each kpt)\n",
    "    #set up the list    \n",
    "        contribution_list=[]\n",
    "    #print(len(grid[0]))\n",
    "    #print(shape(grid))\n",
    "    #loop over components of fine grid twice (to define the kpt)\n",
    "        for i in range(np.shape(grid)[2]):\n",
    "            for j in range(np.shape(grid)[3]):\n",
    "                for k in range(np.shape(grid)[4]):\n",
    "            #collect the kpt location\n",
    "            #all_pts.append([grid_kx[i][j],grid_ky[i][j]])\n",
    "            #each combination i,j corresponds to a unique kpt in the interpolated space\n",
    "            #now collect together the n eigenvalues for this kpt \n",
    "            \n",
    "            #loop over all the kpts in the fine grid, picking out the kth eigenvalue and lth contribution to it\n",
    "                    cum_list=[]\n",
    "                    for l in range(np.shape(grid)[0]):                \n",
    "                        one_cell_one_eig_cont_list=[]\n",
    "                        for m in range(np.shape(grid)[1]):\n",
    "                            one_cell_one_eig_cont_list.append(grid[l][m][i][j][k])  #list of contributions to one eig at one kpt\n",
    "                        cum_list.append(one_cell_one_eig_cont_list)    #list of conts to all eigs at one kpt\n",
    "            #collect these together as a list of format [kx,ky,[eigenvalues]], precisely as the original all_energies was\n",
    "                    contribution_list.append([grid_kx[i][j][k],grid_ky[i][j][k],grid_kz[i][j][k],np.array(cum_list)])\n",
    "\n",
    "    elif d2:    \n",
    "        kxmax=kx.max();kxmin=kx.min();kymax=ky.max();kymin=ky.min()\n",
    "        grid_kx,grid_ky=np.mgrid[kxmin:kxmax:interp_pointsx*1j, kymin:kymax:interp_pointsy*1j]\n",
    "    #print(\"grid len\",len(grid_kx))\n",
    "    \n",
    "    #set up empty lists for various things    \n",
    "        points=[];grid_contributions=[];grid=[]\n",
    "    #grid_energies will hold a list of the form  \n",
    "    #[[eig1 at kpt1,eig1 at kpt2,...],[eig2 at kpt1,....],[],.....]\n",
    "    #grid holds the corresponding data on the finer mesh\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid_contributions.append([]);grid.append([])\n",
    "        #for every MO in the list, add an empty list to grid_energies\n",
    "        #so we now have a nested list  [[],[],[],.......]  one \n",
    "        #likewise for grid\n",
    "            for i2 in range(len(eh_basis_functs)):\n",
    "                grid_contributions[i].append([]);grid[i].append([])\n",
    "        #now we add an extra level of nesting to contain the components of each MO  \n",
    "            #[[[comp1 of eig1 at kpt1,comp1 of eig1 at kpt2,comp1 of eig1 at kpt3],....]\\\n",
    "            #,[comp2 of eig1 at kpt1,comp2 of eig1 at kpt2,.......],[],[]...]\\\n",
    "            #[comp1 of eig2 at kpt1],......\n",
    "            #[compn of eign at kptx]]]\n",
    "    \n",
    "        for item in all_contributions:   #recall all contributions is a list containing [kx,ky,[[list of components of eig1],[componenst of eig2],...]] for each kpt\n",
    "            points.append([item[0],item[1]])   #add the kpts to points\n",
    "            for i in range(len(item[3])):    #this is the mo\n",
    "                for i2 in range(len(item[3])):  #this is the contribution\n",
    "                    grid_contributions[i][i2].append(item[3][i][i2])   #add it to grid contributions [i]\n",
    "\n",
    "            \n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            for j in range(len(eh_basis_functs)):\n",
    "                grid[i][j]=interpolate.griddata(points,grid_contributions[i][j],(grid_kx,grid_ky),method='linear')\n",
    "            #note that if point on the grid falls outside the original 1st BZ, an array of Nans will be returned.\n",
    "    #now grid each sublist of grid_contributions in tur\n",
    "    \n",
    "    #now we need to put the lists back into their original format (i.e. n different eigenvalues for each kpt)\n",
    "    #set up the list    \n",
    "        contribution_list=[]\n",
    "    #print(len(grid[0]))\n",
    "    #print(shape(grid))\n",
    "    #loop over components of fine grid twice (to define the kpt)\n",
    "        for i in range(np.shape(grid)[2]):\n",
    "            for j in range(np.shape(grid)[3]):\n",
    "            #collect the kpt location\n",
    "            #all_pts.append([grid_kx[i][j],grid_ky[i][j]])\n",
    "            #each combination i,j corresponds to a unique kpt in the interpolated space\n",
    "            #now collect together the n eigenvalues for this kpt \n",
    "            \n",
    "            #loop over all the kpts in the fine grid, picking out the kth eigenvalue and lth contribution to it\n",
    "                cum_list=[]\n",
    "                for l in range(np.shape(grid)[0]):                \n",
    "                    one_cell_one_eig_cont_list=[]\n",
    "                    for m in range(np.shape(grid)[1]):\n",
    "                        one_cell_one_eig_cont_list.append(grid[l][m][i][j])  #list of contributions to one eig at one kpt\n",
    "                    cum_list.append(one_cell_one_eig_cont_list)    #list of conts to all eigs at one kpt\n",
    "            #collect these together as a list of format [kx,ky,[eigenvalues]], precisely as the original all_energies was\n",
    "                contribution_list.append([grid_kx[i][j],grid_ky[i][j],0,np.array(cum_list)])\n",
    "    elif d1:    \n",
    "        kzmax=kz.max();kzmin=kz.min()\n",
    "        grid_kz=np.linspace(kzmin,kzmax,interp_pointsz)\n",
    "    #print(\"grid len\",len(grid_kx))\n",
    "    \n",
    "    #set up empty lists for various things    \n",
    "        points=[];grid_contributions=[];grid=[]\n",
    "    #grid_energies will hold a list of the form  \n",
    "    #[[eig1 at kpt1,eig1 at kpt2,...],[eig2 at kpt1,....],[],.....]\n",
    "    #grid holds the corresponding data on the finer mesh\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            grid_contributions.append([]);grid.append([])\n",
    "        #for every MO in the list, add an empty list to grid_energies\n",
    "        #so we now have a nested list  [[],[],[],.......]  one \n",
    "        #likewise for grid\n",
    "            for i2 in range(len(eh_basis_functs)):\n",
    "                grid_contributions[i].append([]);grid[i].append([])\n",
    "        #now we add an extra level of nesting to contain the components of each MO  \n",
    "            #[[[comp1 of eig1 at kpt1,comp1 of eig1 at kpt2,comp1 of eig1 at kpt3],....]\\\n",
    "            #,[comp2 of eig1 at kpt1,comp2 of eig1 at kpt2,.......],[],[]...]\\\n",
    "            #[comp1 of eig2 at kpt1],......\n",
    "            #[compn of eign at kptx]]]\n",
    "    \n",
    "        for item in all_contributions:   #recall all contributions is a list containing [kx,ky,[[list of components of eig1],[componenst of eig2],...]] for each kpt\n",
    "            points.append(item[2])   #add the kpts to points\n",
    "            for i in range(len(item[3])):    #this is the mo\n",
    "                for i2 in range(len(item[3])):  #this is the contribution\n",
    "                    grid_contributions[i][i2].append(item[3][i][i2])   #add it to grid contributions [i]\n",
    "\n",
    "        #print(grid_contributions[0][0])\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            for j in range(len(eh_basis_functs)):\n",
    "                grid[i][j]=np.interp(grid_kz,points,grid_contributions[i][j])\n",
    "            #note that if point on the grid falls outside the original 1st BZ, an array of Nans will be returned.\n",
    "    #now grid each sublist of grid_contributions in tur\n",
    "    \n",
    "    #now we need to put the lists back into their original format (i.e. n different eigenvalues for each kpt)\n",
    "    #set up the list    \n",
    "        contribution_list=[]\n",
    "    #print(len(grid[0]))\n",
    "    #print(shape(grid))\n",
    "    #loop over components of fine grid twice (to define the kpt)\n",
    "        for i in range(interp_pointsz):\n",
    "            #collect the kpt location\n",
    "            #all_pts.append([grid_kx[i][j],grid_ky[i][j]])\n",
    "            #each combination i,j corresponds to a unique kpt in the interpolated space\n",
    "            #now collect together the n eigenvalues for this kpt \n",
    "            \n",
    "            #loop over all the kpts in the fine grid, picking out the kth eigenvalue and lth contribution to it\n",
    "                cum_list=[]\n",
    "                for l in range(np.shape(grid)[0]):                \n",
    "                    one_cell_one_eig_cont_list=[]\n",
    "                    for m in range(np.shape(grid)[1]):\n",
    "                        one_cell_one_eig_cont_list.append(grid[l][m][i])  #list of contributions to one eig at one kpt\n",
    "                    cum_list.append(one_cell_one_eig_cont_list)    #list of conts to all eigs at one kpt\n",
    "            #collect these together as a list of format [kx,ky,[eigenvalues]], precisely as the original all_energies was\n",
    "                contribution_list.append([0,0,grid_kz[i],np.array(cum_list)])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    #print(\"len contributionss\",len(all_contributions),len(contribution_list))        \n",
    "    return contribution_list\n",
    "\n",
    "#function that finds the index of the nearest kpt in the coarse grid to one in the fine (interpolated) grid\n",
    "#redundant now - was using it to try to avoid interpolating contributions but it's very slow\n",
    "def find_nearest_kpt(kpt_index,kx_line,ky_line,all_pts,kxmax,kymax):\n",
    "    min_dist=1000.   #initailise minimum distance to arbitrary large value\n",
    "    for i in range(len(all_pts)):\n",
    "            dist=np.linalg.norm([sum(xyz) for xyz in zip(all_pts[i],[-kx_line,-ky_line])])\n",
    "            if dist<min_dist:\n",
    "                index=i\n",
    "                min_dist=dist\n",
    "    return index\n",
    "\n",
    "#find the Fermi level\n",
    "def fermi_level(all_energies,E_pts,Emin,DOS_min,Emax,all_contributions,eh_basis_functs,plot_COOP,mesh,span,no_electrons):    \n",
    "    #plot_COOP=True\n",
    "#generate a nested list containing Energy across a given range and the cumulative number of occupied states\n",
    "#we get this by looping over energies in increasing order and for each energy, looping over the first BZ\n",
    "#if any energy in the eigenvalue list falls below the Energy, we add one to the count. Total number must then be\n",
    "#divided by the npts in the BZ at the end. n.b it doesn't matter that we only scan over 1 quadrant of the first BZ \n",
    "#because we divide by number of points - if we generated the entire BZ (8 times as large) we would just have to divide\n",
    "#by 8 times as many points.\n",
    "    fermi_list=[];Proj_states_list=[];coop_list=[]\n",
    "    Emin=min([Emin,DOS_min])\n",
    "    Energy_range=np.linspace(Emin,Emax,E_pts)\n",
    "    #loop over an energy range from below the lowest occupied level to somewhere above Ef\n",
    "    #first generate a list of energies and number of occupied states        \n",
    "    for Energy in Energy_range:   #loop over all energies in the range\n",
    "        #create a nested list (fermi_list) which contains the energy and the cumulative number of states that lie below this energy     \n",
    "        number_of_points_sampled=0  #total number of states inside the BZ (always equal to the total number unless interpolate_flag==True)       \n",
    "        Nstates=0;     #Nstates is the number of states that falls below a particular energy\n",
    "        Proj_states=np.zeros(len(eh_basis_functs))   #Proj_states is a list which breaks down the state into individual AO contrbutions\n",
    "        coop=np.zeros((len(eh_basis_functs),len(eh_basis_functs)))   #initialise coop - it is an integer as I'm only doing one pair of basis functions\n",
    "        #loop over all lists of energies (one per pair of k points) in all_energies\n",
    "        #print(\"lens\",len(all_energies),len(all_energies[0][3]),len(eh_basis_functs))\n",
    "                \n",
    "        for kpt_index in range(len(all_energies)):    #loop over the individual kpts\n",
    "            #print(all_energies[kpt_index])\n",
    "            if not np.isnan(all_energies[kpt_index][3][0]):  #test to see if elements are Nans: if they are, this means that the point in interpolated grid fell outside the 1st BZ\n",
    "                number_of_points_sampled+=1\n",
    "            #print(\"k\",kpt_index)\n",
    "                kx_line=all_energies[kpt_index][0];ky_line=all_energies[kpt_index][1];kz_line=all_energies[kpt_index][2]            \n",
    "                for eigenvalue_index in range(len(all_energies[kpt_index][3])):  #loop over all the eigenvalues at each kpt\n",
    "                    #print(\"eig\",eigenvalue_index) \n",
    "                    #print(\"here\",all_energies[kpt_index][3][eigenvalue_index])\n",
    "                    if all_energies[kpt_index][3][eigenvalue_index]<Energy:   #if the eigenvalue is below the value 'Energy', add one to Nstates\n",
    "                        Nstates+=1\n",
    "                    #now do the projected states  (i.e. weight Nstates by the contribution of each AO to the MO)\n",
    "                        for basis_functioni in range(len(eh_basis_functs)):        #loop over all the basis functions\n",
    "                        #print(\"i\",basis_functioni)                     \n",
    "                            Proj_states[basis_functioni]+=all_contributions[kpt_index][3][eigenvalue_index][basis_functioni]   #add the various components to the relevant element of Proj_states\n",
    "                            if plot_COOP:     \n",
    "                            \n",
    "                                for basis_functionj in range(len(eh_basis_functs)):#print(\"coops\",Energy,eigenvalue_index,all_coop[eigenvalue_index])\n",
    "                                #print(\"ij\",basis_functioni,basis_functionj)                                 \n",
    "                                #print(kpt_index,eigenvalue_index,basis_functioni,basis_functionj,all_coop[kpt_index][3][eigenvalue_index][basis_functioni][basis_functioni])                                \n",
    "                                    coop[basis_functioni][basis_functionj]+=all_coop[kpt_index][3][eigenvalue_index][basis_functioni][basis_functionj]\n",
    "\n",
    "        #NOTES       \n",
    "        #Nstates is just an integer - the number of states that lie below the energy threshold (needs to be divided by no of kpts in\n",
    "        #the BZ)\n",
    "        #Proj_states is a list - Nstates weighted by the contribution of each basis function\n",
    "        #coop_list is 2-d array - Nstates weighted by COOPs for each basis function pair.\n",
    "        #Finally, divide the elements of Fermi list, Proj_states_list and coop_list by the number of kpts in the sample to normalise it\n",
    "        #(if you have 1 state but 100 kpts in the sample, Nstates will be 100 at this stage)\n",
    "        #Finally, divide the elements of Fermi list and Proj_states_list by the number of kpts in the sample to normalise it\n",
    "        #(if you have 1 state but 100 kpts in the sample, Nstates will be 100 at this stage)\n",
    "        \n",
    "        #fermi_list.append([Energy,Nstates/len(all_energies)])\n",
    "        fermi_list.append([Energy,Nstates/number_of_points_sampled])\n",
    "        Proj_states_list.append([Energy,Proj_states/number_of_points_sampled])\n",
    "        if plot_COOP:        \n",
    "            coop_list.append([Energy,coop/number_of_points_sampled])\n",
    "        \n",
    "    states=[];proj_states=[];coops=[]\n",
    "\n",
    "    for i in range(len(fermi_list)-5):\n",
    "        #print(len(all_energies))\n",
    "        #print(i,fermi_list[i][0],fermi_list[i][1])\n",
    "        states.append(fermi_list[i][1])\n",
    "        #coops.append(coop_list[i][1][coopi][coopj])\n",
    "#this next bit adds an extra 5 elements on to the end of states to make it the same length as Energy_range (needs to be so to plot DOS)     \n",
    "    #print(\"len states\",len(states),len(Energy_range))\n",
    "    count=0                    \n",
    "    while count<5:\n",
    "        states.append(states[-1])\n",
    "        #coops.append(coops[-1])\n",
    "        count=count+1\n",
    "\n",
    "#this creates a nested list of projected states - equivalent to 'states' but weighted by contribution of each basis function to the MO\n",
    "    for j in range(len(eh_basis_functs)):\n",
    "        proj_states_temp=[]\n",
    "        for i in range(len(fermi_list)-5): \n",
    "            proj_states_temp.append(Proj_states_list[i][1][j])\n",
    "        \n",
    "        count=0                    \n",
    "        while count<5:\n",
    "            proj_states_temp.append(proj_states_temp[-1])\n",
    "            count=count+1\n",
    "        proj_states.append(proj_states_temp)\n",
    "\n",
    "#this creates a nested list of coops, each associated with a list which acts as a label [i,j]. Would be neater to do this with a dictionary.  \n",
    "    if plot_COOP:\n",
    "        for j in range(len(eh_basis_functs)):\n",
    "            for k in range(len(eh_basis_functs)):\n",
    "                coop_temp=[]\n",
    "                for i in range(len(fermi_list)-5): \n",
    "                    coop_temp.append(coop_list[i][1][j][k])\n",
    "        \n",
    "                count=0                    \n",
    "                while count<5:\n",
    "                    coop_temp.append(coop_temp[-1])\n",
    "                    count=count+1\n",
    "                coops.append([coop_temp,[j,k]])\n",
    "    #print(\"coops len\",len(coops))\n",
    "\n",
    "#now find the fermi level by scanning fermi_list to find the point where the number of occupied states exceeeds number of electrons\n",
    "#if number of states varies slowly near Ef, it may be that several energies meet the \"Nstates=no_electrons/2\" criterion.\n",
    "#so collect all that meet the criterion in a list and average it    \n",
    "    Fermi_level_range=[];bracket=[]\n",
    "    for i in range(len(fermi_list)-5):\n",
    "        #the first bit is in case we don't find Ef exactly - it saves a pair of energies that bracket Ef by +/-10*span (span can be changed in input block)\n",
    "        #(likely behaviour if it's an insulator)\n",
    "        #print(fermi_list[i][1],fermi_list[i+5][1])\n",
    "        if np.round(fermi_list[i][1],decimals=mesh)<no_electrons/2-5*span and np.round(fermi_list[i+3][1],decimals=mesh)>no_electrons/2+5*span:\n",
    "            #print(\"bracket\",fermi_list[i][1],fermi_list[i][0],fermi_list[i+5][1],fermi_list[i+5][0])\n",
    "            bracket.append(fermi_list[i][0])\n",
    "            bracket.append(fermi_list[i+5][0])\n",
    "        #if we DO find it exactly (most likely if it's a metal, where Nstates is varying rapidly around Ef)\n",
    "        #if np.round(fermi_list[i][1],decimals=mesh)==no_electrons/2:\n",
    "        if np.isclose(fermi_list[i][1],no_electrons/2,span):\n",
    "            #print(\"Fermi level located at\",fermi_list[i][0],\"with no_states=\",fermi_list[i][1])\n",
    "            Fermi_level_range.append(fermi_list[i][0])\n",
    "    print(\"looking for Fermi level with\",no_electrons/2,\"filled levels\")\n",
    "    if not Fermi_level_range and not bracket:\n",
    "        print(\"can't find the Fermi level, setting it to zero\")\n",
    "        average_Fermi_level=0.\n",
    "    elif not Fermi_level_range:\n",
    "        print(\"can't find the Fermi level, but it lies between\",'{:06.2f}'.format(max(bracket)),\"eV and\",'{:06.2f}'.format(min(bracket)),\"eV\")\n",
    "        average_Fermi_level=np.mean(bracket)\n",
    "        print(\"average fermi level\",'{:06.2f}'.format(average_Fermi_level),\"eV\")\n",
    "    else:\n",
    "        average_Fermi_level=np.mean(Fermi_level_range)\n",
    "        print(\"average fermi level\",'{:06.2f}'.format(average_Fermi_level),\"eV\")\n",
    "\n",
    "    #print(len(Energy_range),len(states))\n",
    "    return Energy_range,states,proj_states,coops,average_Fermi_level\n",
    "\n",
    "#calculatethe DOS\n",
    "def DOS(states,proj_states,Energy_range,eh_basis_functs,atoms):\n",
    "#now calculate the DOS using finite difference\n",
    "    #states=states[0::DOS_sample]   #sample states and DOS at every nth value (otherwise derivative is too noisy). ut this is solved when I interpolate the DOS, so set to 1   \n",
    "    Energy_range_DOS=Energy_range#[0::DOS_sample]\n",
    "    #print(\"energy range\",Energy_range)\n",
    "    DOS=np.diff(states).tolist()\n",
    "    DOS.append(DOS[-1])  #note that in taking the first finite difference we lose one element, so need to duplicate final member to make lists the same length    \n",
    "    DOS=np.round(DOS,decimals=3)\n",
    "    #now loop through all the projected states to generate the PDOS\n",
    "    all_PDOS=[]\n",
    "    for i in range(len(proj_states)):\n",
    "        pstates_sampled=proj_states[i]#[0::DOS_sample]\n",
    "        PDOS=np.diff(pstates_sampled).tolist()\n",
    "        PDOS.append(PDOS[-1])\n",
    "        PDOS=np.round(PDOS,decimals=3)\n",
    "        #add a label so I can identify the PDOS  \n",
    "        PDOS_label=[eh_basis_functs[i][0],eh_basis_functs[i][1],eh_basis_functs[i][2],eh_basis_functs[i][3],eh_basis_functs[i][4]] #Z, index, n, l, ml\n",
    "        all_PDOS.append([PDOS,PDOS_label])\n",
    "    #sum PDOS on each atom type\n",
    "    #first generate a list of unique elements in the unit cell\n",
    "    unique_elements=[]\n",
    "    for element in atoms:\n",
    "        if element not in unique_elements:\n",
    "            unique_elements.append(element)\n",
    "    pdos_summed_over_atoms=[]\n",
    "    for element in unique_elements:\n",
    "        sum_for_one_atom_type=np.zeros(len(all_PDOS[0][0]))\n",
    "        for i in range(len(eh_basis_functs)):            \n",
    "            if all_PDOS[i][1][0]==element:   #all_PDOS[i][1][0] is the first element of the PDOS_label\n",
    "                 sum_for_one_atom_type=[sum(xyz) for xyz in zip(sum_for_one_atom_type,all_PDOS[i][0])]\n",
    "        pdos_summed_over_atoms.append([sum_for_one_atom_type,(element)])\n",
    "    \n",
    "#sum PDOS on each atom type, separated by angular quantum number, l    \n",
    "    pdos_summed_over_atoms_and_l=[]\n",
    "    for element in unique_elements:\n",
    "        sum_for_one_atom_type_s=np.zeros(len(all_PDOS[i][0]));sum_for_one_atom_type_p=np.zeros(len(all_PDOS[0][0]));sum_for_one_atom_type_d=np.zeros(len(all_PDOS[i][0]))\n",
    "        for i in range(len(eh_basis_functs)):            \n",
    "            if all_PDOS[i][1][0]==element and all_PDOS[i][1][3]==0:   #all_PDOS[i][1][0] is the first element of the PDOS_label\n",
    "                 sum_for_one_atom_type_s=[sum(xyz) for xyz in zip(sum_for_one_atom_type_s,all_PDOS[i][0])]\n",
    "            elif all_PDOS[i][1][0]==element and all_PDOS[i][1][3]==1:   #all_PDOS[i][1][0] is the first element of the PDOS_label\n",
    "                 sum_for_one_atom_type_p=[sum(xyz) for xyz in zip(sum_for_one_atom_type_p,all_PDOS[i][0])]\n",
    "                 #ptype==True\n",
    "                 #print(\"ptype_true\")\n",
    "            elif all_PDOS[i][1][0]==element and all_PDOS[i][1][3]==2:   #all_PDOS[i][1][0] is the first element of the PDOS_label\n",
    "                 sum_for_one_atom_type_d=[sum(xyz) for xyz in zip(sum_for_one_atom_type_d,all_PDOS[i][0])]\n",
    "                 #dtype==True\n",
    "                 #print(\"dtype_true\")\n",
    "        pdos_summed_over_atoms_and_l.append([sum_for_one_atom_type_s,(element,0)])   #the tuple element,0 is used to label an s orbital on 'element'\n",
    "        #print([sum_for_one_atom_type_s,(element,0)])       \n",
    "        if sum(sum_for_one_atom_type_p)!=0:    #only add p-type if there are in fact p orbitals on the atom in question!\n",
    "            pdos_summed_over_atoms_and_l.append([sum_for_one_atom_type_p,(element,1)])\n",
    "        if sum(sum_for_one_atom_type_d)!=0:     #only add d-type if there are in fact d orbitals on the atom in question!\n",
    "            pdos_summed_over_atoms_and_l.append([sum_for_one_atom_type_d,(element,2)])\n",
    "    return Energy_range_DOS,DOS,all_PDOS,pdos_summed_over_atoms,pdos_summed_over_atoms_and_l,unique_elements\n",
    "    \n",
    "#locate the Fermi surface\n",
    "def fermi_surface(all_energies,average_Fermi_level,Fermi_offset,symmetry):  \n",
    "#now I've found Ef, find the Fermi surface (the points in the BZ where the energy of one level corresponds exactly to Ef) \n",
    "    #print(\"AFE\",average_Fermi_level)    \n",
    "    Fermi_surface=[]\n",
    "    for item1 in all_energies:\n",
    "        #loop over eigenvalues in each list\n",
    "        for item2 in item1[3]:\n",
    "            if np.isclose(item2,average_Fermi_level+Fermi_offset,0.01):\n",
    "                FS_point=[item1[0],item1[1],item1[2]]\n",
    "                Fermi_surface.append(FS_point)\n",
    "                #print(\"surface_hit\",FS_point)\n",
    "    #print(Fermi_surface)\n",
    "#we have the k points that lie on the Fermi surface in the symmetry-unique region of the first BZ.\n",
    "#now use the symmetry of the BZ to map these points onto the entire region- no extend\n",
    "    if symmetry=='fcc' or symmetry=='bcc' or symmetry=='c' or symmetry=='t' or symmetry=='o':\n",
    "            full_BZ_Fermi_surface=[];z_ref=[]\n",
    "            for item in Fermi_surface:\n",
    "                full_BZ_Fermi_surface.append(item)\n",
    "        #print(\"FS\",full_BZ_Fermi_surface)\n",
    "            for item in Fermi_surface:\n",
    "        #print(\"items\",item)\n",
    "                x_ref=[-item[0],item[1],item[2]]\n",
    "                full_BZ_Fermi_surface.append(x_ref)\n",
    "            for item in Fermi_surface:\n",
    "                xy_ref=[-item[0],-item[1],item[2]]\n",
    "                full_BZ_Fermi_surface.append(xy_ref)\n",
    "            for item in Fermi_surface:\n",
    "                y_ref=[item[0],-item[1],item[2]]\n",
    "                full_BZ_Fermi_surface.append(y_ref)\n",
    "#    #now reflect everything in xy plane\n",
    "            for item in full_BZ_Fermi_surface:\n",
    "                z_ref.append([item[0],item[1],-item[2]])\n",
    "    #now add the two lists\n",
    "            full_BZ_Fermi_surface+=z_ref\n",
    "                \n",
    "            surface_kx=[];surface_ky=[];surface_kz=[]\n",
    "            for item in full_BZ_Fermi_surface:\n",
    "                surface_kx.append(item[0])\n",
    "                surface_ky.append(item[1])\n",
    "                surface_kz.append(item[2])\n",
    "            #print(surface_kx)\n",
    "    elif symmetry=='h':\n",
    "        full_BZ_Fermi_surface=Fermi_surface\n",
    "        surface_kx=[];surface_ky=[];surface_kz=[]\n",
    "        for item in full_BZ_Fermi_surface:\n",
    "            surface_kx.append(item[0])\n",
    "            surface_ky.append(item[1]) \n",
    "            surface_kz.append(item[1]) \n",
    "    \n",
    "\n",
    "#    xi = linspace(kx_min,kx_max,100)\n",
    "#    yi = linspace(ky_min,ky_max,100)\n",
    "#    Z = interpolate.griddata(surface_kx,surface_ky,surface_kz,xi,yi)\n",
    "#    X, Y = np.meshgrid(xi, yi)\n",
    "            \n",
    "    return full_BZ_Fermi_surface,surface_kx,surface_ky,surface_kz\n",
    "\n",
    "def COOP(coops,Energy_range):\n",
    "    DOS_sample=1\n",
    "#now calculate the COOP using finite difference\n",
    "    Energy_range_COOP=Energy_range[0::DOS_sample]\n",
    "    if coop_by_bf_pair:   #calculate COOP for one specific pair of bfs \n",
    "        all_COOP=[]\n",
    "        for i in range(len(coops)):            #scan all pairs in coops\n",
    "            if coops[i][1]==coop_by_bf_pair:   #if the pair label matches the pair identified in input\n",
    "                COOP=np.diff(coops[i][0][0::DOS_sample]).tolist()      #differentiate it        \n",
    "        COOP.append(COOP[-1])#add one more element to recover the one lost on differentiating\n",
    "        COOP=np.round(COOP,decimals=3)\n",
    "        #add a label so I can identify the pair (somewhat redundant here, but let's keep it for consistency for now)\n",
    "        COOP_label=coop_by_bf_pair #Z, index, n, l, ml\n",
    "        all_COOP.append([COOP,COOP_label])\n",
    "    if coop_by_atom_pair:\n",
    "        COOP_atom_pair=np.zeros(len(coops[0][0]))  #initialise the summation over basis functions to 0.\n",
    "        all_COOP=[]\n",
    "        for i in range(len(coops)):      #scan all pairs in coop\n",
    "            bf_index0=coops[i][1][0];bf_index1=coops[i][1][1]   #identify the 2 basis functions\n",
    "            #print(\"bf_index\",bf_index0,bf_index1)\n",
    "            if eh_basis_functs[bf_index0][1] in coop_by_atom_pair and eh_basis_functs[bf_index1][1] in coop_by_atom_pair and eh_basis_functs[bf_index1][1]!=eh_basis_functs[bf_index0][1]:   #test to see if basis functions are on selected atoms             \n",
    "                COOP_atom_pair=[sum(xyz) for xyz in zip(COOP_atom_pair,coops[i][0])]   #if so, add them to the sum \n",
    "        COOP_atom_pair=np.diff(COOP_atom_pair[0::DOS_sample]).tolist()   # sample and differentiate\n",
    "        COOP_atom_pair.append(COOP_atom_pair[-1])   #add an extra element\n",
    "        COOP_atom_pair=np.round(COOP_atom_pair,decimals=3)  #round\n",
    "        #add a label so I can identify the atom pair\n",
    "        #print(coop_by_atom_pair[0],coop_by_atom_pair[1])\n",
    "        atom_identity_0=atno_to_element[atoms[coop_by_atom_pair[0]]];atom_identity_1=atno_to_element[atoms[coop_by_atom_pair[1]]]  #identify atom types\n",
    "        #print(\"id\",atom_identity_0,atom_identity_1)        \n",
    "        COOP_atom_pair_label=(atom_identity_0,coop_by_atom_pair[0],atom_identity_1,coop_by_atom_pair[1]) #add a label (atom type, atom index number)\n",
    "        all_COOP.append([COOP_atom_pair,COOP_atom_pair_label])\n",
    "\n",
    "    return Energy_range_COOP,all_COOP\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#~~~~~~~~~~~~~~~~~~~~~~~~~FERMI SURFACE PLOT~~~~~~~~~~~~\n",
    "def Fermi_surface_plot(ax6,A,B,C,surface_kx,surface_ky,surface_kz,kx_max,ky_max,kz_max):\n",
    "    #draw a circle at the selected k points that are plotted\n",
    "    \n",
    "#print(\"circle\",bloch_kx,bloch_ky)\n",
    "    #work out ratio of axis lengths in reciprocal space\n",
    "    print(kx_max,ky_max,kz_max)\n",
    "    if symmetry=='fcc' or symmetry=='bcc' or 'c' or 't' or 'o':  \n",
    "        #circle=patch.Circle((bloch_kx,bloch_ky),radius=0.03,color='red',fill=False)\n",
    "        #axis_ratio=np.linalg.norm(A)/np.linalg.norm(B)\n",
    "        #surface_kx=[axis_ratio*(xyz) for xyz in surface_kx]\n",
    "        #ax3.add_patch(circle)\n",
    "        ax6.set_title('Fermi Surface')\n",
    "        ax6.set_xlabel('kx')\n",
    "        ax6.set_ylabel('ky')\n",
    "        ax6.set_zlabel('kz')\n",
    "        ax6.set_ylim(-ky_max,ky_max)\n",
    "        ax6.set_xlim(-kx_max,kx_max)\n",
    "        ax6.set_zlim(-kz_max,kz_max)\n",
    "        #ax3.set_aspect('equal','datalim')\n",
    "\n",
    "        if symmetry=='bcc':\n",
    "            b3=A;b2=A+B;b1=A-C\n",
    "            #print(b1,b2,b3)\n",
    "            recip_latt_points=[0.25*(3*A+B-C),-0.25*(3*A+B-C),0.25*(3*B+C+A),-0.25*(3*B+C+A),0.25*(3*C+B-A),-0.25*(3*C+B-A),0.25*(A+C-B),-0.25*(A+C-B)\\\n",
    "            ,0.5*(b1-b2+b3),0.5*(-b1+b2-b3),0.5*(b1+b2-b3),0.5*(-b1-b2+b3)]\n",
    "            #print(recip_latt_points)\n",
    "            dist=np.linalg.norm(0.5*A)            \n",
    "            rlpx=[];rlpy=[];rlpz=[]            \n",
    "            for item in recip_latt_points:\n",
    "                rlpx.append(item[0]);rlpy.append(item[1]);rlpz.append(item[2])\n",
    "        ax6.scatter(rlpx,rlpy,rlpz,color='red')\n",
    "#        for i in range(len(rlpx)):\n",
    "#            for j in range(i,len(rlpx)):\n",
    "#                if np.sqrt((rlpx[i]-rlpx[j])**2+(rlpy[i]-rlpy[j])**2+(rlpz[i]-rlpz[j])**2)==dist:\n",
    "#                    ax3.plot([rlpx[i],rlpx[j]],[rlpy[i],rlpy[j]],[rlpz[i],rlpz[j]],color='red')\n",
    "        #ax3.scatter(surface_kx,surface_ky,surface_kz)\n",
    "        #surface_kz_neg=[-1*z for z in surface_kz]\n",
    "        #ax3.scatter(surface_kx,surface_ky,surface_kz_neg)\n",
    "    elif symmetry=='h':\n",
    "        #ktot=bloch_kx*A+bloch_ky*B\n",
    "        #circle=patch.Circle((ktot[0],ktot[1]),radius=0.03,color='red',fill=False)\n",
    "        #ax3.add_patch(circle)\n",
    "        ax6.set_title('Fermi Surface')\n",
    "        ax6.set_xlabel('kx')\n",
    "        ax6.set_ylabel('ky')\n",
    "        ax6.set_zlabel('kz')\n",
    "        ax6.set_aspect('equal','datalim')\n",
    "\n",
    "        surface_kz+=[-1*z for z in surface_kz]\n",
    "        surface_kx+=surface_kx\n",
    "        surface_ky+=surface_ky\n",
    "        ax6.trisurf(X,Y,Z)\n",
    "        ax6.scatter(surface_kx,surface_ky,surface_kz)\n",
    "#        surface_kz_neg=[-1*z for z in surface_kz]\n",
    "#        ax3.scatter(surface_kx,surface_ky,surface_kz_neg)\n",
    "        #reflect in z axis\n",
    "        \n",
    "        #uncomment the line below if you want to see all the kpts that have been sampled\n",
    "        #ax3.scatter(acceptx,accepty,marker='x',color='red')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~DOS PLOT~~~~~~~~~~~~            \n",
    "def moving_average(x, w):\n",
    "    return np.convolve(x, np.ones(w), 'valid') / w\n",
    "\n",
    "def DOS_plot(total_DOS_plot,elements_to_plot,DOS,Energy_range_DOS,E_pts,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,all_PDOS,pdos_summed_over_atoms,pdos_summed_over_atoms_and_l,unique_elements,average_Fermi_level,DOS_min,DOS_max):\n",
    "    rolling_average=200\n",
    "    plt.figure(figsize=(5,10))\n",
    "    plt.clf()\n",
    "    angmom=0.;ml=0.\n",
    "    #define a grid for interpolation of the DOS - 10x finer than Energy_range\n",
    "    E_interp=np.linspace(Energy_range_DOS.min(),Energy_range_DOS.max(),E_pts*50)\n",
    "    if PDOS_by_atom:\n",
    "        element_tracker=[]\n",
    "        pdos_maxima=[]\n",
    "        for pdos in pdos_summed_over_atoms:\n",
    "            element=pdos[1];element_label=atno_to_element[element]\n",
    "            DOS_line_colour=(atom_colours[element][0]/255,atom_colours[element][1]/255,atom_colours[element][2]/255)\n",
    "\n",
    "            if element in elements_to_plot:\n",
    "                #if element not in element_tracker:\n",
    "                    f2=interpolate.interp1d(Energy_range_DOS,pdos[0], kind='cubic') #interpolate           \n",
    "                    pdos_interp=f2(E_interp)\n",
    "                    pdos_interpb=moving_average(pdos_interp,rolling_average)\n",
    "                    #plt.plot(pdos_interp,E_interp,c=cm.nipy_spectral(int(5*element)),label=str(element_label))\n",
    "                    plt.plot(pdos_interpb,E_interp[:-(rolling_average-1)],c=DOS_line_colour,label=str(element_label))\n",
    "                    pdos_maxima.append(pdos_interp.max())  \n",
    "\n",
    "                    #element_tracker.append(element)\n",
    "    #plots PDOS summed over all basis functions of a given l on a given atoms type\n",
    "    elif PDOS_by_atom_and_l:\n",
    "        element_tracker=[]\n",
    "        pdos_maxima=[]\n",
    "        for pdos in pdos_summed_over_atoms_and_l:\n",
    "            #identify the bits I need\n",
    "            element=pdos[1][0];angmom=pdos[1][1]\n",
    "            element_label=atno_to_element[element];angmom_label=l_identifiers[angmom] \n",
    "\n",
    "            #now use the scipy interpolate1d function\n",
    "            if angmom==0:\n",
    "                DOS_line_colour=(atom_colours[element][0]/255,atom_colours[element][1]/255,atom_colours[element][2]/255)\n",
    "                orbital_linestyle='-'\n",
    "            elif angmom==1:\n",
    "                DOS_line_colour=(atom_colours[element][2]/255,atom_colours[element][1]/255,atom_colours[element][0]/255)  #choose a different set of numbers that lie in the range 0<x<1\n",
    "                orbital_linestyle='-.'\n",
    "            elif angmom==2:\n",
    "                DOS_line_colour=(1-atom_colours[element][0]/255,1-atom_colours[element][1]/255,1-atom_colours[element][2]/255)\n",
    "                orbital_linestyle=':'\n",
    "            if element in elements_to_plot:\n",
    "                #if element not in element_tracker:\n",
    "                    f2=interpolate.interp1d(Energy_range_DOS,pdos[0], kind='cubic')            \n",
    "                    pdos_interp=f2(E_interp)\n",
    "                    pdos_interpb=moving_average(pdos_interp,rolling_average)\n",
    "                    #plt.plot(pdos_interp,E_interp,c=cm.nipy_spectral(int(5*element+20*angmom)),label=(str(element_label)+\" \"+str(angmom_label)))   #(5*element+10*angmom) just spaces the colormap out a bit\n",
    "                    plt.plot(pdos_interpb,E_interp[:-(rolling_average-1)],c=DOS_line_colour,linestyle=orbital_linestyle,label=(str(element_label)+\" \"+str(angmom_label)))\n",
    "                    pdos_maxima.append(pdos_interp.max())  \n",
    "\n",
    "    #plots PDOS summed per basis function\n",
    "    elif PDOS_by_basis_funct:\n",
    "        #element_tracker=[];angmom_tracker=[]\n",
    "        pdos_maxima=[]\n",
    "        for pdos in all_PDOS:\n",
    "            element=pdos[1][0];index=pdos[1][1];n=pdos[1][2];angmom=pdos[1][3];ml=pdos[1][4]   #extract the relevant labels\n",
    "            element_label=atno_to_element[element]\n",
    "            DOS_line_colour=(atom_colours[element][0]/255,atom_colours[element][1]/255,atom_colours[element][2]/255)\n",
    "            if angmom==0:\n",
    "                orbital_linestyle='-'\n",
    "            elif angmom==1:\n",
    "                DOS_line_colour=(atom_colours[element][2]/255,atom_colours[element][1]/255,atom_colours[element][0]/255)\n",
    "                if ml==-1:\n",
    "                    orbital_linestyle='-.'\n",
    "                elif ml==0:\n",
    "                    orbital_linestyle=':'\n",
    "                elif  ml==1:\n",
    "                    orbital_linestyle='--'\n",
    "            elif angmom==2:\n",
    "                DOS_line_colour=(1-atom_colours[element][0]/255,1-atom_colours[element][1]/255,1-atom_colours[element][2]/255)\n",
    "                if ml==-2:\n",
    "                    orbital_linestyle='-'\n",
    "                elif ml==-1:\n",
    "                    orbital_linestyle='--'\n",
    "                elif ml==0:\n",
    "                    orbital_linestyle=(0,(3,1,1,1))\n",
    "                elif ml==1:\n",
    "                    orbital_linestyle='-.'\n",
    "                elif ml==2:\n",
    "                    orbital_linestyle=':'\n",
    "            if element in elements_to_plot:\n",
    "                #if element not in element_tracker:\n",
    "                    pdos_interp=np.interp(E_interp,Energy_range_DOS,pdos[0])            \n",
    "                    f2=interpolate.interp1d(Energy_range_DOS,pdos[0], kind='cubic') #interpolate           \n",
    "                    pdos_interp=f2(E_interp)\n",
    "                    pdos_interpb=moving_average(pdos_interp,rolling_average)\n",
    "                    plt.plot(pdos_interpb,E_interp[:-(rolling_average-1)],c=DOS_line_colour,linestyle=orbital_linestyle,label=(str(element_label)+\" \"+str(index)+\" \"+str(identifiers[(n,angmom,ml)])))\n",
    "                    pdos_maxima.append(pdos_interp.max())  \n",
    "    #add the total DOS\n",
    "    #f2=interpolate.interp1d(Energy_range_DOS,DOS, kind='cubic') #interpolate    \n",
    "         \n",
    "    if total_DOS_plot==True:\n",
    "        DOS_interp=np.interp(E_interp,Energy_range_DOS,DOS)\n",
    "        DOS_interpb=moving_average(DOS_interp,rolling_average)\n",
    "    #plt.plot(DOS_interp,E_interp,'-',color='black',label=\"total DOS\")\n",
    "        plt.plot(DOS_interpb,E_interp[:-(rolling_average-1)],color='green',label=\"total DOS\")\n",
    "        right_max=min([DOS.max(),1.0])\n",
    "    else:\n",
    "        right_max=min([max(pdos_maxima),1.0])\n",
    "    if average_Fermi_level!=0.:\n",
    "        plt.plot([0,right_max],[average_Fermi_level,average_Fermi_level],color='red',linewidth=2,label=\"Ef\")\n",
    "    plt.text(-0.2*right_max,average_Fermi_level,\"Ef\",weight='bold',fontsize=14)  #plots label at the origin (it is not included in breakpoints)\n",
    "#set the axis limits\n",
    "    \n",
    "    plt.ylim(DOS_min,DOS_max)\n",
    "    plt.xlim(left=0,right=right_max)\n",
    "    plt.legend(ncol=2,markerscale=2)\n",
    "    plt.title(\"DOS\")\n",
    "    show()\n",
    "    \n",
    "def COOP_plot():\n",
    "    #define a grid for interpolation of the DOS - 10x finer than Energy_range\n",
    "    plt.figure()\n",
    "    E_interp=np.linspace(Energy_range_COOP.min(),Energy_range_COOP.max(),E_pts*50)\n",
    "    for COOP in all_COOP:    \n",
    "        f2=interpolate.interp1d(Energy_range_COOP,COOP[0], kind='cubic') #interpolate           \n",
    "        COOP_interp=f2(E_interp) \n",
    "        ax5.plot(COOP_interp,E_interp,label=COOP[1])\n",
    "    \n",
    "    #add a line for the Fermi level\n",
    "    plt.plot([COOP_interp.min(),COOP_interp.max()],[average_Fermi_level,average_Fermi_level],'black',linewidth=1,label=\"Ef\")\n",
    "    #set the exis limits\n",
    "    plt.ylim(DOS_min,DOS_max)\n",
    "    #ax2.set_xlim(left=0)\n",
    "    #ax2.set_xlim(0.,pdos_interp.max())\n",
    "    plt.legend()\n",
    "    plt.set_title(\"COOP\")\n",
    "    plt.plot([0,0],[DOS_min,DOS_max],'black',linewidth=1)   #add a line defining zero\n",
    "\n",
    "def unit_cell_2d(mol,a0,b0,c0,a,b,c,supermolecule_coords,supermolecule_atoms,d1,d2,d3,repeats,symmetry):\n",
    "    #a dictionary to decide which set of radii to use, ionic or covalent\n",
    "    if ionic_or_covalent_radii[mol]=='i':\n",
    "        radii_dict='ionic_radii'\n",
    "    elif ionic_or_covalent_radii[mol]=='c':\n",
    "        radii_dict='covalent_radii'\n",
    "    \n",
    "    print(\"using\",radii_dict,\"dictionary\")\n",
    "    \n",
    "    if d2 or d3:\n",
    "        plt.figure(figsize=(5,5))\n",
    "    elif d1:\n",
    "        plt.figure(figsize=(2.5,5))\n",
    "    plt.clf()\n",
    "    plt.xlabel('x');plt.ylabel('y')\n",
    "    displacements2=[];distances=[]\n",
    "    repeats=2\n",
    "    if d1:\n",
    "        #print(supermolecule_coords)\n",
    "        everything=[]\n",
    "            #no need to fill the primitive unit cell here as it is already primitive!\n",
    "            #now generate the vectors to replicate the repeat unit along x, y and z of the primitive cubic unit cell\n",
    "        for k in range(-repeats,repeats+1):\n",
    "            displacements2.append([0.,0.,k*c0/A0])    \n",
    "                #now generate all the coordinates in the repetitions\n",
    "        #print(displacements)\n",
    "        for l in range(len(displacements2)):\n",
    "            for m in range(len(supermolecule_coords)):\n",
    "                everything.append([supermolecule_coords[m][0],supermolecule_coords[m][1],displacements2[l][2]+supermolecule_coords[m][2],supermolecule_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "        sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate\n",
    "        #flip the y and z coordinates so we can plot them using same code as 2- and 3-d systems\n",
    "        for item in sorted_coords:\n",
    "            item[1],item[2]=item[2],item[1]\n",
    "            \n",
    "\n",
    "    elif d2:\n",
    "        everything=[]\n",
    "        if symmetry=='2d_square':\n",
    "            for i in range(-repeats,repeats+1):\n",
    "                for j in range(-repeats,repeats+1):\n",
    "                    displacements2.append([i*a0/A0,j*a0/A0,0.0])                        \n",
    "                #now generate all the coordinates in the repetitions\n",
    "            for l in range(len(displacements2)):        \n",
    "                for m in range(len(supermolecule_coords)):\n",
    "                    everything.append([displacements2[l][0]+supermolecule_coords[m][0],displacements2[l][1]+supermolecule_coords[m][1],displacements2[l][2]+supermolecule_coords[m][2],supermolecule_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "        sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate\n",
    "        if symmetry=='2d_h':\n",
    "            for i in range(-repeats,repeats+1):\n",
    "                for j in range(-repeats,repeats+1):\n",
    "                    displacements2.append([(i-0.5*j)*a0/A0,0.5*(3**0.5)*j*a0/A0,0.])                        \n",
    "                #now generate all the coordinates in the repetitions\n",
    "            for l in range(len(displacements2)):        \n",
    "                for m in range(len(supermolecule_coords)):\n",
    "                    everything.append([displacements2[l][0]+supermolecule_coords[m][0],displacements2[l][1]+supermolecule_coords[m][1],displacements2[l][2]+supermolecule_coords[m][2],supermolecule_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "            sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate\n",
    "\n",
    "    elif d3:\n",
    "        if symmetry=='fcc':\n",
    "                #first, fill up the primitive cubic lattice\n",
    "            primitive_cubic_coords=[];primitive_cubic_atoms=[];everything=[]\n",
    "            for coordinates in supermolecule_coords:\n",
    "                primitive_cubic_coords.append(coordinates)\n",
    "                primitive_cubic_coords.append([coordinates[0],coordinates[1]+(1/2)*a0/A0,coordinates[2]+(1/2)*a0/A0])                    \n",
    "                primitive_cubic_coords.append([coordinates[0]+(1/2)*a0/A0,coordinates[1],coordinates[2]+(1/2)*a0/A0])\n",
    "                primitive_cubic_coords.append([coordinates[0]+(1/2)*a0/A0,coordinates[1]+(1/2)*a0/A0,coordinates[2]])\n",
    "            for atoms in supermolecule_atoms:\n",
    "                primitive_cubic_atoms.append(atoms)\n",
    "                primitive_cubic_atoms.append(atoms)\n",
    "                primitive_cubic_atoms.append(atoms)\n",
    "                primitive_cubic_atoms.append(atoms)\n",
    "                #shift all atoms to the front, left, bottom quadrant of the unit cell\n",
    "            shifted_coordinates=[]\n",
    "            for coordinate in primitive_cubic_coords:\n",
    "                temp_coord=[]\n",
    "                for xyz in coordinate:\n",
    "                    if xyz>=a0/A0:\n",
    "                        temp_coord.append(xyz-a0/A0)\n",
    "                    else:\n",
    "                         temp_coord.append(xyz)\n",
    "                shifted_coordinates.append(temp_coord)\n",
    "                #now generate the vectors to replicate the repeat unit along x, y and z of the primitive cubic unit cell\n",
    "            for i in range(-repeats,repeats+1):\n",
    "                for j in range(-repeats,repeats+1):\n",
    "                    for k in range(-repeats,repeats+1):\n",
    "                        displacements2.append([i*a0/A0,j*a0/A0,k*a0/A0])                        \n",
    "                #now generate all the coordinates in the repetitions\n",
    "            for l in range(len(displacements2)):        \n",
    "                for m in range(len(primitive_cubic_coords)):\n",
    "                    everything.append([displacements2[l][0]+shifted_coordinates[m][0],displacements2[l][1]+shifted_coordinates[m][1],displacements2[l][2]+shifted_coordinates[m][2],primitive_cubic_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "            sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate\n",
    "            \n",
    "        elif symmetry=='c':\n",
    "            everything=[]\n",
    "                #no need to fill the primitive unit cell here as it is already primitive!\n",
    "                #now generate the vectors to replicate the repeat unit along x, y and z of the primitive cubic unit cell\n",
    "            for i in range(-repeats,repeats+1):\n",
    "                for j in range(-repeats,repeats+1):\n",
    "                    for k in range(-repeats,repeats+1):\n",
    "                        displacements2.append([i*a0/A0,j*a0/A0,k*a0/A0])                        \n",
    "                #now generate all the coordinates in the repetitions\n",
    "            for l in range(len(displacements2)):        \n",
    "                for m in range(len(supermolecule_coords)):\n",
    "                    everything.append([displacements2[l][0]+supermolecule_coords[m][0],displacements2[l][1]+supermolecule_coords[m][1],displacements2[l][2]+supermolecule_coords[m][2],supermolecule_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "            sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate\n",
    "\n",
    "            \n",
    "        elif symmetry=='h':\n",
    "            everything=[]\n",
    "                #no need to fill the primitive unit cell here as it is already primitive!\n",
    "                #now generate the vectors to replicate the repeat unit along x, y and z of the primitive cubic unit cell\n",
    "            for i in range(-repeats,repeats+1):\n",
    "                for j in range(-repeats,repeats+1):\n",
    "                    for k in range(-repeats,repeats+1):\n",
    "                        displacements2.append([(i-0.5*j)*a0/A0,0.5*(3**0.5)*j*a0/A0,k*c0/A0])                        \n",
    "                        distances.append([i,j,np.linalg.norm([(i-0.5*j)*a0/A0,0.5*(3**0.5)*j*a0/A0,k*c0/A0])])\n",
    "                #now generate all the coordinates in the repetitions\n",
    "            for l in range(len(displacements2)):        \n",
    "                for m in range(len(supermolecule_coords)):\n",
    "                    everything.append([displacements2[l][0]+supermolecule_coords[m][0],displacements2[l][1]+supermolecule_coords[m][1],displacements2[l][2]+supermolecule_coords[m][2],supermolecule_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "            sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate                \n",
    "                \n",
    "                \n",
    "        elif symmetry=='t' or 'bct':\n",
    "            everything=[]\n",
    "                #no need to fill the primitive unit cell here as it is already primitive!\n",
    "                #now generate the vectors to replicate the repeat unit along x, y and z of the primitive cubic unit cell\n",
    "            for i in range(-repeats,repeats+1):\n",
    "                for j in range(-repeats,repeats+1):\n",
    "                    for k in range(-repeats,repeats+1):\n",
    "                        displacements2.append([i*a0/A0,j*a0/A0,k*c0/A0])                        \n",
    "                #now generate all the coordinates in the repetitions\n",
    "            for l in range(len(displacements2)):        \n",
    "                for m in range(len(supermolecule_coords)):\n",
    "                    everything.append([displacements2[l][0]+supermolecule_coords[m][0],displacements2[l][1]+supermolecule_coords[m][1],displacements2[l][2]+supermolecule_coords[m][2],supermolecule_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "            sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate\n",
    "\n",
    "\n",
    "                \n",
    "        elif symmetry=='bcc':\n",
    "                #first, fill up the primitive cubic lattice\n",
    "            primitive_cubic_coords=[];primitive_cubic_atoms=[];everything=[]\n",
    "            for coordinates in supermolecule_coords:\n",
    "                primitive_cubic_coords.append(coordinates)\n",
    "                primitive_cubic_coords.append([coordinates[0]+0.5*a0/A0,coordinates[1]+0.5*a0/A0,coordinates[2]+0.5**a0/A0])\n",
    "            for atoms in supermolecule_atoms:\n",
    "                primitive_cubic_atoms.append(atoms)\n",
    "                primitive_cubic_atoms.append(atoms)\n",
    "                #shift all atoms to the front, left, bottom quadrant of the unit cell\n",
    "                #shouldn't be relevant in standard set up, but could be if atom was defined in middle of unit cell rather than at the origin\n",
    "            shifted_coordinates=[]\n",
    "            for coordinate in primitive_cubic_coords:\n",
    "                temp_coord=[]\n",
    "                for xyz in coordinate:\n",
    "                    if xyz>=a0/A0:\n",
    "                        temp_coord.append(xyz-a0/A0)\n",
    "                    else:\n",
    "                        temp_coord.append(xyz)\n",
    "                shifted_coordinates.append(temp_coord)\n",
    "                #now generate the vectors to replicate the repeat unit along x, y and z of the primitive cubic unit cell\n",
    "            for i in range(-repeats,repeats+1):\n",
    "                for j in range(-repeats,repeats+1):\n",
    "                    for k in range(-repeats,repeats+1):\n",
    "                        displacements2.append([i*a0/A0,j*a0/A0,k*a0/A0])                        \n",
    "                #now generate all the coordinates in the repetitions\n",
    "            for l in range(len(displacements2)):        \n",
    "                for m in range(len(primitive_cubic_coords)):\n",
    "                    everything.append([displacements2[l][0]+shifted_coordinates[m][0],displacements2[l][1]+shifted_coordinates[m][1],displacements2[l][2]+shifted_coordinates[m][2],primitive_cubic_atoms[m]])\n",
    "                #I am going to project onto the 001 plane (i.e. along z) so I want to sort the list so that atoms come in order of increasing z\n",
    "                #this should ensure that the last atoms in any column to be plotted will be the ones closest to the surface                \n",
    "            sorted_coords=sorted(everything,key = lambda x: x[2])  #sort according to z coordinate\n",
    "                \n",
    "                        \n",
    "                \n",
    "                \n",
    "        #now set plot limits to make the box square\n",
    "    xcoords=[];ycoords=[];zcoords=[]\n",
    "    for coordinate in sorted_coords:\n",
    "        xcoords.append(coordinate[0]);ycoords.append(coordinate[1]);zcoords.append(coordinate[2])\n",
    "    xmax=max(xcoords);xmin=min(xcoords);ymax=max(ycoords);ymin=min(ycoords);zmax=max(zcoords);zmin=min(zcoords)\n",
    "            #below is a work around to try to set the axis ratios equal.  \n",
    "        #print(xmax,xmin, ymax,ymin)\n",
    "    max_range = max(xmax-xmin, ymax-ymin)/2.0\n",
    "    xcoords=np.asarray(xcoords);ycoords=np.asarray(ycoords);zcoords=np.asarray(zcoords) \n",
    "    mean_x = xcoords.mean();mean_y = ycoords.mean();mean_z = zcoords.mean()\n",
    "    plt.xlim(mean_x - max_range, mean_x + max_range)\n",
    "    plt.ylim(mean_x - max_range, mean_x + max_range)\n",
    "    if d1:\n",
    "        plt.xlim(-5.,5.)\n",
    "        plt.ylim(-10.,10.)\n",
    "    xy_coords=[];z_coords=[];plotted_coords=[]  \n",
    "    \n",
    "    \n",
    "    #for item in sorted_coords:    #switch y and z\n",
    "    #    item[0],item[2]=item[2],item[0]\n",
    "        \n",
    "        \n",
    "    for i in range(len(sorted_coords)):\n",
    "        if sorted_coords[i][3]==1:\n",
    "            atom_colour='k'\n",
    "        else:\n",
    "            atom_colour=[x/255 for x in atom_colours[sorted_coords[i][3]]] #decide what colour to use \n",
    "\n",
    "        if (sorted_coords[i][0],sorted_coords[i][1]) not in xy_coords:  #only plot the top atom in a column defined by (x,y)\n",
    "            plt.scatter(sorted_coords[i][0],sorted_coords[i][1],color=atom_colour)  #plot the atom\n",
    "            plotted_coords.append(sorted_coords[i])\n",
    "            xy_coords.append((sorted_coords[i][0],sorted_coords[i][1]))  #track the points we have plotted on\n",
    "        \n",
    "        #now decide where to draw bonds\n",
    "    for a in range(len(plotted_coords)):\n",
    "        for b in range(a,len(sorted_coords)):\n",
    "            vecab=[(sorted_coords[b][0]-plotted_coords[a][0]),(sorted_coords[b][1]-plotted_coords[a][1]),(sorted_coords[b][2]-plotted_coords[a][2])]\n",
    "            distab=np.linalg.norm(vecab)  #\n",
    "            \n",
    "                #choose which set of radii to use to set cutoff\n",
    "            if radii_dict=='ionic_radii':\n",
    "                scale_factor=0.97\n",
    "                sum_of_radii=(ionic_radii[plotted_coords[a][3]]+ionic_radii[sorted_coords[b][3]])/A0 \n",
    "            elif radii_dict=='covalent_radii':\n",
    "                scale_factor=1.0\n",
    "                sum_of_radii=(covalent_radii[plotted_coords[a][3]]+covalent_radii[sorted_coords[b][3]])/A0 \n",
    "            bond_count=0  #track number of bonds\n",
    "            if distab<scale_factor*sum_of_radii:  #define bonded cutoff as 90% of sum of covalent radii                                         \n",
    "                plt.plot([sorted_coords[b][0],plotted_coords[a][0]],[sorted_coords[b][1],plotted_coords[a][1]], color=\"black\",lw=1) \n",
    "                bond_count+=1\n",
    "                \n",
    "            if bond_count==0:  #if don't find any bonds, increase scale factor and try again\n",
    "                if distab<1.05*scale_factor*sum_of_radii:  #define bonded cutoff as 90% of sum of covalent radii                                         \n",
    "                    plt.plot([sorted_coords[b][0],plotted_coords[a][0]],[sorted_coords[b][1],plotted_coords[a][1]], color=\"black\",lw=1) \n",
    "                    bond_count+=1\n",
    "                    #print(a,b,distab,sum_of_radii)\n",
    "    plt.title('projection onto 001')\n",
    "    unique_atoms=[]\n",
    "    for atom in supermolecule_atoms:\n",
    "        if atom not in unique_atoms:\n",
    "            unique_atoms.append(atom)\n",
    "    for i in range(len(unique_atoms)):\n",
    "        plt.text(xmax+5,(xmax-2-(xmax/5)*i),str(atno_to_element[unique_atoms[i]]),color=[x/255 for x in atom_colours[unique_atoms[i]]],fontsize=14)\n",
    "        #print(unique_atoms[i],[x/255 for x in atom_colours[unique_atoms[i]]])\n",
    "    if symmetry in ['h','2d_h']:\n",
    "        plt.plot([0,a0/A0],[0.,0.], color=\"blue\",lw=3)\n",
    "        plt.plot([0.5*a0/A0,1.5*a0/A0],[0.5*(3**0.5)*a0/A0,0.5*(3**0.5)*a0/A0], color=\"blue\",lw=3)\n",
    "        plt.plot([0,0.5*a0/A0],[0.,0.5*(3**0.5)*a0/A0], color=\"blue\",lw=3)\n",
    "        plt.plot([a0/A0,1.5*a0/A0],[0.,0.5*(3**0.5)*a0/A0], color=\"blue\",lw=3)\n",
    "    elif symmetry in ['c','fcc','bcc','t','bct','2d_square']:\n",
    "        plt.plot([0.,0.],[0.,a0/A0], color=\"blue\",lw=3)\n",
    "        plt.plot([a0/A0,a0/A0],[0.,a0/A0], color=\"blue\",lw=3)\n",
    "        plt.plot([0,a0/A0],[0.,0.], color=\"blue\",lw=3)\n",
    "        plt.plot([a0/A0,0.],[a0/A0,a0/A0], color=\"blue\",lw=3)\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "#a function that calculates band structure within a given line segment of the BZ\n",
    "def line_plot(kx_test,ky_test,kz_test,start_point,energies,kvec_list,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,eh_basis_functs,npts_line,d1,d2,d3):\n",
    "    #kx_range=kx_test[-1]-kx_test[0]\n",
    "    #ky_range=ky_test[-1]-ky_test[0]\n",
    "    #kz_range=kz_test[-1]-kz_test[0]\n",
    "    fail_count=0.\n",
    "    for i in range(npts_line):        \n",
    "        kx_line=kx_test[i]\n",
    "        ky_line=ky_test[i]\n",
    "        kz_line=kz_test[i]\n",
    "        if d3:\n",
    "            ktot=kx_line*A+ky_line*B+kz_line*C\n",
    "        elif d2:\n",
    "            ktot=kx_line*A+ky_line*B\n",
    "        elif d1:\n",
    "            ktot=kz_line*C\n",
    "            #print(\"ktot\",ktot)\n",
    "        final_S=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex);final_H=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex)            \n",
    "        final_S+=S;final_H+=H\n",
    "        for j in range(len(displacements)):\n",
    "            #print(displacements[j],np.dot(ktot,displacements[j]))\n",
    "            final_S+=np.exp(1j*np.dot(ktot,displacements[j]))*map_S[j]+np.exp(-1j*np.dot(ktot,displacements[j]))*map_S_tran[j]\n",
    "            final_H+=np.exp(1j*np.dot(ktot,displacements[j]))*map_H[j]+np.exp(-1j*np.dot(ktot,displacements[j]))*map_H_tran[j]\n",
    "        if is_pos_def(final_S)==True:\n",
    "            v,e,occupations=diagonalise_periodic(final_H,final_S,no_electrons)  #Solves generalised eigenvalue equation\n",
    "            e=e.real\n",
    "            #this next bit will be needed if I want to colour code the lines in the band structure according to their dominant contribution\n",
    "            #not implemented yet            \n",
    "            dominant_orbital=[]\n",
    "            for eigenvector in v:\n",
    "                abs_eigenvector=[abs(x) for x in eigenvector]\n",
    "                dom_orb=abs_eigenvector.index(max(abs_eigenvector))\n",
    "                dominant_orbital.append(dom_orb)    \n",
    "            #print(\"dom\",dominant_orbital)\n",
    "            \n",
    "            kvec_list.append(start_point+i/npts_line)\n",
    "            energies.append(e)\n",
    "        else:\n",
    "            fail_count+=1\n",
    "#        if kx_line==ky_line==kz_line==k_max:\n",
    "#            print(kx_test,energies)\n",
    "            #print(\"fail\",kx_test[i],ky_test[i],kz_test[i])\n",
    "    #print(\"success\",npts_line-fail_count,\"fail_count\",fail_count)\n",
    "    return energies,kvec_list\n",
    "\n",
    "#function that calculates energy at a single point in reciprocal space\n",
    "def single_point(bloch_kx,bloch_ky,bloch_kz,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,eh_basis_functs):  \n",
    "        ktot=bloch_kx*A+bloch_ky+bloch_kz*C\n",
    "        final_S=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex);final_H=np.zeros((len(eh_basis_functs),len(eh_basis_functs)),dtype=complex)            \n",
    "        final_S+=S;final_H+=H\n",
    "        for j in range(len(displacements)):\n",
    "            final_S+=np.exp(1j*np.dot(ktot,displacements[j]))*map_S[j]#+np.exp(-1j*np.dot(ktot,displacements[j]))*map_S_tran[j]\n",
    "            final_H+=np.exp(1j*np.dot(ktot,displacements[j]))*map_H[j]#+np.exp(-1j*np.dot(ktot,displacements[j]))*map_H_tran[j]\n",
    "        if is_pos_def(final_S)==True:\n",
    "            v,e,occupations=diagonalise_periodic(final_H,final_S,no_electrons)  #Solves generalised eigenvalue equation\n",
    "            e=e.real\n",
    "        else:\n",
    "            print(\"fail\")\n",
    "        bloch_coeff=[]\n",
    "        for i in range(len(eh_basis_functs)):\n",
    "            eigenvector=v[:,i].tolist()\n",
    "            norm=np.linalg.norm(eigenvector)\n",
    "            eigenvector=eigenvector/norm\n",
    "            bloch_coeff.append(eigenvector)\n",
    "        #print(\"bloch eigenvectors\",bloch_coeff)\n",
    "        return e,bloch_coeff\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~BAND STRUCTURE PLOT~~~~~~~~~~~~\n",
    "#plot some lines in the first BZ, as defined in BZ_path\n",
    "def Band_structure_plot(eh_basis_functs,BZ_path,BZ_labels,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,npts_line,DOS_min,DOS_max,average_Fermi_level,d1,d2,d3):\n",
    "    #ax1=plt.subplot2grid((nrows,ncolumns),(0,2), colspan=2, rowspan=nrows)    \n",
    "    plt.figure(figsize=(5,10))\n",
    "    plt.clf()\n",
    "    break_points=[]\n",
    "    energies=[];kvec_list=[];start_point=0. \n",
    "    for i in range(len(BZ_path)-1):\n",
    "        kz_test=np.linspace(BZ_path[i][2],BZ_path[i+1][2],npts_line)\n",
    "        kx_test=np.linspace(BZ_path[i][0],BZ_path[i+1][0],npts_line)\n",
    "        ky_test=np.linspace(BZ_path[i][1],BZ_path[i+1][1],npts_line)\n",
    "        #print(\"BZ_path step \",i,np.round(BZ_path[i],decimals=2),np.round(BZ_path[i+1],decimals=2))\n",
    "        energies,kvec_list=line_plot(kx_test,ky_test,kz_test,start_point,energies,kvec_list,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,eh_basis_functs,npts_line,d1,d2,d3)       \n",
    "        start_point=kvec_list[-1]\n",
    "        break_points.append(start_point)   \n",
    "#collect all the energies in a single list for plotting\n",
    "    energy_list=[]\n",
    "    for i in range(len(eh_basis_functs)):\n",
    "        energy_list.append(np.zeros(len(kvec_list)))\n",
    "        for j in range(len(kvec_list)):\n",
    "            energy_list[i][j]=energies[j][i]\n",
    "\n",
    "#box=fig.add_subplot(223)\n",
    "    for i in range(len(eh_basis_functs)):\n",
    "        plt.plot(kvec_list,energy_list[i],'blue',markersize=1)\n",
    "\n",
    "#ymin,ymax=(DOS_min,DOS_max)\n",
    "#ax3=fig.add_subplot(2,2,3)\n",
    "    plt.title(\"Band structure\")\n",
    "    plt.ylabel(\"Energy / eV\")\n",
    "    plt.xlim([0.,max(kvec_list)])\n",
    "    plt.ylim([DOS_min,DOS_max])\n",
    "    DOS_range=DOS_max-DOS_min\n",
    "    right_max=max(kvec_list)\n",
    "    #plt.xlabel('kz')\n",
    "    plt.xticks([])\n",
    "    plt.tick_params(labelbottom='off') # labels along the bottom edge are off\n",
    "    if average_Fermi_level!=0.:\n",
    "        plt.plot([0.,max(kvec_list)],[average_Fermi_level,average_Fermi_level],'red',linewidth=2)\n",
    "    plt.text(0.0,DOS_min-DOS_range/20,BZ_labels[0],weight='bold')  #plots label at the origin (it is not included in breakpoints)\n",
    "    plt.text(-0.2*right_max,average_Fermi_level,\"Ef\",weight='bold',fontsize=14)  #plots label at the origin (it is not included in breakpoints)\n",
    "\n",
    "    count=1\n",
    "    for item in break_points:\n",
    "        plt.plot([item,item],[DOS_min,DOS_max],'black',linewidth=1)\n",
    "        label=BZ_labels[count];kpt_label=str(np.round(BZ_path[count],decimals=2))\n",
    "        plt.text(item,DOS_min-DOS_range/20,label,weight='bold')\n",
    "        #plt.text(item,DOS_min-DOS_range/20,kpt_label)\n",
    "        count+=1\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~BLOCH EIGENSTATES PLOT~~~~~~~~~~~~\n",
    "#now plot the Bloch eigenstates\n",
    "\n",
    "def Bloch_eigenstates_plot(ncolumns,nrows,a,b,c,A,B,C,coords,atoms,eh_basis_functs,S,map_S,map_S_tran,H,map_H,map_H_tran,displacements,no_electrons,bloch_kpts,bloch_orbitals,offset,repeats,d1,d2,d3,levels): \n",
    "     \n",
    "  bloch_orbital=bloch_orbitals[0]\n",
    "  #print(\"Bloch Orbital to plot\",bloch_orbital)\n",
    "  count=0 \n",
    "  #calculate normamlisation factors of the AOs\n",
    "  if d2:  \n",
    "      norms=[]\n",
    "      for basis_funct in eh_basis_functs:\n",
    "            #if basis_funct[3]==2:\n",
    "            if type(basis_funct[6][0]) is tuple:\n",
    "                n=basis_funct[2]\n",
    "                exponent1=basis_funct[6][0][0];exponent2=basis_funct[6][1][0]\n",
    "                coeff1=basis_funct[6][0][1];coeff2=basis_funct[6][1][1]\n",
    "                norm1=(2*exponent1)**n*np.sqrt(2*exponent1/m.factorial(2*n))\n",
    "                norm2=(2*exponent1)**n*np.sqrt(2*exponent2/m.factorial(2*n))            \n",
    "                norms.append([norm1,coeff1,norm2,coeff2])\n",
    "            else:\n",
    "                exponent=basis_funct[6][0];n=basis_funct[2]\n",
    "                norm=(2*exponent)**n*np.sqrt(2*exponent/m.factorial(2*n))\n",
    "                norms.append([norm])    \n",
    "\n",
    "  \n",
    "      for kpt in bloch_kpts:\n",
    "        bloch_kx=kpt[0];bloch_ky=kpt[1];bloch_kz=0.\n",
    "        ktot=bloch_kx*A+bloch_ky*B\n",
    "        ax4=plt.subplot2grid((nrows,ncolumns),(1+count,ncolumns-1), colspan=1, rowspan=1)\n",
    "        plot_title='kx='+str(np.round(bloch_kx,decimals=2))+', ky='+str(np.round(bloch_ky,decimals=2)),', level='+str(np.round(bloch_orbital+1,decimals=2))\n",
    "        ax4.set_title(plot_title)\n",
    "        ax4.set_aspect('equal','datalim')\n",
    "        #ax4.set_xlabel('x');ax4.set_ylabel('y')\n",
    "        \n",
    "        bloch_displacements=[]\n",
    "        for i in range(-repeats,repeats+1):\n",
    "            for j in range(-repeats,repeats+1):\n",
    "                bloch_displacements.append(i*a+j*b)\n",
    "                #bloch_displacements.append([sum(x) for x in zip([i*x for x in a],[j*y for y in b])])\n",
    "        bloch_coords=[];bloch_atoms=[]\n",
    "        for k in range(len(bloch_displacements)):\n",
    "            for i in range(len(coords)):\n",
    "                bloch_coords.append([sum(xyz) for xyz in zip(coords[i], bloch_displacements[k])])\n",
    "                bloch_atoms.append(atoms[i])#;all_atoms.append(atoms[i])#;all_atoms.append(atoms[i]);all_atoms.append(atoms[i])\n",
    "    #these next few lines plot the unit cell + extensions\n",
    "        #print(all_coords)\n",
    "    #setup grid in xyz plane\n",
    "        xcoord=[];ycoord=[];zcoord=[]\n",
    "        for item in bloch_coords:\n",
    "            xcoord.append(item[0]);ycoord.append(item[1]);zcoord.append(item[2])\n",
    "        xmax=max(xcoord);xmin=min(xcoord);ymax=max(ycoord);ymin=min(ycoord);zmax=max(zcoord);zmin=min(zcoord)\n",
    "        #print(xmin,xmax,zmin,zmax)\n",
    "    #setup grid in xyz plan\n",
    "        x=np.linspace(xmin,xmax,151);y=np.linspace(ymin,ymax,151);z=np.linspace(zmin,zmax,151)\n",
    "        #x=np.linspace(-0.1,16,101);y=np.linspace(-0.1,16,101);z=np.linspace(-5,5,100)\n",
    "        [X,Y] = np.meshgrid(x,y)\n",
    "\n",
    "    #calculate bloch eigenstates at specific kx,ky\n",
    "        e,bloch_coeff=single_point(bloch_kx,bloch_ky,bloch_kz,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,eh_basis_functs)\n",
    "  \n",
    "    #print(\"coeff\",bloch_coeff)    \n",
    "\n",
    "    #initialise psi    \n",
    "        psi=0.  \n",
    "    #print(len(bloch_coeff[bloch_orbital]),len(bloch_displacements))\n",
    "    #ax4=plt.subplot2grid((2,columns),(count,count2_temp))  \n",
    "        \n",
    "    #now I repeat the calculation of displacement vectors, but go a bit further out\n",
    "    #so I catch all the tails on the atoms on the edges of the plot\n",
    "        bloch_displacements=[]\n",
    "        for i in range(-4,repeats+4):\n",
    "            for j in range(-4,repeats+4):    \n",
    "                bloch_displacements.append(i*a+j*b)\n",
    "                #bloch_displacements.append([sum(x) for x in zip([i*x for x in a],[j*y for y in b])])\n",
    "\n",
    "    #loop over each basis function\n",
    "        for k in range(len(bloch_coeff[bloch_orbital])):\n",
    "            atomindex=eh_basis_functs[k][1];exponent=eh_basis_functs[k][6][0];n=eh_basis_functs[k][2]\n",
    "        #now loop over each displacement vector        \n",
    "            for i in range(len(bloch_displacements)):\n",
    "            #work out the phase factor\n",
    "                phase=np.exp(1j*np.dot(ktot,bloch_displacements[i]))\n",
    "                #print(\"phase\",kpt,k,i,phase)\n",
    "                phase_symm=np.exp(1j*np.dot(ktot,bloch_displacements[i])).real  \n",
    "                phase_antisymm=np.exp(1j*np.dot(ktot,bloch_displacements[i])).imag\n",
    "            #work out where each atom in the unit cell is project to by the displacement vector\n",
    "                psi_coords=[sum(xyz) for xyz in zip(coords[atomindex], bloch_displacements[i])]\n",
    "            #print(k,i,psi_coords)\n",
    "            #calculate the vector to this point from anywhere in the XY grid\n",
    "                vecij=[(X-psi_coords[0]),(Y-psi_coords[1]),-psi_coords[2]+offset]\n",
    "            #work out the distance to this point\n",
    "                distij=np.linalg.norm(vecij)         \n",
    "            #set angular factors for the projection onto the plane. Note that these are identical to the angular factors for overlap\n",
    "            #with an s orbital at the same point, so I can re-use the direction cosines used in the calculation of the overlap.\n",
    "                dcn=vecij[2]/distij\n",
    "                dcm=vecij[1]/distij\n",
    "                dcl=vecij[0]/distij\n",
    "                angular_factor=1.    #1 for an s orbitals    \n",
    "                if eh_basis_functs[k][3]==1 and eh_basis_functs[k][4]==0:     #p orbitals\n",
    "                    angular_factor=dcn\n",
    "                elif eh_basis_functs[k][3]==1 and eh_basis_functs[k][4]==1:  \n",
    "                    angular_factor=dcl\n",
    "                elif eh_basis_functs[k][3]==1 and eh_basis_functs[k][4]==-1:\n",
    "                    angular_factor=dcm\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==-2:   #d orbitals\n",
    "                    angular_factor=3**0.5*dcl*dcm\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==-1:\n",
    "                    angular_factor=3**0.5*dcm*dcn\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==0:\n",
    "                    angular_factor=dcn**2-0.5*(dcl**2+dcm**2)\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==1:\n",
    "                    angular_factor=3**0.5*dcl*dcn\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==2:\n",
    "                    angular_factor=3**0.5*(dcl**2-dcm**2)\n",
    "\n",
    "                if len(norms[k])==1:   #if it is single zeta\n",
    "                #print(bloch_coeff[bloch_orbital][k])\n",
    "                    #psi+=norms[k][0]*bloch_coeff[k].real()*np.exp(-exponent*distij)*distij**(n-1)*angular_factor*phase_symm\n",
    "                    psi+=norms[k][0]*bloch_coeff[bloch_orbital][k]*np.exp(-exponent*distij)*distij**(n-1)*angular_factor*phase\n",
    "                else:                #if it is double zeta\n",
    "                    psi+=bloch_coeff[bloch_orbital][k]*angular_factor\\\n",
    "                    *norms[k][0]*norms[k][1]*np.exp(-exponent1*distij)*distij**(n-1)\\\n",
    "                    *norms[k][2]*norms[k][3]*np.exp(-exponent2*distij)*distij**(n-1)*phase\n",
    "\n",
    "        #levels=np.arange(-4.0,4.0,0.25)\n",
    "        #levels=np.linspace(-4.0,4.0,32)\n",
    "        ax4.set_xlim([xmin,xmax]);ax4.set_ylim([ymin,ymax])\n",
    "        #ax4.set_ylim([0,12.]);ax4.set_xlim([0,12.])\n",
    "        ax4.contour(X,Y,psi, colors='k',levels=levels)\n",
    "        for line in ax4.collections:\n",
    "            if line.get_linestyle() == [(None, None)]:\n",
    "                line.set_color('blue')\n",
    "            else:\n",
    "                line.set_color('green')\n",
    "        \n",
    "    #first, plot the atomic positions  \n",
    "\n",
    "    \n",
    "        for i in range(len(bloch_coords)):\n",
    "            if bloch_atoms[i]==1:\n",
    "                atom_colour='k'\n",
    "            else:\n",
    "                atom_colour=[x/255 for x in atom_colours[bloch_atoms[i]]]\n",
    "            size=ionic_radii[bloch_atoms[i]]*50\n",
    "            ax4.scatter(bloch_coords[i][0],bloch_coords[i][1],color=atom_colour,s=size)\n",
    "        for x in range(len(bloch_coords)):\n",
    "            for y in range(x,len(bloch_coords)):\n",
    "                if x<y:\n",
    "                    vecab=[(bloch_coords[y][0]-bloch_coords[x][0]),(bloch_coords[y][1]-bloch_coords[x][1]),(bloch_coords[y][2]-bloch_coords[x][2])]\n",
    "                    distab=np.linalg.norm(vecab)\n",
    "                    sum_of_radii=(ionic_radii[bloch_atoms[x]]+ionic_radii[bloch_atoms[y]])/A0 \n",
    "                    if distab<1.15*sum_of_radii:  #define bonded cutoff as 110% of sum of covalent radii                                         \n",
    "                        ax4.plot([bloch_coords[y][0],bloch_coords[x][0]],[bloch_coords[y][1],bloch_coords[x][1]], color=\"black\",lw=1)  \n",
    "        \n",
    "        \n",
    "        \n",
    "        count+=1\n",
    "    #ax4.clabel(CS,inline=1, fontsize=10)\n",
    "  elif d1:  \n",
    "    norms=[]\n",
    "    for basis_funct in eh_basis_functs:\n",
    "            #if basis_funct[3]==2:\n",
    "            if type(basis_funct[6][0]) is tuple:\n",
    "                n=basis_funct[2]\n",
    "                exponent1=basis_funct[6][0][0];exponent2=basis_funct[6][1][0]\n",
    "                coeff1=basis_funct[6][0][1];coeff2=basis_funct[6][1][1]\n",
    "                norm1=(2*exponent1)**n*np.sqrt(2*exponent1/m.factorial(2*n))\n",
    "                norm2=(2*exponent1)**n*np.sqrt(2*exponent2/m.factorial(2*n))            \n",
    "                norms.append([norm1,coeff1,norm2,coeff2])\n",
    "            else:\n",
    "                exponent=basis_funct[6][0];n=basis_funct[2]\n",
    "                norm=(2*exponent)**n*np.sqrt(2*exponent/m.factorial(2*n))\n",
    "                norms.append([norm])    \n",
    "\n",
    "    for kpt in bloch_kpts:\n",
    "        bloch_kz=kpt;bloch_kx=0.;bloch_ky=0.\n",
    "        ktot=bloch_kz*C\n",
    "        ax4=plt.subplot2grid((nrows,ncolumns),(1+count,ncolumns-1), colspan=1, rowspan=1)\n",
    "        plot_title='kz='+str(np.round(bloch_kz,decimals=2)),', level='+str(np.round(bloch_orbital+1,decimals=2))\n",
    "        ax4.set_title(plot_title)\n",
    "        ax4.set_aspect('equal','datalim')\n",
    "        #ax4.set_xlabel('x');ax4.set_ylabel('y') \n",
    "        \n",
    "        \n",
    "        bloch_displacements=[]\n",
    "        for i in range(-repeats,repeats+1): \n",
    "            bloch_displacements.append(i*c)\n",
    "            #bloch_displacements.append([i*x for x in c])\n",
    "        bloch_coords=[];bloch_atoms=[]\n",
    "        for k in range(len(bloch_displacements)):\n",
    "            for i in range(len(coords)):\n",
    "                bloch_coords.append([sum(xyz) for xyz in zip(coords[i], bloch_displacements[k])])\n",
    "                bloch_atoms.append(atoms[i])#;all_atoms.append(atoms[i])#;all_atoms.append(atoms[i]);all_atoms.append(atoms[i])\n",
    "        \n",
    "        #identifymax and min coords        \n",
    "        xcoord=[];ycoord=[];zcoord=[]\n",
    "        for item in bloch_coords:\n",
    "            xcoord.append(item[0]);ycoord.append(item[1]);zcoord.append(item[2])\n",
    "        xmax=max(xcoord);xmin=min(xcoord);ymax=max(ycoord);ymin=min(ycoord);zmax=max(zcoord);zmin=min(zcoord)\n",
    "        #print(xmin,xmax,zmin,zmax)\n",
    "    #setup grid in xyz plan\n",
    "        x=np.linspace(xmin-4,xmax+4,101);y=np.linspace(ymin-4,ymax+4,101);z=np.linspace(zmin,zmax,101)\n",
    "        [X,Z] = np.meshgrid(x,z)\n",
    "\n",
    "    #calculate bloch eigenstates at specific kx,ky\n",
    "        e,bloch_coeff=single_point(bloch_kx,bloch_ky,bloch_kz,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,eh_basis_functs)\n",
    "  \n",
    "    #print(\"coeff\",bloch_coeff)    \n",
    "\n",
    "    #initialise psi    \n",
    "        psi=0.   \n",
    "        \n",
    "    #now repeat the calculation of displacement vectors, but go a bit further out\n",
    "    #so I catch all the tails on the atoms on the edges of the plot\n",
    "        bloch_displacements=[]\n",
    "        for i in range(-repeats-4,repeats+5):\n",
    "            for j in range(-repeats-4,repeats+5):    \n",
    "                bloch_displacements.append(i*c)\n",
    "                #bloch_displacements.append([sum(x) for x in zip([i*x for x in a],[j*y for y in c])])\n",
    "\n",
    "    #loop over each basis function\n",
    "        for k in range(len(bloch_coeff[bloch_orbital])):\n",
    "            atomindex=eh_basis_functs[k][1];exponent=eh_basis_functs[k][6][0];n=eh_basis_functs[k][2]\n",
    "        #now loop over each displacement vector        \n",
    "            for i in range(len(bloch_displacements)):\n",
    "            #work out the phase factor\n",
    "                phase=np.exp(1j*np.dot(ktot,bloch_displacements[i]))\n",
    "                #print(\"phase\",kpt,k,i,phase)\n",
    "                phase_symm=np.exp(1j*np.dot(ktot,bloch_displacements[i])).real  \n",
    "                phase_antisymm=np.exp(1j*np.dot(ktot,bloch_displacements[i])).imag\n",
    "            #work out where each atom in the unit cell is project to by the displacement vector\n",
    "                psi_coords=[sum(xyz) for xyz in zip(coords[atomindex], bloch_displacements[i])]\n",
    "            #print(k,i,psi_coords)\n",
    "            #calculate the vector to this point from anywhere in the XY grid\n",
    "                vecij=[(X-psi_coords[0]),-psi_coords[1]+offset,(Z-psi_coords[2]),]\n",
    "            #work out the distance to this point\n",
    "                distij=np.linalg.norm(vecij)         \n",
    "            #set angular factors for the projection onto the plane. Note that these are identical to the angular factors for overlap\n",
    "            #with an s orbital at the same point, so I can re-use the direction cosines used in the calculation of the overlap.\n",
    "                dcn=vecij[2]/distij\n",
    "                dcm=vecij[1]/distij\n",
    "                dcl=vecij[0]/distij\n",
    "                angular_factor=1.    #1 for an s orbitals    \n",
    "                if eh_basis_functs[k][3]==1 and eh_basis_functs[k][4]==0:     #p orbitals\n",
    "                    angular_factor=dcn\n",
    "                elif eh_basis_functs[k][3]==1 and eh_basis_functs[k][4]==1:  \n",
    "                    angular_factor=dcl\n",
    "                elif eh_basis_functs[k][3]==1 and eh_basis_functs[k][4]==-1:\n",
    "                    angular_factor=dcm\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==-2:   #d orbitals\n",
    "                    angular_factor=3**0.5*dcl*dcm\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==-1:\n",
    "                    angular_factor=3**0.5*dcm*dcn\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==0:\n",
    "                    angular_factor=dcn**2-0.5*(dcl**2+dcm**2)\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==1:\n",
    "                    angular_factor=3**0.5*dcl*dcn\n",
    "                elif eh_basis_functs[k][3]==2 and eh_basis_functs[k][4]==2:\n",
    "                    angular_factor=3**0.5*(dcl**2-dcm**2)\n",
    "\n",
    "                if len(norms[k])==1:   #if it is single zeta\n",
    "                #print(bloch_coeff[bloch_orbital][k])\n",
    "                    #psi+=norms[k][0]*bloch_coeff[k].real()*np.exp(-exponent*distij)*distij**(n-1)*angular_factor*phase_symm\n",
    "                    psi+=norms[k][0]*bloch_coeff[bloch_orbital][k]*np.exp(-exponent*distij)*distij**(n-1)*angular_factor*phase\n",
    "                else:                #if it is double zeta\n",
    "                    psi+=bloch_coeff[bloch_orbital][k]*angular_factor\\\n",
    "                    *norms[k][0]*norms[k][1]*np.exp(-exponent1*distij)*distij**(n-1)\\\n",
    "                    *norms[k][2]*norms[k][3]*np.exp(-exponent2*distij)*distij**(n-1)*phase\n",
    "\n",
    "        #levels=np.arange(-20,20,3.)\n",
    "        #levels=np.linspace(-4.0,4.0,32)\n",
    "        ax4.set_xlim([xmin-4,xmax+4]);ax4.set_ylim([zmin,zmax])\n",
    "        ax4.contour(X,Z,psi, colors='k',levels=levels)\n",
    "        for line in ax4.collections:\n",
    "            if line.get_linestyle() == [(None, None)]:\n",
    "                line.set_color('blue')\n",
    "            else:\n",
    "                line.set_color('green')\n",
    "    #first, plot the atomic positions  \n",
    "    #these next few lines plot the unit cell + extensions\n",
    "        #print(all_coords)\n",
    "    \n",
    "        for i in range(len(bloch_coords)):\n",
    "            if bloch_atoms[i]==1:\n",
    "                atom_colour='k'\n",
    "            else:\n",
    "                atom_colour=[x/255 for x in atom_colours[bloch_atoms[i]]]\n",
    "            size=ionic_radii[bloch_atoms[i]]*50\n",
    "            ax4.scatter(bloch_coords[i][0],bloch_coords[i][2],color=atom_colour,s=size)\n",
    "        for x in range(len(bloch_coords)):\n",
    "            for y in range(x,len(bloch_coords)):\n",
    "                if x<y:\n",
    "                    vecab=[(bloch_coords[y][0]-bloch_coords[x][0]),(bloch_coords[y][1]-bloch_coords[x][1]),(bloch_coords[y][2]-bloch_coords[x][2])]\n",
    "                    distab=np.linalg.norm(vecab)\n",
    "                    sum_of_radii=(ionic_radii[bloch_atoms[x]]+ionic_radii[bloch_atoms[y]])/A0 \n",
    "                    if distab<1.15*sum_of_radii:  #define bonded cutoff as 110% of sum of covalent radii  \n",
    "                        #print(\"hit\")                                       \n",
    "                        ax4.plot([bloch_coords[y][0],bloch_coords[x][0]],[bloch_coords[y][2],bloch_coords[x][2]], color=\"black\",lw=1)  \n",
    "        \n",
    "        \n",
    "        count+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PERIODIC EXTENDED HUCKEL THEORY \n",
      "\n",
      "A notebook for calculating DOS, PDOS and band structures for common inorganic solids \n",
      "\n",
      "the following standard input files are available:\n",
      "\n",
      "    Toy hydrogen models:\n",
      "\n",
      "    linear_H, linear_H2, linear_H4,\n",
      "    distorted_H2, distorted_H4,\n",
      "    square_H, square_H4, hexagonal_H,\n",
      "    fcc_H\n",
      "\n",
      "    1-dimensional systems:\n",
      "\n",
      "    Carbon-based systems:\n",
      "    linear_C, linear_C2, distorted_C2,\n",
      "    trans_polyacetylene, distorted_trans_polyacetylene,\n",
      "    Metals:\n",
      "    Pt2H8, distorted_Pt2H8, Pt2CN8,\n",
      "    poly_SN\n",
      "\n",
      "    2-dimensional systems:\n",
      "\n",
      "    graphite, diamond, 2d_graphene,\n",
      "    2d_Au, 2d_MoS2, 2d_NbS2, square_CuO,\n",
      "\n",
      "    Semiconductors:\n",
      "    diamond, Si, Ge, Sn, BN, BP, AlN, AlP, AlAs, AlSb, GaN, GaP\n",
      "\n",
      "    GaAs, GaSb, CuCl, ZnS, CdS\n",
      "\n",
      "    Bulk metals:\n",
      "\n",
      "    BCC:\n",
      "    bcc_Na, bcc_W, bcc_Fe, bcc_K, bcc_V, bcc_Nb, bcc_Mo, bcc_Cr,\n",
      "\n",
      "    HCP:\n",
      "    hcp_Al, hcp_Mg, hcp_Ti, hcp_Zr, hcp_Co, hcp_Ru, hcp_Zn,\n",
      "\n",
      "    FCC:\n",
      "    fcc_Ca, fcc_Cu, fcc_Au, fcc_Pt, fcc_Al, fcc_Ni, fcc_Ag, fcc_Pb, fcc_Pd,\n",
      "\n",
      "    Ionic Solids:\n",
      "\n",
      "    Rock-salt:\n",
      "    NaCl structure, LiF, NaF, LiCl, NaCl, MgO, TiN, TiC, TiO, VO\n",
      "\n",
      "    CrO, CrN, FeO, NiO, CuO\n",
      "\n",
      "    NiAs structure:\n",
      "    alloys: NiAs, CrS, VS:\n",
      "\n",
      "    Rutile structure:\n",
      "    t_TiO2, t_VO2, t_RuO2, t_CrO2, t_MnF2, t_NiF2, t_ZnF2\n",
      "\n",
      "    Perovskite-like:\n",
      "    ReO3, WO3, NaWO3, SrTiO3, SrVO3, SrMnO3, SrNbO3, SrMoO3,\n",
      "\n",
      "    YCrO3, KNiF3, NaVF3\n",
      "\n",
      "    Layered Structures:\n",
      "    graphite, hexagonal_BN, KC8, C8Br, TiS2, NbS2, MoS2, SrVO2H\n",
      "name of input file (without .input extension)?linear_H\n",
      "treating the system as 1-dimensional (no dispersion in x and y directions) \n",
      "\n",
      "lattice parameters: c =  1.5 Angstrom\n",
      "\n",
      "\n",
      "formula unit: \n",
      "H 1\n",
      "\n",
      "\n",
      "charge per unit cell 0.0 \n",
      "\n",
      "atomic coordinates \n",
      "\n",
      "H               0.00000         0.00000         0.00000        \n",
      "\n",
      "\n",
      " **********************************************\n",
      "Computational Details \n",
      "\n",
      "sampling Brillouin zone on an 0 x 0 x 2000  grid\n",
      "interpolated to  0 x 0 x 5000  grid\n",
      "overlap with  5  unit cells is considered\n",
      "\n",
      "\n",
      " **********************************************\n",
      "Do you want to change any of these parameters?, Y/N  N\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "###############################################\n",
      "Starting the periodic calculation\n",
      "Structure projected onto the 001 plane\n",
      "using covalent_radii dictionary\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANcAAAFNCAYAAACT9/okAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYiElEQVR4nO3de5hkdX3n8fenZxiwRyL3y8BMFbegQAKRzkQ3uM8IiDirTNiYBO0oJO5WcGVXd+OKpl0fAumskBizrhe2owSVEvAGThQVjCaYZLn08HC/yIDTwwy38cIAtpEd+e4f59djTVHVXdPdv6oz1Z/X85xnTv3Or05960x9+lz6dP0UEZjZ/BvodQFm/crhMsvE4TLLxOEyy8ThMsvE4TLLxOHqEkmvkvTArrJemzuHq0si4rsRcfRc1yMpJB053+udT5JWSdo0x3W8WdKEpJ9IulbSPg3L9pF0TVo2IenNDcsOlrRW0qNpW1XnUsdcOFzzRNLiXtfQLyQdC/wf4C3AgcAk8PGGLh8DnkvLhoFPpOcAPA98A/jtrhXcTkR4ajMBG4D3AfcCPwb+FtgjLVsFbALOBx4HPgvsDvw18Gia/hrYvbF/w7qXAV8CtgDfB/5Lw7JFwJ8ADwHPAOuA5cCNQAA/AZ4Ffq/Fel8G/APwFHAPcEbDssspPphfS+u9GThimvd/RlrHU2mdL2vaNu8G7gS2AlcDewBLgZ9SfMifTdOy6bZNi9f9c+BzDY+PoAjTnmn9zwG/3LD8s8AHm9axOG2ras8+P73+AJd5Sh+gu9MHex/gn4E/S8tWAduAi9MH50XAhcBNwAHA/sC/ABc19N+U5gdSYD4ALAEOBx4GXpuW/3fgLuBoQMDxwL5pWQBHNtTYuN7dgPUpmEuAk1OIjk7LLwd+CKxMH746cFWb9/7LFCF+TVrve9K6lzRsm1tScPYB7gPOba6pYX1tt02L1/4KcH5T27PAicCvAZNNy94N/F1Tm8NV5il9gM5teLwaeKjhA/QcaU+W2h4CVjc8fi2wofkDB/wGsLHptd4H/G2afwBY06am6cL1Koq96EDD8iuBC9L85cAnm97P/W1e538An294PABsBlY1bJvfb1h+CXBpc02dbJsWr/33jds9tW1O630V8HjTsv8I/ENTW8/D5fOEmT3SMD9B8ZN6ypaI+NeGx8tSn3b9p1SAZZKeamhbBHw3zS+n+DDurGXAIxHxfFMNhzQ8frxhfhJ48TTr2v5eIuJ5SY/MsK5W77Xl+mi/baDYS/1SU9svUeyFn59mWan4gsbMljfMr6A4X5jS/CcFj1IEp13/KY8A34+IvRqmPSNidcPyI2ZR66PAckmN/68rKH7qz2Zd29+LJFFsi07W1epPLTrdNlCc5x3f8NqHUxx6fy9NiyUd1dD/+PScUnG4ZvYOSYemS8EjFCfu7VwJvF/S/pL2ozinuqJFv1uAZySdL+lFkhZJOk7Sr6flnwQuknSUCr8qad+07AmKc7RWbqbYg7xH0m6SVgFvAK7aifc75fPAv5N0iqTdgD8GfkZxrjSTJ4B9Jb2koa3TbQPFueAb0u/wllKcr305Ip6JiJ8AXwYulLRU0m8CayguagAgaQ+KMALsnh53X6+OR3eFiR2vFj4FfBoYjPbnFXsAHwEeS9NHaLq62NB3GcUH7nGKK5E3AaemZYuA91NcRXwGuBU4NC07N637KeB3W6z3WOAfKa7g3Quc2bDsctIFmXbvoen9nJnWsTWt89imbXNqw+MLgCsaHl9GcfHkqfRe226bNq/9ZmAjxUWVrwD7NCzbB7g2LdsIvLnpudE89eLzo1SMtSBpA/AfIuJb87CukykuJrTb61if8WFh9xxHsSeyBaKn4ZJ0maQnJd3d0LaPpBskPZj+3bvNc89OfR6UdHb3qt55kv4X8F+BP+11LdY9PT0slPRvKS67fiYijkttlwA/iogPSnovsHdEnN/0vH2AcWCI4ph6HXBiRPy4q2/AbBo93XNFxI3Aj5qa11BcOCD9+1stnvpa4IaI+FEK1A3A6bnqNJuNMp5zHRgRj6X5xyluzmx2CDv+cncTO/5y06znSn2HRkSEpDkdt0qqATWApUuXnvjSl750Xmqz/rZu3bofRMT+c1lHGcP1hKSDI+IxSQcDT7boM3Wf2ZRDKe7afoGIGAPGAIaGhmJ8fHx+q7W+JGli5l7TK+Nh4Vpg6urf2RS/QGz2TeA0SXunq4mnpTaz0uj1pfgrgf8LHC1pk6S3AR8EXiPpQeDU9BhJQ5I+CRARPwIuorhz4VbgwtRmVhoL6g4NHxZapySti4ihuayjjIeFZn3B4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsuklOGSdLSk2xumpyW9q6nPKklbG/p8oEflmrVUxlFOiIgHgBMAJC2iGNXkmhZdvxsRr+9iaWYdK+Weq8kpwEMRMechXcy6aVcI11nAlW2WvVLSHZK+LunYbhZlNpNSh0vSEuAM4AstFt8GVCLieOB/A9e2WUdN0rik8S1btmSr1axZqcMFvA64LSKeaF4QEU9HxLNp/jpgN0n7teg3FhFDETG0//5zGoXTbKeUPVxvos0hoaSDJCnNr6R4Lz/sYm1m0yrl1UIASUuB1wB/1NB2LkBEXAq8EXi7pG3AT4GzYiGN5GelV9pwRcRPgH2b2i5tmP8o8NFu12XWqbIfFprtshwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcrgWqXq9TrVYZGBigWq1Sr9d7XVLfKe2f+Vs+9XqdWq3G5OQkABMTE9RqNQCGh4d7WVpf8Z5rARoZGdkerCmTk5OMjIz0qKL+5HAtQBs3btypdpsdh2sBWrFixU612+w4XAvQ6Ogog4ODO7QNDg4yOjrao4r6k8O1AA0PDzM2NkalUkESlUqFsbExX8yYZ1pIX1I7NDQU4+PjvS7DdgGS1kXE0FzWUdo9l6QNku5Ko0a+IBEqfETSekl3Snp5L+o0a6fsv+d6dUT8oM2y1wFHpek3gE+kf81KobR7rg6sAT4ThZuAvSQd3OuizKaUOVwBXC9pnaRai+WHAI80PN6U2sxKocyHhSdFxGZJBwA3SLo/Im7c2ZWkYNbAv8ex7irtnisiNqd/nwSuAVY2ddkMLG94fGhqa16PR5a0nihluCQtlbTn1DxwGnB3U7e1wFvTVcNXAFsj4rEul2rWVlkPCw8Erkmjsi4GPhcR32gaWfI6YDWwHpgE/qBHtZq1VMpwRcTDwPEt2htHlgzgHd2sy2xnlPKw0KwfOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XAtUvV6nWq0yMDBAtVqlXq/3uqS+U8qvVrO86vU6tVpt+6DjExMT1GrF1/F7ALz54z3XAjQyMrI9WFMmJycZGRnpUUX9yeFagDZu3LhT7TY7pQuXpOWSviPpXkn3SHpniz6rJG1No07eLukDvah1V9VutBePAjO/ShcuYBvwxxFxDPAK4B2SjmnR77sRcUKaLuxuibu20dFRBgcHd2gbHBxkdHS0RxX1p9KFKyIei4jb0vwzwH14ULt5NTw8zNjYGJVKBUlUKhXGxsZ8MWOeqRjPoJwkVYEbgeMi4umG9lXAlyhGk3wUeHdE3DPT+oaGhmJ8/AVjl5u9gKR1ETE0l3WU9lK8pBdTBOhdjcFKbgMqEfGspNXAtRQDj7daj0eWtJ4o3WEhgKTdKIJVj4gvNy+PiKcj4tk0fx2wm6T9Wq3LI0tar5QuXCpGvPsUcF9E/FWbPgelfkhaSfE+fti9Ks1mVsbDwt8E3gLcJen21PYnwArYPgDeG4G3S9oG/BQ4K8p88mgLUunCFRH/BGiGPh8FPtqdisxmp3SHhWb9wuEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvE4TLLpLThknS6pAckrZf03hbLd5d0dVp+cxpuyKw0ShkuSYuAjwGvA44B3tRidMm3AT+OiCOBDwMXd7fKXVu9XqdarTIwMEC1WqVer/e6pL4zY7gk/WdJe3ejmAYrgfUR8XBEPAdcBaxp6rMG+HSa/yJwytTIJza9er1OrVZjYmKCiGBiYoJareaAzbNO9lwHArdK+nw6VOvGB/gQ4JGGx5t44dCt2/tExDZgK7BvF2rb5Y2MjDA5OblD2+TkJCMjIz2qqD/NGK6IeD/FqI2fAs4BHpT055KOyFzbvJBUkzQuaXzLli29LqcUNm7cuFPtNjsdnXOlsa8eT9M2YG/gi5IuyVTXZmB5w+NDU1vLPpIWAy+hxQB4HlnyhdoNX+thbedXJ+dc75S0DrgE+GfgVyLi7cCJwG9nqutW4ChJh0laApwFrG3qsxY4O82/Efi2B8DrzOjoKIODgzu0DQ4OMjo62qOK+lRETDsBf0oxuHerZS+b6fmznYDVwPeAh4CR1HYhcEaa3wP4ArAeuAU4fKZ1nnjiiWGFK664IiqVSkiKSqUSV1xxRa9LKhVgPOb4GVYsoB/2Q0NDMT4+3usybBcgaV1EDM1lHaX8PZdZP3C4zDJxuMwycbjMMnG4zDJxuMwycbjMMnG4zDJxuMwycbjMMnG4zDJxuMwycbjMpnc58NUW7UNAANV2T3S4zDJxuMwycbjMMlnc6wLMdgGnA882tc24Y3K4zGZ2I1BrajsOuGa6JzlcZjObpPiulkZ7zfQkn3OZZeJwmWXicJll4nMus+md06Z9HJh23ATvucwycbjMMinVYaGkvwDeADxH8TXWfxART7XotwF4Bvg5sG2u34xqlkPZ9lw3AMdFxK9SfE/8+6bp++qIOMHBsrIqVbgi4vooBrIDuIli6CCzXVKpwtXkD4Gvt1kWwPWS1klqvi3FrBS6fs4l6VvAQS0WjUTEV1KfEYpB9toN0ntSRGyWdABwg6T7I+LGNq9XI90X5sHdrJu6vueKiFMj4rgW01SwzgFeDwxHm/GNImJz+vdJipsnV07zeh5ZsoV6vU61WmVgYIBqterBxjMo1WGhpNOB91AMcDfZps9SSXtOzQOnAXd3r8pdX71ep1arMTExQUQwMTFBrVZzwOZZqQa/k7Qe2J1fjG18U0ScK2kZ8MmIWC3pcH5xq/9i4HMR0dF4ox78rlCtVpmYmHhBe6VSYcOGDd0vqITmY/C7Uv2eKyKObNP+KMUwrkTEw8Dx3ayr32zcuHGn2m12SnVYaN3R7sKOL/jML4drARodHWVwcHCHtsHBQUZHOzq6tg45XAvQ8PAwY2NjVCoVJFGpVBgbG2N4eLjXpfWVUl3QyM0XNKxT83FBw3sus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcLrNMHC6zTEoXLkkXSNos6fY0rW7T73RJD0haL+m93a7TbCal+jrrBh+OiL9st1DSIuBjwGuATcCtktZGxL3dKtBsJqXbc3VoJbA+Ih6OiOeAq4A1Pa7JbAdlDdd5ku6UdJmkvVssPwR4pOHxptRmVho9CZekb0m6u8W0BvgEcARwAvAY8KE5vlZN0rik8S1btsy9eLMO9eScKyJO7aSfpL8Bvtpi0WZgecPjQ1Nbq9caA8ag+DrrnavUbPZKd1go6eCGh2fSetTIW4GjJB0maQlwFrC2G/WZdaqMVwsvkXQCEMAG4I8AGkeXjIhtks4DvgksAi6LiHt6VK9ZS6ULV0S8pU379tEl0+PrgOu6VZfZzirdYaFZv3C4Fqh6vU61WmVgYIBqtUq9Xu91SX2ndIeFll+9XqdWqzE5OQnAxMQEtVoNwKNLziPvuRagkZGR7cGaMjk5ycjISI8q6k8O1wK0cePGnWq32XG4FqAVK1bsVLvNjsO1AI2OjjI4OLhD2+DgIKOjoz2qqD85XAvQ8PAwY2NjVCoVJFGpVBgbG/PFjHmmiIVzu93Q0FCMj4/3ugzbBUhaFxFDc1mH91xmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmThcZpk4XGaZOFxmmZTqq9UkXQ0cnR7uBTwVESe06LcBeAb4ObBtrn/UZpZDqcIVEb83NS/pQ8DWabq/OiJ+kL8qs9kpVbimSBLwu8DJva7FbLbKes71KuCJiHiwzfIArpe0TlKti3WZdazrey5J3wIOarFoJCK+kubfBFw5zWpOiojNkg4AbpB0f0Tc2Ob1akAN/L181l2l+/YnSYspRok8MSI2ddD/AuDZiPjLmfr625+sU/367U+nAve3C5akpZL2nJoHTqP16JNmPVXGcJ1F0yGhpGWSpga6OxD4J0l3ALcAX4uIb3S5RrMZle5qYUSc06Jt+6iSEfEwcHyXyzLbaWXcc5n1BYfLLBOHyywTh8ssE4fLLBOHyywTh8ssE4fLLBOHyywTh8ssE4fLLBOHyywTh8ssE4fLLBOHyywTh8ssE4fLLBOHyywTh8ssE4fLLBOHyywTh8ssE4fLLBOHyywTh8ssk56ES9LvSLpH0vOShpqWvU/SekkPSHptm+cfJunm1O9qSUu6U7lZ53q157ob+PfADsP+SDqG4rvijwVOBz4uaVGL518MfDgijgR+DLwtb7lmO68n4YqI+yLigRaL1gBXRcTPIuL7wHpgZWOHNOrkycAXU9Ongd/KWK7ZrJTtnOsQ4JGGx5tSW6N9KQYi3zZNH7OeyzbKSYcjSGbXOLIk8DNJZRnLaz+gDAOml6UOKFctR891BdnCFRGnzuJpm4HlDY8PTW2NfgjsJWlx2nu16tNYxxgwBiBpfK6jBc6XstRSljqgfLXMdR1lOyxcC5wlaXdJhwFHUQxwt10U48x+B3hjajob6Nqe0KxTvboUf6akTcArga9J+iZARNwDfB64F/gG8I6I+Hl6znWSlqVVnA/8N0nrKc7BPtXt92A2k9INOJ6TpFo6TOy5stRSljqg/2pZUOEy66aynXOZ9Y2+DpekCyRtlnR7mla36Xd6ut1qvaT3ZqjjLyTdL+lOSddI2qtNvw2S7kq1zvlqVdO6p32P6SLS1Wn5zZKq8/n6Da+zXNJ3JN2bboF7Z4s+qyRtbfh/+0COWtJrTbvNVfhI2i53Snp5xyuPiL6dgAuAd8/QZxHwEHA4sAS4Azhmnus4DVic5i8GLm7TbwOwX4btMON7BP4TcGmaPwu4OtP/ycHAy9P8nsD3WtSyCvhqlz4j025zYDXwdUDAK4CbO113X++5OrQSWB8RD0fEc8BVFLdhzZuIuD5+cUfJTRS/m+umTt7jGopbyaC4teyUdKvZvIqIxyLitjT/DHAf5b7DZg3wmSjcRPE71oM7eeJCCNd5aXd+maS9Wyzv5Jar+fSHFD8JWwngeknr0p0l86WT97i9T/pBsJXi1xzZpEPPXwNubrH4lZLukPR1ScdmLGOmbT7rz0e2OzS6ZbrbrIBPABdRbMCLgA9RfLi7Wkek270kjQDbgHqb1ZwUEZslHQDcIOn+iLixTd9dmqQXA18C3hURTzctvg2oRMSz6Tz5WoobCnLIts13+XBFh7dZSfob4KstFnVyy9Wc65B0DvB64JRIB/Mt1rE5/fukpGsoDufm4z+6k/c41WeTpMXASyhuNZt3knajCFY9Ir7cvLwxbBFxnaSPS9ovIub9vsMOtvmsPx99fVjYdGx8JsXfkTW7FTgq/QHmEoqT+bXzXMfpwHuAMyJisk2fpZL2nJqnuAgyXzcZd/Ie11LcSgbFrWXfbvdDYC7SedyngPsi4q/a9Dlo6nxP0kqKz+m8B73Dbb4WeGu6avgKYGtEPNbRC3TjikyvJuCzwF3AnWkjHZzalwHXNV0R+h7FFbWRDHWspzhuvz1NlzbXQXEl74403TPfdbR6j8CFFIEH2AP4Qqr1FuDwTP8nJ1Ecpt/ZsD1WA+cC56Y+56VtcAfFBaB/k6mWltu8qRYBH0vb7S5gqNP1+w4Ns0z6+rDQrJccLrNMHC6zTBwus0wcLrNMHC6zTBwus0wcrgVK0q+nG5r3SHcq3CPpuF7X1U/8S+QFTNKfUdyZ8SJgU0T8zx6X1FccrgUs3Wd4K/CvFLcY/bzHJfUVHxYubPsCL6b4i+A9elxL3/GeawGTtJbir5IPo7ip+bwel9RXdvm/57LZkfRW4P9FxOdUDNP0L5JOjohv97q2fuE9l1kmPucyy8ThMsvE4TLLxOEyy8ThMsvE4TLLxOEyy8ThMsvk/wPVfZIoqXSnwAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 180x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating Properties of the Isolated Unit Cell\n",
      "electrons 1.0     basis functions 1 \n",
      "\n",
      "Sampling BZ in a 0 x 0 x 2000 grid\n",
      "Interpolating the 1st Brillouin zone to convert a 0 x 0 x 2000 grid to a 0 x 0 x 5000 grid\n",
      "Locating the Fermi level\n",
      "looking for Fermi level with 0.5 filled levels\n",
      "average fermi level -16.63 eV\n",
      "Calculating DOS\n",
      "Calculation complete\n"
     ]
    }
   ],
   "source": [
    "plt.close('all')\n",
    "\n",
    "print(\"PERIODIC EXTENDED HUCKEL THEORY\",'\\n')\n",
    "print(\"A notebook for calculating DOS, PDOS and band structures for common inorganic solids\",'\\n')\n",
    "print(list_of_structures)\n",
    "title=input('name of input file (without .input extension)?')\n",
    "while title not in crystal_dict:\n",
    "    print(\"that is not in the library:\")\n",
    "    print('\\n')\n",
    "    print(list_of_structures)\n",
    "    print('\\n')\n",
    "    title=input('name of input file (without .input extension)?  ')\n",
    "    \n",
    "input_from_file=False\n",
    "input_from_library=True\n",
    "cartesian=False\n",
    "parameters=modified_Cerda\n",
    "#parameter_file='parameters'\n",
    "if input_from_file:\n",
    "    a0,b0,c0,beta,symmetry,atoms,Q,coords,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,DOS_min,DOS_max,\\\n",
    "    E_pts,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts=read_from_file(title,parameters)\n",
    "elif input_from_library:\n",
    "    a0,b0,c0,beta,crystal,symmetry,atoms,Q,coords,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,DOS_min,DOS_max,\\\n",
    "    E_pts,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts=read_from_library(title,parameters,cartesian)\n",
    "print('\\n')\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~HERE IS THE WORKFLOW~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "#read from dictionaries and \n",
    "#set up lattice vectors, reciprocal lattice vectors, displacements, coordinates etc\n",
    "\n",
    "print('\\n')\n",
    "print(\"###############################################\")\n",
    "print(\"Starting the periodic calculation\")\n",
    "a,b,c,A,B,C,atoms,coords_in_angstrom,coords_in_au,element_coord,Q,displacements,BZ_path,BZ_labels,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,\\\n",
    "DOS_min,DOS_max,E_pts,symmetry,d1,d2,d3,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts\\\n",
    "=setup(cartesian,a0,b0,c0,beta,title,symmetry,atoms,Q,coords,nptsx,nptsy,nptsz,interp_pointsx,interp_pointsy,interp_pointsz,span,DOS_min,DOS_max,E_pts,plot_all,plot_DOS,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,levels,offset,nneighbours,repeats,bloch_orbitals,bloch_kpts)\n",
    "print(\"Structure projected onto the 001 plane\")\n",
    "unit_cell_2d(title,a0,b0,c0,a,b,c,coords_in_au,atoms,d1,d2,d3,repeats,symmetry)\n",
    "#calculate an isolated unit cell. There is not much value in this, but I need the S and H matrices for later, so may as well diagonalise it.\n",
    "S,H,eh_basis_functs,bf_index,coeff,no_electrons,emin=isolated_unit_cell(coords_in_au,atoms,element_coord,parameters,parameter_file,Q,dist_cutoff,title,WH)\n",
    "#print(eh_basis_functs)\n",
    "#calculate the S and H matrices for extensions along the displacement coordinates.\n",
    "map_S,map_H,map_S_tran,map_H_tran=extended_S_and_H(coords_in_au,atoms,displacements,parameters,dist_cutoff,eh_basis_functs,WH)\n",
    "#define a 3d grid of kx,ky,kz covering the symmetry-unique portion of the BZ \n",
    "print(\"Sampling BZ in a\",nptsx,\"x\",nptsy,\"x\",nptsz,\"grid\")\n",
    "kx,ky,kz=define_BZ(symmetry,A,B,C,nptsx,nptsy,nptsz,d1,d2,d3)\n",
    "#and solve at range of kpoints defined by kx,ky,kz\n",
    "all_energies,all_pts_x,all_pts_y,all_pts_z,all_contributions,all_coop,all_pts=full_BZ_sample(kx,ky,kz,nptsx,nptsy,nptsz,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,symmetry,eh_basis_functs,plot_COOP,d1,d2,d3)\n",
    "#do some interpolation\n",
    "if interpolate_flag:\n",
    "    print(\"Interpolating the 1st Brillouin zone to convert a\",nptsx,\"x\",nptsy,\"x\",nptsz,\"grid to a\",interp_pointsx,\"x\",interp_pointsy,\"x\",interp_pointsz,\"grid\") \n",
    "    all_energies,all_pts_interp=interpolate_BZ(interp_pointsx,interp_pointsy,interp_pointsz,kx,ky,kz,all_energies,eh_basis_functs,d1,d2,d3)\n",
    "    if PDOS_by_basis_funct or PDOS_by_atom or PDOS_by_atom_and_l:\n",
    "        all_contributions=interpolate_contributions_BZ(interp_pointsx,interp_pointsy,interp_pointsz,kx,ky,kz,all_contributions,eh_basis_functs,d1,d2,d3)\n",
    "    if plot_COOP:\n",
    "        all_coop=interpolate_coop_BZ(interp_pointsx,interp_pointsy,interp_pointsz,kx,ky,kz,all_coop,eh_basis_functs)\n",
    "#find the Fermi level\n",
    "print(\"Locating the Fermi level\")\n",
    "Energy_range,states,proj_states,coops,average_Fermi_level=fermi_level(all_energies,E_pts,emin-10,DOS_min,DOS_max,all_contributions,eh_basis_functs,plot_COOP,mesh,span,no_electrons)\n",
    "#calulate the DOS and PDOS\n",
    "print(\"Calculating DOS\")\n",
    "Energy_range_DOS,DOS,all_PDOS,pdos_summed_over_atoms,pdos_summed_over_atoms_and_l,unique_elements=DOS(states,proj_states,Energy_range,eh_basis_functs,atoms)\n",
    "if plot_COOP:\n",
    "    print(\"Calculating COOP\")\n",
    "    Energy_range_COOP,all_COOP=COOP(coops,Energy_range)\n",
    "print(\"Calculation complete\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "do you want to plot the DOS?  Y/N  Y\n",
      "DOS plots: the default settings are:\n",
      "\n",
      "\n",
      "Plotting DOS projected onto all atoms\n",
      "\n",
      "\n",
      "plotting total DOS and DOS projected onto separate angular momenta of each atom \n",
      "plot window:  -25.0 eV to  -10.0 eV in  200  steps \n",
      "\n",
      "\n",
      "\n",
      "do you want to change the DOS plotting options?  Y/N  N\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#~~~~~~~~~~~~~~~~~~~~~~~NOW PLOT THE DOS~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "make_DOS=input('do you want to plot the DOS?  Y/N  ')\n",
    "if make_DOS=='Y':\n",
    "    plot_DOS==True\n",
    "    print(\"DOS plots: the default settings are:\")\n",
    "    print('\\n')\n",
    "    print('Plotting DOS projected onto all atoms')\n",
    "    print('\\n')\n",
    "    if PDOS_by_atom==True:\n",
    "        print(\"plotting total DOS and DOS projected onto separate atoms \")\n",
    "    elif PDOS_by_atom_and_l==True:\n",
    "        print(\"plotting total DOS and DOS projected onto separate angular momenta of each atom \")\n",
    "    elif PDOS_by_basis_funct==True:\n",
    "        print(\"plotting total DOS and DOS projected onto separate orbitals of each atom \")    \n",
    "    print(\"plot window: \", float(DOS_min),\"eV to \",float(DOS_max),\"eV in \",E_pts,' steps','\\n')\n",
    "    print('\\n')          \n",
    "    OK=input('do you want to change the DOS plotting options?  Y/N  ') \n",
    "    new_DOS_min=DOS_min;new_DOS_max=DOS_max;new_E_pts=E_pts  #initialise at original values\n",
    "    elements_to_plot=list(set(atoms)) #plot all atoms by default\n",
    "    total_DOS_plot=True\n",
    "    while OK=='Y' or OK=='y':\n",
    "        print('\\n')\n",
    "        element_choice=input(\"restrict plots to a subset of element types: input a comma separated list of integers, or return to continue  \"  )\n",
    "        if element_choice:\n",
    "            elements_to_plot=[int(s) for s in element_choice.split(',')]    \n",
    "        \n",
    "        print('\\n')\n",
    "        print(\"1 to plot PDOS projected onto atoms\") \n",
    "        print(\"2 for PDOS projected onto separate angular momentum components, l\")\n",
    "        print(\"3 to plot PDOS projected onto separate ml\")\n",
    "        print(\"10 to exit  \"  )\n",
    "        plot_choice=int(input(\"type an integer, 1, 2 or 3  \"  ))\n",
    "        #print(plot_choice)\n",
    "        if plot_choice==1:\n",
    "            PDOS_by_atom=True;PDOS_by_atom_and_l=False;PDOS_by_basis_funct=False      #project DOS onto atoms\n",
    "        elif plot_choice==2:\n",
    "            PDOS_by_atom=False;PDOS_by_atom_and_l=True;PDOS_by_basis_funct=False      #project DOS onto atoms\n",
    "        elif plot_choice==3:\n",
    "            PDOS_by_atom=False;PDOS_by_atom_and_l=False;PDOS_by_basis_funct=True      #project DOS onto atoms\n",
    "        elif plot_choice==10:\n",
    "            break\n",
    "        print('\\n')\n",
    "        print(\"input new plot range:  Emin, Emax, in units of eV \"  )\n",
    "        print('\\n')\n",
    "        range_choice=input(\"enter a comma separated list of floats or hit return if default values are OK  \"  )\n",
    "        if range_choice:\n",
    "            new_DOS_min,new_DOS_max=[float(s) for s in range_choice.split(',')]\n",
    "        print('\\n')\n",
    "        #print(new_DOS_min,new_DOS_max)\n",
    "        print(\"input number of steps for the energy scan (more will give a better sample but may be noisy)\")\n",
    "        steps=input(\"input an integer or hit return if default value is OK  \"  )\n",
    "        if steps:\n",
    "            new_E_pts=int(steps)\n",
    "        print('\\n')\n",
    "        print(\"new plot range: \", new_DOS_min,\"eV to \",new_DOS_max,\"eV in \",E_pts,' steps','\\n')\n",
    "        print('\\n')\n",
    "        \n",
    "        total_DOS=input(\"do you want to plot the total DOS? Y or N. Default is Y \"  )\n",
    "        if total_DOS==('N' or 'n'):\n",
    "            total_DOS_plot=False\n",
    "        OK=input('do you want to change anything else?  Y/N  ') \n",
    "        print('\\n')\n",
    "\n",
    "    DOS_plot(total_DOS_plot,elements_to_plot,DOS,Energy_range_DOS,new_E_pts,PDOS_by_atom,PDOS_by_atom_and_l,PDOS_by_basis_funct,all_PDOS,pdos_summed_over_atoms,pdos_summed_over_atoms_and_l,unique_elements,average_Fermi_level,new_DOS_min,new_DOS_max)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "do you want to plot the band structure? Y/N   Y\n",
      "\n",
      "\n",
      "The default path through the Brillouin zone is:\n",
      "Γ ➜ Π/a\n",
      "\n",
      "\n",
      "The available special kpoints are:\n",
      "Γ [ 0, 0, 0 ]\n",
      "X [ 0, 0, 1/2 ]\n",
      "\n",
      "\n",
      "input a special point, gamma, A, X etc or hit return to finish  \n",
      "\n",
      "\n",
      "The final path through the Brillouin zone is:\n",
      "Γ ➜ Π/a\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#special points used earlier on, converted to a dictionary\n",
    "from fractions import Fraction\n",
    "\n",
    "special_point_dictionary={\"t\":{\"gamma\":[0.,0.,0.],\"X\":[0.5,0.,0.],\"R\":[0.5,0.0,0.5],\"M\":[0.5,0.5,0.],\"A\":[0.5,0.5,0.5],\"Z\":[0.,0.,0.5]},\n",
    "                         \"c\":{\"gamma\":[0.,0.,0.],\"X\":[0.5,0.,0.],\"M\":[0.5,0.5,0.],\"R\":[0.5,0.5,0.5]},\n",
    "                         \"o\":{\"gamma\":[0.,0.,0.],\"X\":[0.5,0.,0.],\"Y\":[0.,0.5,0.],\"Z\":[0.0,0.0,0.5],\"T\":[0.0,0.5,0.5],\"U\":[0.5,0.0,0.5],\"S\":[0.5,0.5,0.],\"R\":[0.5,0.5,0.5]},\n",
    "                         \"fcc\":{\"gamma\":[0.,0.,0.],\"X\":[0,1/2,1/2],\"L\":[1/2,1/2,1/2],\"W\":[1/4,3/4,1/2],\"U\":[5/8,1/4,5/8],\"K\":[3/8,3/8,3/4]},\n",
    "                         \"bcc\":{\"gamma\":[0.,0.,0.],\"N\":[0,0,1/2],\"P\":[1/4,1/4,1/4],\"H\":[-1/2,1/2,1/2]},\n",
    "                         \"h\":{\"gamma\":[0.,0.,0.],\"K\":[2/3,-1/3,0.],\"A\":[0,0,1/2],\"H\":[2/3,-1/3,1/2],\"M\":[1/2,0,0],\"L\":[1/2,0,1/2]},\n",
    "                         \"m\":{\"gamma\":[0.,0.,0.],\"Z\":[0,1/2,0],\"B\":[1/2,0,0],\"Y\":[0,0,1/2],\"C\":[0,1/2,1/2],\"D\":[1/2,1/2,0],\"A\":[1/2,0,-1/2]},\n",
    "                         \"d1\":{\"gamma\":[0,0,0],\"X\":[0,0,1/2]},\n",
    "                         \"d2_square\":{\"gamma\":[0,0,0],\"X\":[0,1/2,0],\"M\":[1/2,1/2,0]},\n",
    "                         \"d2_h\":{\"gamma\":[0,0,0],\"K\":[2/3,-1/3,0],\"M\":[1/2,0,0]}}\n",
    "\n",
    "#can't use a number as start of dictionary key, si I need to redefine some symmetries\n",
    "if symmetry==\"2d_h\":\n",
    "    symmetry=\"d2_h\"\n",
    "elif symmetry==\"2d_square\":\n",
    "    symmetry=\"d2_square\"\n",
    "elif symmetry==\"1d\":\n",
    "    symmetry=\"d1\"\n",
    "\n",
    "\n",
    "make_band=input('do you want to plot the band structure? Y/N   ')\n",
    "if make_band=='Y':\n",
    "    BZ_labels_to_print=[]\n",
    "    #print(BZ_labels)\n",
    "    for item in BZ_labels:\n",
    "        if item=='$\\\\Gamma$':\n",
    "            BZ_labels_to_print.append('\\N{greek capital letter gamma}')\n",
    "            BZ_labels_to_print.append(\"➜\")\n",
    "        elif item=='$\\\\Pi$/a':\n",
    "            BZ_labels_to_print.append('\\N{greek capital letter pi}/a')\n",
    "            BZ_labels_to_print.append(\"➜\")\n",
    "        else:\n",
    "            BZ_labels_to_print.append(item)\n",
    "            BZ_labels_to_print.append(\"➜\")\n",
    "    print('\\n')\n",
    "    print(\"The default path through the Brillouin zone is:\" )\n",
    "    print(*BZ_labels_to_print[:-1])   #the final arrow is removed\n",
    "    print('\\n')\n",
    "    special_points=special_point_dictionary[symmetry]\n",
    "    special_kpoints=[]\n",
    "    for key in special_points:\n",
    "        fractional_list=[]\n",
    "        for item in special_points[key]:\n",
    "            frac=str(Fraction(item).limit_denominator())\n",
    "            fractional_list.append(frac)\n",
    "        special_kpoints.append((key,fractional_list))\n",
    "        #special_kpointsf.append((key,fractional_list))\n",
    "    #print(special_kpointsf)\n",
    "    print(\"The available special kpoints are:\" )\n",
    "    list_of_special_points=[]\n",
    "    for item in special_kpoints:\n",
    "        if item[0]==\"gamma\":\n",
    "            print('\\N{greek capital letter gamma}','[',', '.join(item[1]),']')\n",
    "        else:\n",
    "            print(item[0],'[',', '.join(item[1]),']')\n",
    "        list_of_special_points.append(item[0])\n",
    "    print('\\n')\n",
    "    new_kpt_labels=[];new_kpt_keys=[]\n",
    "    kpt_choice=input('input a special point, gamma, A, X etc or hit return to finish  ') \n",
    "    while kpt_choice:\n",
    "        if kpt_choice not in list_of_special_points:\n",
    "            print('that is not one of the special points  ')\n",
    "        elif kpt_choice==\"gamma\":\n",
    "            new_kpt_keys.append(\"gamma\")\n",
    "            new_kpt_labels.append('$\\\\Gamma$')                \n",
    "        else:\n",
    "            new_kpt_labels.append(kpt_choice)\n",
    "            new_kpt_keys.append(kpt_choice)\n",
    "        kpt_choice=str(input(\"input another point of return to finish  \"  ))\n",
    "    if new_kpt_keys:\n",
    "        new_kpt_coords=[]\n",
    "        for item in new_kpt_keys:\n",
    "            new_kpt_coords.append(special_points[item])\n",
    "        final_BZ_path=new_kpt_coords;final_BZ_labels=new_kpt_labels    \n",
    "    else:\n",
    "        final_BZ_path=BZ_path;final_BZ_labels=BZ_labels\n",
    "    \n",
    "    final_BZ_labels_to_print=[]\n",
    "    for item in final_BZ_labels:\n",
    "        if item=='$\\\\Gamma$':\n",
    "            final_BZ_labels_to_print.append('\\N{greek capital letter gamma}')\n",
    "            final_BZ_labels_to_print.append(\"➜\")\n",
    "        elif item=='$\\\\Pi$/a':\n",
    "            final_BZ_labels_to_print.append('\\N{greek capital letter pi}/a')\n",
    "            final_BZ_labels_to_print.append(\"➜\")\n",
    "        else:\n",
    "            final_BZ_labels_to_print.append(item)\n",
    "            final_BZ_labels_to_print.append(\"➜\")\n",
    "    print('\\n')\n",
    "    print(\"The final path through the Brillouin zone is:\" )\n",
    "    \n",
    "    print(*final_BZ_labels_to_print[:-1])   #the final arrow is removed\n",
    "    print('\\n')\n",
    "    \n",
    "    Band_structure_plot(eh_basis_functs,final_BZ_path,final_BZ_labels,S,map_S,map_S_tran,H,map_H,map_H_tran,A,B,C,a,b,c,displacements,no_electrons,npts_line,DOS_min,DOS_max,average_Fermi_level,d1,d2,d3)\n"
   ]
  },
  {
   "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}