HuckelMO_Nov24.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "IbMtakdKw9OV",
      "metadata": {
        "id": "IbMtakdKw9OV"
      },
      "source": [
        "# HUCKEL Molecular Orbital (HMO) Calculations\n",
        "\n",
        "CHEM344  Physical Chemistry \\\n",
        "Department of Chemistry \\\n",
        "Illinois Institute of Technology \\\n",
        "\n",
        "\n",
        "\n",
        "Original Bash Code By Jingbai Li \\\n",
        "Translated to Python by Joseph DePaolo-Boisvert \\\n",
        "HUCKELMO Version 2.0  Aug 30th 2017 \\\n",
        "Written Nov 2022; Last Updated Nov 2024\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9c0e8a17-1a20-413e-8339-c4b1ee241ac4",
      "metadata": {
        "id": "9c0e8a17-1a20-413e-8339-c4b1ee241ac4"
      },
      "source": [
        "### Basic Operations in Python\n",
        "Python can be used to perform basic mathematical operations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cf8269e3-e30c-4dd0-8797-913553638028",
      "metadata": {
        "id": "cf8269e3-e30c-4dd0-8797-913553638028"
      },
      "outputs": [],
      "source": [
        "#Addition\n",
        "1 + 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "987c7a79-1ae9-4530-b50a-f7e8732ab20e",
      "metadata": {
        "id": "987c7a79-1ae9-4530-b50a-f7e8732ab20e"
      },
      "outputs": [],
      "source": [
        "#Subtraction\n",
        "10 - 8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cd7390da-c225-4555-9966-996604707aec",
      "metadata": {
        "id": "cd7390da-c225-4555-9966-996604707aec"
      },
      "outputs": [],
      "source": [
        "#Multiplication\n",
        "13 * 5.1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "13cd029f-ad35-4832-8fe9-146e04a3ea30",
      "metadata": {
        "id": "13cd029f-ad35-4832-8fe9-146e04a3ea30"
      },
      "outputs": [],
      "source": [
        "#Division\n",
        "print(77 / 10) #Float Division\n",
        "print(77 // 10) #Integer Division"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "60b91c37-bb16-4092-8da6-23aeb7381008",
      "metadata": {
        "id": "60b91c37-bb16-4092-8da6-23aeb7381008"
      },
      "outputs": [],
      "source": [
        "#Exponentiation\n",
        "5**3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1215edd3-8545-464e-bd2d-cac226be91df",
      "metadata": {
        "id": "1215edd3-8545-464e-bd2d-cac226be91df"
      },
      "outputs": [],
      "source": [
        "#Modulus (Remainder of Division)\n",
        "14 % 5"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4fa15e6e-5e22-4f07-98c5-d61f8c287bf3",
      "metadata": {
        "id": "4fa15e6e-5e22-4f07-98c5-d61f8c287bf3"
      },
      "source": [
        "### Variables and DataTypes\n",
        "Numbers (and other types of data) can be stored in user-defined **variables**.\\\n",
        "A vairable is assigned to data using a single equals sign (=)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "053579cb-c94d-4846-9138-f263a735c2c4",
      "metadata": {
        "id": "053579cb-c94d-4846-9138-f263a735c2c4"
      },
      "outputs": [],
      "source": [
        "#Strings\n",
        "my_string = 'A string is a series of characters'\n",
        "print(my_string)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "565d4658-68ae-405b-b8b4-a8a6493c0bab",
      "metadata": {
        "id": "565d4658-68ae-405b-b8b4-a8a6493c0bab"
      },
      "source": [
        "A double equals sign (==) will check if the two sets of data on either side are equal, returning True if they are, and False if they are not.\\\n",
        "The values True and False are called **Booleans**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b177387b-4069-475d-99f5-2eb8103b648f",
      "metadata": {
        "id": "b177387b-4069-475d-99f5-2eb8103b648f"
      },
      "outputs": [],
      "source": [
        "#Booleans (True or False values)\n",
        "my_first_bool = 1 == 2\n",
        "my_second_bool = 1/2 == 0.5\n",
        "print(my_first_bool, my_second_bool)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e7a62031-785c-49be-a9f2-3b4e8374e7be",
      "metadata": {
        "id": "e7a62031-785c-49be-a9f2-3b4e8374e7be"
      },
      "source": [
        "Lists are collections of data, they don't have to be the same type of data!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dcf6e82d-e982-4ea6-a803-cf5ca35ebd75",
      "metadata": {
        "id": "dcf6e82d-e982-4ea6-a803-cf5ca35ebd75"
      },
      "outputs": [],
      "source": [
        "#Lists (A series of data)\n",
        "my_list = [182.25, 18//3, \"A string\", 3/2 == 1.5]\n",
        "my_list_types = [type(element) for element in my_list]\n",
        "print(my_list)\n",
        "print(my_list_types)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5a4be226-15f1-401f-958f-19341d8e91bb",
      "metadata": {
        "id": "5a4be226-15f1-401f-958f-19341d8e91bb"
      },
      "source": [
        "Notice that the different elements of the list (**expressions**) evaluated to their **return value** in the creation of thelist.\\\n",
        "Different elements of the list can be retrieved by a process called **indexing**.\\\n",
        "Indexing is zero-based meaning that the first value in the list is at index 0, the next at index 1, etc.\\\n",
        "Indexes are always **integers**.\\\n",
        "In the cell below, **assign the appropriate index** to the variable *my_index* so that the cell prints the **string**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d8151c8d-0df7-47ae-96b8-b93e10c011a9",
      "metadata": {
        "id": "d8151c8d-0df7-47ae-96b8-b93e10c011a9"
      },
      "outputs": [],
      "source": [
        "my_index = #INSERT INDEX HERE#\n",
        "value = my_list[my_index]\n",
        "print(value)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ccfb0402-fcd8-420d-b32b-7aadd2d5036c",
      "metadata": {
        "id": "ccfb0402-fcd8-420d-b32b-7aadd2d5036c"
      },
      "source": [
        "Indexing can also be done with **negative integers** which count backward from the end of the list.\\\n",
        "Index -1 is the last element of the list, -2 the second to last, etc.\\\n",
        "In the cell below, **assign a negatively valued index** to *my_index* so that the cell prints the **float**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "330f3aeb-6743-4b85-9824-9f298a8a8d31",
      "metadata": {
        "id": "330f3aeb-6743-4b85-9824-9f298a8a8d31"
      },
      "outputs": [],
      "source": [
        "my_index = #INSERT INDEX HERE#\n",
        "value = my_list[my_index]\n",
        "print(value)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "012412f2-b50b-43c7-8b2b-52b2da4cb621",
      "metadata": {
        "id": "012412f2-b50b-43c7-8b2b-52b2da4cb621"
      },
      "source": [
        "### For loops and While loops\n",
        "**Loops** will iterate over a collection of values, such as a list. \\\n",
        "A **For Loop** will iterate a value over a predefined set."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a1db2860-b23d-4da7-b1f7-aa80cec5bab0",
      "metadata": {
        "id": "a1db2860-b23d-4da7-b1f7-aa80cec5bab0"
      },
      "outputs": [],
      "source": [
        "print(my_list)\n",
        "for element in my_list:\n",
        "    print(element)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fa6dd171-67b9-4eee-a63a-42b146fc79aa",
      "metadata": {
        "id": "fa6dd171-67b9-4eee-a63a-42b146fc79aa"
      },
      "source": [
        "In the cell below, write your own **For loop** which iterates over the given list of **integers**. \\\n",
        "Within the loop, square each value, and then print the result."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2777fe7f-d97c-4cf9-83da-b9edea09a610",
      "metadata": {
        "id": "2777fe7f-d97c-4cf9-83da-b9edea09a610"
      },
      "outputs": [],
      "source": [
        "given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "#Write your FOR LOOP here"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f77f102c-be6c-4632-9514-fbc5c51aa3eb",
      "metadata": {
        "id": "f77f102c-be6c-4632-9514-fbc5c51aa3eb"
      },
      "source": [
        "A **While Loop** will continue to interate until the Boolean condition defining the loop evaluates to **False**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "649154ef-3a46-4528-8bcc-efd7339d1d7c",
      "metadata": {
        "id": "649154ef-3a46-4528-8bcc-efd7339d1d7c"
      },
      "outputs": [],
      "source": [
        "i = 1\n",
        "while i <= 10:\n",
        "    print(i)\n",
        "    i = i + 1"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5e0a4933-9769-4645-8ebd-92ad84305981",
      "metadata": {
        "id": "5e0a4933-9769-4645-8ebd-92ad84305981"
      },
      "source": [
        "In the cell below, write your own **While loop**. \\\n",
        "From an an initial value *i*, square the value, print the result, and increase the value of *i* by one. \\\n",
        "Continue to iterate the loop until the squared value of *i* is greater than 50. \\\n",
        "If done correctly, only values below 50 should be printed. \\\n",
        "An initial value of the iterable *i* is provided."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "840ed5eb-1743-412e-8bdf-57c743d44166",
      "metadata": {
        "id": "840ed5eb-1743-412e-8bdf-57c743d44166"
      },
      "outputs": [],
      "source": [
        "i = 0\n",
        "#Write your while loop here"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5ce7b676-4b0a-4448-af1d-15c70b43947c",
      "metadata": {
        "id": "5ce7b676-4b0a-4448-af1d-15c70b43947c"
      },
      "source": [
        "### Functions\n",
        "A **function** is a predifined code that will execute the code within the function. \\\n",
        "A function takes one or more **arguments** and evaluates to it's **return value**. \\\n",
        "Below is an example of a function which takes as input two arguments. \\\n",
        "The function will multiply the first argument by 3, take the square root, and get the modulus against the second argument."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ee0a43e5-1429-4249-bc33-5ba4d4f7368a",
      "metadata": {
        "id": "ee0a43e5-1429-4249-bc33-5ba4d4f7368a"
      },
      "outputs": [],
      "source": [
        "def example_1(foo, bar):\n",
        "    value = foo*3\n",
        "    value = value**(1/2)\n",
        "    value = value % bar\n",
        "    return value"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dc8e9f3b-e273-4413-aa1a-1d209e7e469a",
      "metadata": {
        "id": "dc8e9f3b-e273-4413-aa1a-1d209e7e469a"
      },
      "source": [
        "Notice that the above cell produces no output.  This is because it is the definition of a function, but the function must be **called**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "600e1683-0610-422d-b091-2bc31bd86637",
      "metadata": {
        "id": "600e1683-0610-422d-b091-2bc31bd86637"
      },
      "outputs": [],
      "source": [
        "my_value = example_1(27, 5)\n",
        "print(my_value)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "523ff190-5b8e-4ba8-80b5-c4c9e230d21e",
      "metadata": {
        "id": "523ff190-5b8e-4ba8-80b5-c4c9e230d21e"
      },
      "source": [
        "Use the cell below to **write your own function**, which takes 3 arguments as input.\n",
        "The function should raise the first argument to the power of the second argument, and divide the resulting value by the third argument."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fad783d6-f076-4e11-b7c9-936b7fb67a37",
      "metadata": {
        "id": "fad783d6-f076-4e11-b7c9-936b7fb67a37"
      },
      "outputs": [],
      "source": [
        "#WRITE YOUR FUNCTION HERE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9e19ffa0-30db-4205-87c1-97021a0ab27b",
      "metadata": {
        "id": "9e19ffa0-30db-4205-87c1-97021a0ab27b"
      },
      "outputs": [],
      "source": [
        "#CALL YOUR FUNCTION HERE"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5823ff38-fa1b-4d85-9aa7-83472c6da9be",
      "metadata": {
        "id": "5823ff38-fa1b-4d85-9aa7-83472c6da9be"
      },
      "source": [
        "A **lambda function** is a shorthand function useful for mathematical operations. \\\n",
        "The lambda function below will take two arguments, multiplying the first by two and dividing by the second."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6f7a07ba-b266-489e-8ab7-814a501d6de4",
      "metadata": {
        "id": "6f7a07ba-b266-489e-8ab7-814a501d6de4"
      },
      "outputs": [],
      "source": [
        "lam_fun = lambda x, y , z: (2*x)/y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "25b8f136-e24e-4da6-896d-91989cc2e031",
      "metadata": {
        "id": "25b8f136-e24e-4da6-896d-91989cc2e031"
      },
      "outputs": [],
      "source": [
        "z = lam_fun(15, 3)\n",
        "print(z)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dcbd5884-6e99-468e-b4f0-3998daf57271",
      "metadata": {
        "id": "dcbd5884-6e99-468e-b4f0-3998daf57271"
      },
      "source": [
        "### Packages\n",
        "Python **packages (modules)** are collections of code that have additional functionality.\\\n",
        "The power of python lies in the ability to create, distribute, and **import** modules."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5PczdqsYXWaL",
      "metadata": {
        "id": "5PczdqsYXWaL"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from numpy import real\n",
        "import glob\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3qFD3eETYcL7",
      "metadata": {
        "id": "3qFD3eETYcL7"
      },
      "source": [
        "Some Example Calculations using numpy arrays"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "l7-P1e-2YgJI",
      "metadata": {
        "id": "l7-P1e-2YgJI"
      },
      "outputs": [],
      "source": [
        "a = np.arange(1,9)\n",
        "b = np.arange(15,23)\n",
        "print(a,b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Z2wHak5hYgSZ",
      "metadata": {
        "id": "Z2wHak5hYgSZ"
      },
      "outputs": [],
      "source": [
        "#Vector Operations\n",
        "print(a+b)\n",
        "print(b-a)\n",
        "print(a*b)\n",
        "print(b/a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "slLcej-RYgat",
      "metadata": {
        "id": "slLcej-RYgat"
      },
      "outputs": [],
      "source": [
        "a, b = a.reshape((2,4)), b.reshape((2, 4))\n",
        "print(a)\n",
        "print(b)\n",
        "#Try running the cell above"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "yHByKaonYIda",
      "metadata": {
        "id": "yHByKaonYIda"
      },
      "source": [
        "## Molecular Orbitals Calculation\n",
        "\n",
        "In this laboratory, you will handcraft the Huckel Matrices for Benzene as well as all of the dyes from the conjugated Dyes Lab. \\\\\n",
        "From these Huckel matrices, the Huckel MO energy levels will be calculated, as well the atomic orbitals' coefficeints (contributing to each Huckel MO). \\\\\n",
        "Together, we will work through building this matrix for Benzene, and getting the output.  One of the dyes is constructed already as an example for you to follow while doing the other five. \\\\\n",
        "As a final result for this laboratory, demonstrate the calculation of the Huckel matrices for all dyes, get the Huckel MO levels, report the HOMO-LUMO gap in units of beta as well as in units of wavelength (nm), and calculate the delocalization energy."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def make_H_matrix_for_benzene(a, b):\n",
        "    h_matrix = np.array([[0, 0, 0, 0, 0, 0],\n",
        "                         [0, 0, 0, 0, 0, 0],\n",
        "                         [0, 0, 0, 0, 0, 0],\n",
        "                         [0, 0, 0, 0, 0, 0],\n",
        "                         [0, 0, 0, 0, 0, 0],\n",
        "                         [0, 0, 0, 0, 0, 0]])\n",
        "    return h_matrix\n",
        "\n",
        "def get_eigs(h_matrix):\n",
        "    eig_vals, eig_vecs = np.linalg.eig(h_matrix)\n",
        "    #eig_inv_vecs = np.linalg.inv(eig_vecs)\n",
        "    return eig_vals, eig_vecs"
      ],
      "metadata": {
        "id": "7uy-sR3SjGzT"
      },
      "id": "7uy-sR3SjGzT",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "benzene_h_matrix = make_H_matrix_for_benzene(0, 0)\n",
        "\n",
        "MO_levels, eigen_vectors = get_eigs(benzene_h_matrix)"
      ],
      "metadata": {
        "id": "PyHuHtufjQUL"
      },
      "id": "PyHuHtufjQUL",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(MO_levels)"
      ],
      "metadata": {
        "id": "IasvpJqmjQF2"
      },
      "id": "IasvpJqmjQF2",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(eigen_vectors.shape[0]):\n",
        "  print(f\"The column {i} vector is {eigen_vectors[:, i]}\")"
      ],
      "metadata": {
        "id": "AcsKZ8xqjPqJ"
      },
      "id": "AcsKZ8xqjPqJ",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def make_H_matrix_4_4_4carbo(a, b, c, d):\n",
        "  #                     N  2  3  4  5  6  7  8  9  X   N  2  3  4  5  6  7  8  9  X   A  B  C\n",
        "  h_matrix = np.array([[c, d, 0, 0, 0, 0, 0, 0, 0, d,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#N\n",
        "                       [d, a, b, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#2\n",
        "                       [0, b, a, b, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#3\n",
        "                       [0, 0, b, a, b, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  b, 0, 0],#4\n",
        "                       [0, 0, 0, b, a, b, 0, 0, 0, b,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#5\n",
        "                       [0, 0, 0, 0, b, a, b, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#6\n",
        "                       [0, 0, 0, 0, 0, b, a, b, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#7\n",
        "                       [0, 0, 0, 0, 0, 0, b, a, b, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#8\n",
        "                       [0, 0, 0, 0, 0, 0, 0, b, a, b,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#9\n",
        "                       [d, 0, 0, 0, b, 0, 0, 0, b, a,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#X\n",
        "\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  c, d, 0, 0, 0, 0, 0, 0, 0, d,  0, 0, 0],#N\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  d, a, b, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0],#2\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, b, a, b, 0, 0, 0, 0, 0, 0,  0, 0, 0],#3\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, b, a, b, 0, 0, 0, 0, 0,  0, 0, b],#4\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, b, a, b, 0, 0, 0, b,  0, 0, 0],#5\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, b, a, b, 0, 0, 0,  0, 0, 0],#6\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, b, a, b, 0, 0,  0, 0, 0],#7\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, b, a, b, 0,  0, 0, 0],#8\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, b, a, b,  0, 0, 0],#9\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  d, 0, 0, 0, b, 0, 0, 0, b, a,  0, 0, 0],#X\n",
        "\n",
        "                       [0, 0, 0, b, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  a, b, 0],#A\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  b, a, b],#B\n",
        "                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, b, 0, 0, 0, 0, 0, 0,  0, b, a]])#C\n",
        "  return h_matrix\n",
        "\n"
      ],
      "metadata": {
        "id": "ABx3xxoD5VBT"
      },
      "id": "ABx3xxoD5VBT",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "four_four_carbo_H_matrix = make_H_matrix_4_4_4carbo(0,#alpha param for C\n",
        "                                                   -1, #beta param for C-c\n",
        "                                                   -0.5, #alpha param for N\n",
        "                                                   -0.8)  # beta param for C-N\n",
        "MO_levels, eigen_vectors = get_eigs(four_four_carbo_H_matrix)"
      ],
      "metadata": {
        "id": "ij7BmkSAAPHS"
      },
      "id": "ij7BmkSAAPHS",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.around(MO_levels, decimals=2)"
      ],
      "metadata": {
        "id": "xqcRy81LFNZt"
      },
      "id": "xqcRy81LFNZt",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(eigen_vectors.shape[0]):\n",
        "  print(f\"The column {i} vector is {np.around(eigen_vectors[:, i], decimals=2)}\")"
      ],
      "metadata": {
        "id": "mhV3mwJL5T5E"
      },
      "id": "mhV3mwJL5T5E",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Below this text, as needed, add additional code cells to complete the assignment.  In this text cell, fill in the blank values below for the HOMO-LUMO Gaps and Delocalization Energies:\n",
        "\n",
        "1-1'-diethyl-2-2'-cyanine: \\\\\n",
        "HOMO-LUMO = \\\\\n",
        "Delocalization Energy = \\\\\n",
        "\n",
        "1-1'-diethyl-2-2'-carbocyanine: \\\\\n",
        "HOMO-LUMO = \\\\\n",
        "Delocalization Energy = \\\\\n",
        "\n",
        "1-1'-diethyl-2-2'-dicarbocyanine: \\\\\n",
        "HOMO-LUMO = \\\\\n",
        "Delocalization Energy = \\\\\n",
        "\n",
        "1-1'-diethyl-4-4'-cyanine: \\\\\n",
        "HOMO-LUMO = \\\\\n",
        "Delocalization Energy = \\\\\n",
        "\n",
        "1-1'-diethyl-4-4'-carbocyanine: \\\\\n",
        "HOMO-LUMO = \\\\\n",
        "Delocalization Energy = \\\\\n",
        "\n",
        "1-1'-diethyl-4-4'-dicarbocyanine: \\\\\n",
        "HOMO-LUMO = \\\\\n",
        "Delocalization Energy = \\\\\n",
        "\n"
      ],
      "metadata": {
        "id": "QiHdtdtVnaJs"
      },
      "id": "QiHdtdtVnaJs"
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "JFhUl9ybni3H"
      },
      "id": "JFhUl9ybni3H",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ey-585UWoL5s"
      },
      "id": "ey-585UWoL5s",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "MdBqnJSnoL2_"
      },
      "id": "MdBqnJSnoL2_",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "VU0A8K3VoL0V"
      },
      "id": "VU0A8K3VoL0V",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ymtSthyioLx5"
      },
      "id": "ymtSthyioLx5",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8bJVm6xLoLvS"
      },
      "id": "8bJVm6xLoLvS",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_ujH2QQCoLsF"
      },
      "id": "_ujH2QQCoLsF",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "FBVMPNlcoLaq"
      },
      "id": "FBVMPNlcoLaq",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "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.11.8"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}