intro_lecture1_2020.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "lecture1_2020.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "MMwm5ll5gjnz"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tAnH-xLbzlL0",
        "colab_type": "text"
      },
      "source": [
        "# Lecture 1: Introduction to Python 3.6 and Jupyter Notebook\n",
        "By Dr. Anders S. Christensen\n",
        "`anders.christensen @ unibas.ch`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hw7K3QNieVn_",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "Today we go through the basics of Python3 and also how to use Jupyter Notebooks (via Google Colab).\n",
        "\n",
        "Try to run the code block below by clicking the play-button (or pressing Ctrl+Enter).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R0LzmafTC4UD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"Hello Python!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OE3QvFVu5SzD",
        "colab_type": "text"
      },
      "source": [
        "## Section 1.1: Basic math operations\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bFuD0dox5sCX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(7 + 17)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1u_i9Y5PAOiS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(7 * 17)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1mgTFnPyAOlT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(7 - 17)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gNn2wX9yAOnZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(7 / 17)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5rkNVq4AcgA5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(7**17)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CPlc2luzCkef",
        "colab_type": "text"
      },
      "source": [
        "### Exercise 1.1.1: Write your own example here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vYRUYLMsCkj-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AiOavTcbAbta",
        "colab_type": "text"
      },
      "source": [
        "## Section 1.2: Variables and naming"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LDnVX9NW6f8J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 7\n",
        "y = 17.0\n",
        "\n",
        "z = x * y\n",
        "\n",
        "print(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r17EUknKBX6Q",
        "colab_type": "text"
      },
      "source": [
        "Strings can also be variables:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7yyBrO2EBYBZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "greeting = \"Hello World!\"\n",
        "\n",
        "print(greeting)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MRWVLSwipS2P",
        "colab_type": "text"
      },
      "source": [
        "Different data types?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XMdZDM50pS9o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 1\n",
        "print(type(x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3hCR17ITphQz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = 5.0\n",
        "print(type(y))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7w0tx7dHphXl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "w = x * y\n",
        "print(type(w))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "4yQS6IEcpr4t"
      },
      "source": [
        "Some variables don't mix:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZSbEvjGqBk54",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = \"Hello\"\n",
        "y = 42\n",
        "\n",
        "z = x + y\n",
        "\n",
        "print(\"z is\", z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "swmGKFmnXSRy"
      },
      "source": [
        "Variable names can be really long! Normally we use lower-case and _ in our variables in Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "qjLX28H3XMJV",
        "colab": {}
      },
      "source": [
        "lecturer_name = \"Anders Christensen\"\n",
        "students_asleep = 0\n",
        "days_until_xmas = 200.5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XHhFCWqLWwli",
        "colab_type": "text"
      },
      "source": [
        "Some examples of legal and illegal names:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cMi3Ni6EWwEe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Legal variable names:\n",
        "myvar = \"John\"\n",
        "my_var = \"John\"\n",
        "_my_var = \"John\"\n",
        "myVar = \"John\"\n",
        "MYVAR = \"John\"\n",
        "myvar2 = \"John\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o8pHXyc25ihk",
        "colab_type": "text"
      },
      "source": [
        "### Exercise 1.2.1:\n",
        "The following will not work. Lets fix them!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "byK_-rHcW1Mb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Illegal variable names:\n",
        "myvar2 = \"John\"\n",
        "my-var = \"John\"\n",
        "my var = \"John\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9DQmEyh-5zx4",
        "colab_type": "text"
      },
      "source": [
        "## Section 1.3: ```for```-loops\n",
        "\n",
        "We have seen how to write variables and do simple calculations, but often we want to do more than just *one* thing!\n",
        "\n",
        "In order to do a series of things, we can use the so-called `for`-loop, which is often invoked using the `range()` funtions.\n",
        "\n",
        "`range(n)` will give you all the numbers from $0$ to $n-1$ \n",
        "\n",
        "(Because Python counting starts from $0$)\n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g6YNMPZ5GuuE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Print all numbers from 0 to 19\n",
        "for i in range(20):\n",
        "  print(i)\n",
        "\n",
        "print(\"Does this get repeated?\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lfxNsAxRGz0l",
        "colab_type": "text"
      },
      "source": [
        "Note how everything that is indented gets repeated by the `for` loop!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J0UpICMielmh",
        "colab_type": "text"
      },
      "source": [
        "**Question:** What is `range()`??"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7UxIlyr7eltT",
        "colab_type": "code",
        "outputId": "32c74bd3-d6ce-47ad-82ff-a62d05080de8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Convert the range to a list\n",
        "print( list(range(10)) )"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tb1GTuwVUzDV",
        "colab_type": "text"
      },
      "source": [
        "Note how `range()` \"skips\" the final number!\n",
        "\n",
        "---\n",
        "\n",
        "Normally `range()` starts from 0, but you can start from any number, by using *two* arguments, for example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NP-q8Ly4UzRp",
        "colab_type": "code",
        "outputId": "878db0d1-6055-49b8-a434-0d5898a800eb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Print from 10 to 19\n",
        "print( list(range(10, 20)) )"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EAarWG4fG7_j",
        "colab_type": "text"
      },
      "source": [
        "We can for example use the loop to calculate a sum:\n",
        "\\begin{equation}\n",
        "k = \\sum_{n=0}^{19} i\n",
        "\\end{equation}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KDvx8vSI9oG4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "k = 0\n",
        "for i in range(20):\n",
        "  # print(i)\n",
        "  k = k + i\n",
        "\n",
        "print(\"k is\", k)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "3SNQQp2r781L"
      },
      "source": [
        "### Section 1.4: Lists \n",
        "A fundamental data structure of Python is so-called \"lists\". A list contains a list of items, for example numbers. \n",
        "\n",
        "An example of a list with 7 items is given below:\n",
        "\n",
        "\\begin{array}{lrrrrrrr}\n",
        "\\texttt{i}  & 0  & 1 & 2 & 3 & 4 & 5 & 6 \\\\ \\hline\n",
        "\\texttt{my_list} & 3.5 & 2.1 & -2.5 & 1.2 & 6.2 & 5.2 & -8.1\n",
        "\\end{array}\n",
        "\n",
        "In Python this would be:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "j2iCa0a0781a",
        "colab": {}
      },
      "source": [
        " my_list = [3.5, 2.1, -2.5, 1.2, 6.2, 5.2, -8.1]\n",
        " print(my_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Il_-Cxh57811"
      },
      "source": [
        "Note: The first item in the list has index $0$, and the last has index $n-1$. You count starting from 0, and NOT 1! \n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "tFZtGKVd7812",
        "colab": {}
      },
      "source": [
        "# The first item in the list\n",
        "print(my_list[0])\n",
        "\n",
        "# The \"third\" item in the list\n",
        "print(my_list[2])\n",
        "\n",
        "# The last item in the list\n",
        "print(my_list[6])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I7s0bGIUPzW_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# List contatining some numbers\n",
        "some_numbers = [5, 10, 15, 20, 25, 30]\n",
        "\n",
        "# print length of that list\n",
        "print(len(some_numbers))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "khyp2t5_QrXa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 1: Print some_numbers\n",
        "for i in range(len(some_numbers)):\n",
        "  print(some_numbers[i])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Py9VC5TcQrJM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 2: Print some_numbers\n",
        "for n in some_numbers:\n",
        "  print(n)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "IJNMfSrgFynu"
      },
      "source": [
        "### Debugging Exercise 1.4.1: What happens if you ask for something that isn't there?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "EGlhyFwsFyn0",
        "colab": {}
      },
      "source": [
        "my_list = [3.5, 2.1, -2.5, 1.2, 6.2, 5.2, -8.1]\n",
        "\n",
        "# Only up to 6 allowed!\n",
        "print(my_list[7])\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bF5PkliD8AOc",
        "colab_type": "text"
      },
      "source": [
        "### Section 1.5: Sum over items in list:\n",
        "\n",
        "This is an example of summation:\n",
        "\n",
        "\\begin{equation}\n",
        "y = \\sum_{i=0}^n x_i\n",
        "\\end{equation}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X0tMAp908AUm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_sum = 0\n",
        "\n",
        "for i in range(7):\n",
        "\n",
        "  print(i, my_list[i])\n",
        "  my_sum = my_sum + my_list[i]\n",
        "\n",
        "print(\"my_sum is\", my_sum)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "44PCWiHuSwwX",
        "colab_type": "text"
      },
      "source": [
        "## Coding Example: The Quantum Harmonic Oscillator\n",
        "\n",
        "The behavior of a di-atomic molecule can be approximated by a quantum harmonic oscillator.\n",
        "\n",
        "In this example we calculate the internal energy, $U$, and the heat capacity $C_v$ of a quantum harmonic oscillator.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wQPd6Qp29t_q",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://ars.els-cdn.com/content/image/3-s2.0-B9780125031639500114-f10-04-9780125031639.gif?_)\n",
        "\n",
        "\n",
        "The energy $\\epsilon_n$ for a state of the harmonic oscillator is given by\n",
        "\\begin{equation}\n",
        "\\epsilon_n = n+\\frac{1}{2},\n",
        "\\end{equation}\n",
        "in units of $\\hbar\\omega$. We also assume that there are no degenerate states!\n",
        "\n",
        "The probability for observing the state $n$ at a given temperature $\\tau$ is given by:\n",
        "\\begin{equation}\n",
        "p(n) = \\frac{\\exp{\\left(-\\epsilon_n / \\tau \\right)}}{Z},\n",
        "\\end{equation}\n",
        "\n",
        "where $Z$ is the partition function (*Zustandssumme*)\n",
        "\\begin{equation}\n",
        "Z = \\sum_{n=0}^{\\infty} \\exp{\\left(-\\epsilon_n / \\tau\\right)}.\n",
        "\\end{equation}\n",
        "\n",
        "The total *internal* energy $U$ is then given by:\n",
        "\\begin{equation}\n",
        "U = \\langle \\epsilon \\rangle = \\sum_n \\epsilon_n p(n)\n",
        "\\end{equation}\n",
        "\n",
        "---\n",
        "\n",
        "Another interesting property of this system is the *heat capactity* $C_V$ given by\n",
        "\\begin{align}\n",
        "C_V &= \\frac{\\partial U}{\\partial \\tau} \\biggl|_V \\\\\n",
        "&= \\frac{\\langle \\epsilon^2 \\rangle - \\langle \\epsilon \\rangle^2}{\\tau^2}.\n",
        "\\end{align}\n",
        "\n",
        "\n",
        "The expectation value $\\langle \\epsilon \\rangle$ is given via the energy $U$:\n",
        "\\begin{align}\n",
        "\\langle \\epsilon \\rangle &= \\sum_n \\epsilon_n p(n) \\\\\n",
        "&= \\sum_n \\left(n+\\frac{1}{2}\\right) p(n)\n",
        "\\end{align}\n",
        "\n",
        "And $\\langle \\epsilon^2 \\rangle$ is the second moment of the energy given by:\n",
        "\\begin{align}\n",
        "\\langle \\epsilon^2 \\rangle &= \\sum_n \\epsilon^2_n p(n) \\\\\n",
        "&= \\sum_n \\left(n+\\frac{1}{2}\\right)^2 p(n)\n",
        "\\end{align}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlSV9P976OB3",
        "colab_type": "text"
      },
      "source": [
        "### Example 1: Print the energy $\\epsilon_n$ for each state up to $n=3$?\n",
        "\n",
        "The energy $\\epsilon_n$ for a state of the harmonic oscillator is given by:\n",
        "\\begin{equation}\n",
        "\\epsilon_n = n+\\frac{1}{2}\n",
        "\\end{equation}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UDp6eRJlM3tM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for n in range(3+1):\n",
        "\n",
        "  epsilon = n + 0.5\n",
        "\n",
        "  print(n, epsilon)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "20FBPuBZNgVr",
        "colab_type": "text"
      },
      "source": [
        "#### Example 2: What is the partition function $Z$ \n",
        "\n",
        "for $\\tau$ = 2.0?\n",
        "\n",
        "Recall that the partition function is given by:\n",
        "\n",
        "\\begin{equation}\n",
        "Z = \\sum_{n=0}^{\\infty} \\exp{\\left(-\\frac{\\left(n+\\frac{1}{2}\\right)}{\\tau}\\right)}\n",
        "\\end{equation}\n",
        "\n",
        "\n",
        "Before we start, we have to import the function to evaluate the exponential function from a package called NumPy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hwZnLDs-Jt3v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Import functionality for exponential function: np.exp()\n",
        "import numpy as np\n",
        "\n",
        "# np.exp() = \"e^x\"\n",
        "\n",
        "print(np.exp(0.0))\n",
        "print(np.exp(1.0))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D5_s6msdQznZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tau = 2.0\n",
        "n_states = 10000\n",
        "\n",
        "Z = 0.0\n",
        "\n",
        "for n in range(n_states+1):\n",
        "  \n",
        "  Z = Z + np.exp(-(n + 0.5) / tau)\n",
        "\n",
        "print(Z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sy2r64p6QCRG",
        "colab_type": "text"
      },
      "source": [
        "#### Example 3: What is the internal energy $U$ for $\\tau$ = 2.0?\n",
        "\n",
        "\\begin{equation}\n",
        "U = \\langle \\epsilon \\rangle = \\sum_n \\epsilon_n p(n)\n",
        "\\end{equation}\n",
        "\n",
        "Also recall that:\n",
        "\n",
        "\\begin{equation}\n",
        "p(n) = \\frac{\\exp{\\left(-\\epsilon_n / \\tau \\right)}}{Z},\n",
        "\\end{equation}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKJIJlQpgjPo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "U = 0\n",
        "\n",
        "for n in range(n_states+1):\n",
        "  \n",
        "  epsilon = n + 0.5\n",
        "  prob = np.exp(-epsilon/tau) / Z\n",
        "  \n",
        "  U = U + epsilon * prob\n",
        "  \n",
        "  # print(n, epsilon, prob)\n",
        "\n",
        "print(\"Internal energy:\", U)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ipBUxMBuXhE0",
        "colab_type": "text"
      },
      "source": [
        "#### Example 4: Second moment of the energy and the heat capacity\n",
        "\n",
        "\n",
        "What is the heat capacity $C_V$ for $\\tau = 2.0$?\n",
        "\\begin{equation}\n",
        "C_V = \\frac{\\langle \\epsilon^2 \\rangle - \\langle \\epsilon \\rangle^2}{\\tau^2}.\n",
        "\\end{equation}\n",
        "\n",
        "With the second moment of the energy:\n",
        "\\begin{equation}\n",
        "\\langle \\epsilon^2 \\rangle = \\sum_n \\left(n+\\frac{1}{2}\\right)^2 p(n)\n",
        "\\end{equation}\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5FLw6PigXhWi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Second moment of the energy:\n",
        "\n",
        "U2 = 0\n",
        "\n",
        "for n in range(n_states+1):\n",
        "  \n",
        "  epsilon = n + 0.5\n",
        "  prob = np.exp(-epsilon/tau) / Z\n",
        "  \n",
        "  U2 = U2 + epsilon**2 * prob\n",
        "  \n",
        "  # print(n, epsilon, prob)\n",
        "\n",
        "print(\"Second moment of the energy:\", U2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qFObIeRrYv-L",
        "colab_type": "text"
      },
      "source": [
        "Finally, the heat capacity is:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JLr77VjrYwMc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "Cv = (U2 - U**2) / tau**2\n",
        "\n",
        "print(\"Heat capacity:\", Cv)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MMwm5ll5gjnz",
        "colab_type": "text"
      },
      "source": [
        "## Extra: Calculating $C_V$ as a function of $\\tau$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zpo7zdwMgj-d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 7 temperatures\n",
        "temperatures = [0.1, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]\n",
        "n_states = 10\n",
        "\n",
        "for tau in temperatures:\n",
        "\n",
        "  # Calculate the partition function for tau\n",
        "  Z = 0.0\n",
        "  for n in range(n_states+1):\n",
        "    Z = Z + np.exp(-(n + 0.5) / tau)\n",
        "\n",
        "  # First moment of the energy\n",
        "  U = 0.0\n",
        "\n",
        "  # Second moment of the energy\n",
        "  U2 = 0.0\n",
        "\n",
        "  for n in range(n_states+1):\n",
        "  \n",
        "    epsilon = n + 0.5\n",
        "    prob = np.exp(-epsilon/tau) / Z\n",
        "  \n",
        "    U = U + epsilon * prob\n",
        "    U2 = U2 + epsilon**2 * prob\n",
        "  \n",
        "  Cv = (U2 - U**2) / tau\n",
        "\n",
        "  print(tau, Cv)"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}