From 5d0e83a53738dd7b9ad74c181f4c68c7be938dab Mon Sep 17 00:00:00 2001 From: Kees van Kempen Date: Fri, 18 Mar 2022 10:38:08 +0100 Subject: [PATCH] Final: fetch final assignment --- ...l - Tight-binding propagation method.ipynb | 1365 +++++++++++++++++ 1 file changed, 1365 insertions(+) create mode 100644 Final/Final - Tight-binding propagation method.ipynb diff --git a/Final/Final - Tight-binding propagation method.ipynb b/Final/Final - Tight-binding propagation method.ipynb new file mode 100644 index 0000000..76a402b --- /dev/null +++ b/Final/Final - Tight-binding propagation method.ipynb @@ -0,0 +1,1365 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "ad6b13cb01007316fa509551e4c8b998", + "grade": false, + "grade_id": "cell-98f724ece1aacb67", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "# CDS: Numerical Methods -- Final Assignment\n", + "\n", + "- See lecture notes and documentation on Brightspace for Python and Jupyter basics. If you are stuck, try to google or get in touch via Discord.\n", + "\n", + "- Solutions must be submitted **individually** via the Jupyter Hub until **Monday, April 4th, 23:59**.\n", + "\n", + "- Make sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\".\n", + "\n", + "- Remember to document your source codes (docstrings, comments where necessary) and to write it as clear as possible.\n", + "\n", + "- Do not forget to fully annotate all of your plots.\n", + "\n", + "## Submission\n", + "\n", + "1. make sure everything runs as expected\n", + "2. **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart)\n", + "3. **run all cells** (in the menubar, select Cell$\\rightarrow$Run All)\n", + "4. Check all outputs (Out[\\*]) for errors and **resolve them if necessary**\n", + "5. submit your solutions **in time (before the deadline)**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "23a115c4a147aab2185c76637a509f7f", + "grade": false, + "grade_id": "cell-fd297f265de59887", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Tight-Binding Propagation Method Module\n", + "\n", + "### Tight-Binding Theory\n", + "\n", + "Solid state theory aims to describe crystalline structures defined by periodic arrangements of atomic positions $\\vec{R}_i$ with $i= 1 \\dots n$. To model the electronic properties of such a structure, we can use the so-called tight-binding method. Here one assumes that the problem for a single atom described by the Hamiltonian $H_{at}(\\vec{r})$ has already been solved, so that the atomic wave functions $\\phi_m(\\vec{r})$ are known. The Hamiltonian of the crystalline structure is then constructed from these atomic Hamiltonians as follows \n", + "\n", + "\\begin{align*}\n", + " H(\\vec{r}) = \\sum_{i} H_{at}(\\vec{r} - \\vec{R}_i) + \\Delta V(\\vec{r}),\n", + "\\end{align*}\n", + "\n", + "where $\\Delta V(\\vec{r})$ describes the changes to the atomic potentials due to the periodic arrangement. Solutions to the time-dependent Schrödinger equation $\\psi_n(\\vec{r})$ can then be approximated by linear combinations of the atomic orbitals, i.e. \n", + "\n", + "\\begin{align*}\n", + " \\psi_m(\\vec{r}) = \\sum_{i} \\, c_{i,m} \\, \\phi_m(\\vec{r}-\\vec{R}_i). \n", + "\\end{align*}\n", + "\n", + "Thus, our task is to find the coefficients $c_{i,m}$, which are the eigenfunctions of the tight-binding Hamiltonian $H_{tb}$. In the basis of the atomic orbitals $H_{tb}$ is an $n \\times n$ matrix which describes the \"hopping\" of an electron from one atomic position to the other. In this description the electrons are assumed to be tightly bound to the atomic positions, hence the name of the approach. In summary, we have reduced our original problem $H(\\vec{r})$, described in a continuous space $\\vec{r}$, to a strongly discretized problem $H_{tb}$ in the space of lattice coordinates $\\vec{R}_i$.\n", + "\n", + "### Propagation Method\n", + "\t\n", + "While this reduction already helps a lot, full diagonalizations of the tight-binding matrix is still not feasible if we need to describe realistic structures with thousands of atoms. For this case we like to have a method which allows us to study the electronic properties, without the need of fully diagonalizing the tight-binding matrix. The tight-biding propagation method allows for exactly this. By analyzing the propagation of an initial electronic state through the crystalline structure we also have access to the full eigenspectrum of $H_{tb}$, without explicit diagonalization.\n", + "\t\n", + "### Your Goal\n", + " \n", + "In the following you will setup the tight-binding Hamiltonian for a one-dimensional chain of atoms and numerically study its properties using exact diagonalization. Then you will compare it to the results obtained using the tight-binding propagation method. You will need some of the algorithms which you have implemented in the weekly assignments before. Additionally, you will need to implement a few new algorithms, which we have discussed in the last lecture. In principle there will be no need to use Numpy or Scipy (except for Numpy's array handling and a few other exceptions). However, if you encounter any problems with your own implementations of specific functionalities, you can use the Numpy and Scipy alternatives. Therefore you should be able to perform all of the following tasks in any case.\n", + "\n", + "Let us start by importing the necessary packages." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "5d73a1e28cac71eb63db02e72960f030", + "grade": true, + "grade_id": "cell-9a7b93b917f8bfed", + "locked": false, + "points": 0, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# Import packages here ...\n", + "\n", + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "46edf5bfda2392bd3743329097a4e7ae", + "grade": false, + "grade_id": "cell-0f4a00fe587d193a", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Step 1: Crystal Lattice\n", + "\n", + "### Task 1.1 [3 points]\n", + "\n", + "In the following exercises the atomic positions of the 1D crystal lattice will be fixed to $\\vec{R}_i = x_i = i a$, with $i = 0 \\dots n-1$ and $a$ being the lattice constant.\n", + "\n", + "Write a simple Python function that takes the chain length $n$ as an argument and returns the atomic positions $x_i$. Set $a = 1$ for all the following exercises." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "bad6e1d563be71de711926b41649c875", + "grade": true, + "grade_id": "cell-65a97e8f9f981da1", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def atomic_positions(n):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "684ad7f7808a1d5b4360a0acb4e52921", + "grade": false, + "grade_id": "cell-a61043ba1148856d", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Step 2: Atomic Basis Functions\n", + "\n", + "Our atomic basis functions will be Gaussians of the form\n", + "$$\n", + "\\large\n", + "\\phi(x, \\mu, \\sigma) = \\frac{1}{\\pi^{1/4} \\sigma^{1/2}} e^{-\\frac{1}{2} \\left(\\frac{x-\\mu}{\\sigma}\\right)^2},\n", + "$$\n", + "\twhere $\\mu$ is their localization position and $\\sigma$ their broadenings. We also choose to have just one orbital per atom so that we can drop the index $m$ from now on. \n", + "\t\n", + "### Task 2.1 [4 points]\n", + "Implement a Python function which calculates $\\phi(x, \\mu, \\sigma)$ for a whole array of arbitrary $x$, centered at given $\\mu$ with a given broadening $\\sigma$.\n", + "\n", + "Plot all the atomic basis functions for a chain with $n = 10$ atoms, using $\\sigma = 0.25$. I.e. plot $\\phi(x, x_i, \\sigma)$ vs $x$, for all atomic positions $x_i$ in the chain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "2ad9cc4c03612d5b9bba4824cff364cb", + "grade": true, + "grade_id": "cell-4689e172e70a4762", + "locked": false, + "points": 4, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def atomic_basis(x, mu, sigma):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "e1c7774260f02916e34521c6236638f4", + "grade": false, + "grade_id": "cell-e5c9315357a401f9", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 2.2 [6 points]\n", + "Implement a Python function to calculate numerical integrals (using for example the composite trapezoid or Simpson rule). This one should be general enough to calculate integrals $\\int_a^b f(x) dx$ for arbitrary functions $f(x)$, as you will need it for other tasks as well.\n", + "\n", + "Implement a simple unit test for your integration function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "aecc6d50a1ffd4e4bfbfe3573847edf8", + "grade": true, + "grade_id": "cell-d851197b213e5d2d", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def integrate(yk, x):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "6ab06c87cf65c73463ed243e46d63b3d", + "grade": true, + "grade_id": "cell-59912b2862fbce5a", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def test_integrate():\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()\n", + " \n", + "test_integrate()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "8c1413a8a11006398e962e8c803ae001", + "grade": false, + "grade_id": "cell-86005829da536b5b", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 2.3 [2 points]\n", + "Use your Python integration function to check the orthogonality of the Gaussian basis functions by verifying the following condition $$\\delta_{ij} = \\int_{-\\infty}^{+\\infty} \\phi(x, x_i, \\sigma) \\, \\phi(x, x_j, \\sigma) \\, dx,$$ where $\\delta_{ii} \\approx 1$ and $\\delta_{ij} \\approx 0$ for $\\sigma = 0.25$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "4751becb5d3cb7663536a0624b3d9c54", + "grade": true, + "grade_id": "cell-8a6a8db84dcef484", + "locked": false, + "points": 2, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "e9ccbed5ba3e6b844bcc6e326053d8da", + "grade": false, + "grade_id": "cell-3cba7034f4eac62f", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Step 3: Tight-Binding Hamiltonian\n", + "\n", + "The tight-binding Hamiltonian for our 1D chain should describe the hopping of an electron from all atomic positions to their nearest left and right neighbours (i.e. no long-range hopping). The resulting matrix representation in the basis of the discrete $x_i$ positions is therefore given as a tri-diagonal $n \\times n$ matrix of the form\n", + "\n", + "\\begin{align}\n", + " \\mathbf{H}_{tb} =\n", + " \\left( \\begin{array}{cccc}\n", + " 0 & t & & 0\\\\\n", + " t & \\ddots & \\ddots & \\\\\n", + " & \\ddots & \\ddots & t \\\\\n", + " 0 & & t & 0\n", + " \\end{array} \\right),\n", + "\\end{align}\n", + "\n", + "where $t = t_{i,i\\pm1}$ is the nearest-neighbour hopping matrix element. A hopping matrix element $t_{i,j}$ is a measure for the probability of an electron to hop from site $i$ to site $j$. They are defined as\n", + "\n", + "\\begin{align}\n", + " t_{i,j} = \\int_{-\\infty}^{+\\infty} \\phi(x, x_i, \\sigma) \\, \\Delta V(x) \\, \\phi(x, x_j, \\sigma) \\, dx,\n", + "\\end{align}\n", + "\n", + "with the potential fixed to\n", + "\n", + "\\begin{align}\n", + " \\Delta V(x) = \\sum_i \\frac{-1}{|x - x_i| + 0.001}.\n", + "\\end{align}\n", + "\n", + "### Task 3.1 [3 points]\n", + "Write a Python function to calculate $t_{i,j}$, using $\\sigma = 0.25$. The function should have as input the indices $i$ and $j$, and the chain length $n$. Verify that the long-range hoppings $t_{i,i\\pm2}$ and $t_{i,i\\pm3}$ are negligible compared to $t_{i,i\\pm1}$.\n", + "\n", + "Hint: use your integration function from task 2.2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "260ae3c806429aee5900599c01cb65c6", + "grade": true, + "grade_id": "cell-0abfcd1aa9fad2fa", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def hopping(i, j, n):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "b1a56ecde33e723ff450defcf5dc2e74", + "grade": true, + "grade_id": "cell-ea36ee5a2b35154c", + "locked": false, + "points": 0, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# Verify that long-range hoppings are negligible here ...\n", + "\n", + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "7d2c8f74993fe38c2c979376961f869a", + "grade": false, + "grade_id": "cell-8a0f18c44306ae00", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 3.2 [3 points]\n", + "Implement a diagonalization routine for tri-diagonal matrices which returns all eigenvalues, for example using the $QR$ decomposition (it is fine to use Numpy's $\\text{qr()}$). \n", + "\n", + "Hint: For tri-diagonal matrices with vanishing diagonal elements, the $QR$-decomposition-based diagonalization algorithm gets trapped. To get around this you could, for example, add a diagonal $1$ to your matrix, and later subtract $1$ from each eigenvalue." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "c20cbcce0a7df50b6ae7b90c7aa35721", + "grade": true, + "grade_id": "cell-9d4942b717eadeb2", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "19976946c5746804cb08c34f0bda50fc", + "grade": false, + "grade_id": "cell-2d8fb5c080951dd5", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 3.3 [3 points]\n", + "Implement a unit test for your diagonalization routine." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "d95777361c07514a97ff1458f26f4f44", + "grade": true, + "grade_id": "cell-001cb3c043c4e371", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "83df149b46d779a846f9de925342b681", + "grade": false, + "grade_id": "cell-85c89b0eb0930f2b", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 3.4 [4 points]\n", + "First, write a function that generates your tight-binding Hamiltonian $\\mathbf{H}_{tb}$, for a given chain length $n$. Use $t = t_{i,i\\pm1}$, as calculated in task 3.1. You can choose any $i$ near the center of the chain for the calculation of $t$, as the chain is (approximately) periodic.\n", + "\n", + "Second, use your diagonalization routine to calculate all the eigenvalues $E_m$, for a variety of $n=10,20,40,80,100$. Sort the resulting $E_m$ and plot them vs. $m$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "a0779b496fd41a4664bb0cdd857c70fc", + "grade": true, + "grade_id": "cell-764cb41c37700042", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def TBHamiltonian(n):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "634e139137eead8808d1d8ccb793d5a5", + "grade": true, + "grade_id": "cell-39ada0528e69d2e5", + "locked": false, + "points": 1, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# Do your plotting here ...\n", + "\n", + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "c2b46d2fef4b0c243103a5a6f1111e2d", + "grade": false, + "grade_id": "cell-b7c84b8c4ed4c1be", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 3.5 [3 points]\n", + "Implement a function to calculate the so-called density-of-states \n", + "\n", + "\\begin{align*}\n", + " \\rho(\\omega) = \\frac{1}{N} \\sum_i \\delta(\\omega - E_i),\n", + "\\end{align*}\n", + "\n", + "for a variable energy grid $\\omega$. Do this by approximating the $\\delta$-distribution with a Gaussian. In detail, you can use your atomic orbital function $\\delta(\\omega - E_i) \\approx \\phi(\\omega, E_i, \\sigma_\\rho)$. Calculate the normalization factor $N$ such that $\\int \\rho(\\omega) dw = 1$ is fulfilled.\n", + "\n", + "Your function should take as input the energy grid $\\omega$, the eigenenergies $E_i$ and the broadening $\\sigma_\\rho$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "ca46cf0b09305fafb522fc0395d1e495", + "grade": true, + "grade_id": "cell-d7c225b7687b5a9c", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def getDOS_ED(w, Ei, sigma):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "attachments": { + "dosN010.png": { + "image/png": "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" + }, + "dosN100.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "b2049bb4d5fb56c59e7d0e742a91d3c8", + "grade": false, + "grade_id": "cell-7560c4658b1da5d3", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 3.6 [3 points]\n", + "Use your density-of-states routine to calculate $\\rho(\\omega)$ for $n=10,20,40,80,100$ for $\\sigma_\\rho \\approx 0.005$. See below for two examples with $t \\approx -0.195$ and $n=10$ and $n=100$.\n", + "\n", + "Hint: if your plots look like they are smoothed out, try decreasing $\\sigma_\\rho$. If they look like there is a lot of noise, try increasing $\\sigma_\\rho$.\n", + "\n", + "$n = 10$ | $n = 100$\n", + ":-: | :-:\n", + "![dosN010.png](attachment:dosN010.png) | ![dosN100.png](attachment:dosN100.png)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "10cb847540f9e1998c9c1b40c5e43a7b", + "grade": true, + "grade_id": "cell-c3083a03553a2aa9", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "69c457b9ef8fbd13ad935fe12c37c81c", + "grade": false, + "grade_id": "cell-362439917c95705f", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Step 4: Tight-Binding Propagation Method\n", + "\n", + "Now we turn to the time-dependent Schrödinger equation\n", + "\n", + "\\begin{align}\n", + " i\\hbar\\frac{\\partial}{\\partial t} \\psi(x,t) = H \\psi(x,t),\n", + "\\end{align}\n", + "\n", + "which has the formal solution\n", + "\n", + "\\begin{align}\n", + " \\psi(x,t) = U(t) \\psi(x,t=0),\n", + "\\end{align}\n", + "\n", + "with \n", + "\n", + "\\begin{align}\n", + " U(t) = e^{-i \\hbar H t}\n", + "\\end{align}\n", + "\n", + "being the time-propagation operator. Within the propagation method we can calculate the so-called local density-of-states\n", + "\n", + "\\begin{align}\n", + " \\rho_{loc}(\\omega) = \\frac{1}{2\\pi} \\int_{-\\infty}^{+\\infty} \\, e^{i\\omega t} \\, f(t) \\ dt,\n", + "\\end{align}\n", + "\n", + "with respect to an (arbitrary) initial state $\\psi(x,t=0)$, where\n", + "\n", + "\\begin{align}\n", + " f(t) &= \\int_{-\\infty}^{+\\infty} \\, \\psi^*(x,t) \\, \\psi(x,t=0) \\, dx \\\\\n", + " &\\approx \\int_{-\\infty}^{+\\infty} \\sum_i c_i^*(t) \\phi(x,x_i,\\sigma) \\, \\sum_j c_j(0) \\phi(x,x_j,\\sigma) \\, dx \\notag \\\\\n", + " &\\approx \\sum_i c_i^*(t) c_i(0). \\notag\n", + "\\end{align}\n", + "\n", + "Thus, the time propagation of an initial state towards positive *and* negative times followed by a Fourier transform of $f(t)$ yields the local density-of-states. To obtain the full density-of-states we need to average $\\rho_{loc}(\\omega)$ as follows\n", + "\n", + "\\begin{align}\n", + " \\rho(\\omega) = \\lim_{S \\to \\infty} \\frac{1}{S} \\sum_p^S \\rho^{(p)}_{loc}(\\omega)\n", + "\\end{align}\n", + "\n", + "over a variety of *random* initial states $p$.\n", + "\n", + "### Task 4.1 [3 points]\n", + "Implement a function which calculates the exact time-propagation matrix $U(\\tau)$ for a small time-step $\\tau$ given the Hamiltonian $H$. For simplicity, set $\\hbar = 1$ in the following. \n", + "\n", + "Hint: Use Scipy's $\\text{expm()}$ function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "6cb01e4b3c6c192a0df3c4111b91c8fa", + "grade": true, + "grade_id": "cell-42a7aac3f0fa4d1b", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def getU_exact(tau, H):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "79f8101b73fbb28ff9138437e9767178", + "grade": false, + "grade_id": "cell-9b02ad5515424242", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.2 [3 points]\n", + "Implement a function which performs the step-by-step time propagation given an initial state $\\vec{c}(0)$, the matrix $U(\\tau)$ and the discretized time grid $t_j$. In other words, your function should calculate \n", + "\n", + "$$\\vec{c}(j+1) = U(\\tau) \\cdot \\vec{c}(j)$$ \n", + "\n", + "for all $j$ of a given discretized time grid $t_j = j \\tau$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "dc040cc32e832b097bfb8c367f4203a1", + "grade": true, + "grade_id": "cell-4e444f44bf3bc9c1", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def timePropagate(U, c0, t):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "61362905e7a2d19219ae21f10a417823", + "grade": false, + "grade_id": "cell-62bfe608c358ff6d", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.3 [4 points]\n", + "Use both of the above functions to calculate and animate the time propagation of an initial state\n", + "\n", + "$$\\psi(x,t=0) = \\phi(x, x_{i=n/2}, \\sigma) \\leftrightarrow \\vec{c}(0) = [c_{i=n/2}(0) = 1, c_{i\\neq n/2}(0) = 0]$$\n", + "\n", + "for a $n=100$ chain. Discretize your time grid as $t_j=j\\tau$ with $j=0 \\dots 200$, and $\\tau=1.5$. Use again $a = 1$ and $\\sigma=0.25$. \n", + "\n", + "To plot / animate the time propagation you should plot the real-space wave function $\\psi(x,t) \\approx \\sum_i c_i(t) \\phi(x, x_i, \\sigma)$.\n", + "\n", + "Hint: use your function from task 3.4 to get the Hamiltonian $H$.\n", + "\n", + "For the animation you can use the following draft:\n", + "```python\n", + "# use matplotlib's animation package\n", + "import matplotlib.pylab as plt\n", + "import matplotlib\n", + "import matplotlib.animation as animation\n", + "# set the animation style to \"jshtml\" (for the use in Jupyter)\n", + "matplotlib.rcParams['animation.html'] = 'jshtml'\n", + "\n", + "# create a figure for the animation\n", + "fig = plt.figure()\n", + "plt.grid(True)\n", + "plt.xlim( ... ) # fix x limits\n", + "plt.ylim( ... ) # fix y limits\n", + "\n", + "# Create an empty plot object and prevent its showing (we will fill it each frame)\n", + "myPlot, = plt.plot([0], [0])\n", + "plt.close()\n", + "\n", + "# This function is called each frame to generate the animation (f is the frame number)\n", + "def animate(f): \n", + " myPlot.set_data( ... ) # update plot\n", + "\n", + "# Show the animation\n", + "frames = np.arange(1, np.size(t)) # t is the time grid here\n", + "myAnimation = animation.FuncAnimation(fig, animate, frames, interval = 20)\n", + "myAnimation\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "dac0e917be4cfe57c7d30715f3f61912", + "grade": true, + "grade_id": "cell-dd676b90f6a61df6", + "locked": false, + "points": 4, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "6786036a70e4fffbda4c92e340ff90de", + "grade": true, + "grade_id": "cell-70e223783d806888", + "locked": false, + "points": 0, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# Animate here ...\n", + "\n", + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "74ab18f8b5e98bc5456ef221449f9299", + "grade": false, + "grade_id": "cell-0395602360fd9e4c", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.4 [3 points]\n", + "Implement a function which calculates the Crank-Nicolson time-propagation matrix \n", + "\n", + "\\begin{align*}\n", + " U_{CN}(\\tau) = (I - i \\tau H / 2)\\cdot(I + i \\tau H / 2)^{-1}.\n", + "\\end{align*}\n", + "\n", + "Here, $I$ is the diagonal identity matrix. Use Numpy's $\\text{inv()}$ function to invert the needed expression." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "1b2677753953d9a528f0dbb71d4077bb", + "grade": true, + "grade_id": "cell-d74914e5d0a13365", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def getU_CN(tau, H):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "3746f3298575d0e0c37d35c01039e60e", + "grade": false, + "grade_id": "cell-1daec83575502040", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.5 [5 points]\n", + "Implement a function which calculates the time-propagation matrix using the Trotter-Suzuki decomposition \n", + "\n", + "\\begin{align*}\n", + " U_{TZ}(\\tau) = e^{-i\\tau H_1} \\cdot e^{-i \\tau H_2}.\n", + "\\end{align*}\n", + "\n", + "In this approach you choose a decomposition of the tight-binding Hamiltonian $H = H_1 + H_2$, which allows you to analytically diagonalize $H_1$ and $H_2$ (see last lecture). From this analytic diagonalization you will be able to calculate the matrix exponentials $e^{-i\\tau H_1}$ and $e^{-i \\tau H_2}$.\n", + "\n", + "Write your definition of the 2x2 blocks in $e^{-i\\tau H_1}$ and $e^{-i \\tau H_2}$ in the Markdown cell below. (Double click on \"YOUR ANSWER HERE\" to open the cell, and ctrl+enter to compile.) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "566fe9a7f8031baea9812438b155671c", + "grade": true, + "grade_id": "cell-bef909a443eb2a68", + "locked": false, + "points": 2, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "source": [ + "YOUR ANSWER HERE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "f9f25759b1a81bbac8c1834c2f4565b8", + "grade": true, + "grade_id": "cell-1425de6027596dea", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def getU_TZ(tau, H):\n", + " # YOUR CODE HERE\n", + " raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "1747285f36e24921cb5c2811632f33c3", + "grade": false, + "grade_id": "cell-f53dc443bd1858b1", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.6 [3 points]\n", + "In your implementation of $U_{TZ}(\\tau)$ you analytically evaluate the matrix exponentials $e^{-i\\tau H_1}$ and $e^{-i \\tau H_2}$. Test your implementation by comparing your results for these matrix exponentials to those obtained using Scipy's $\\text{expm()}$ function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "684e4173792cb10809386ef097c561e4", + "grade": true, + "grade_id": "cell-5aa3ffce9359fa7e", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "94ca5bdd479043f3c73214a3c4916923", + "grade": false, + "grade_id": "cell-c255a2bf5eac4e2b", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.7 [6 points]\n", + "In the next task you will need a Fourier transform to calculate the local density-of-states. Therefore you will need to implement a function that returns the Fourier transform $f(\\omega)$ of a given function $f(t)$ defined on a time grid $t$, for a given energy grid $\\omega$. I.e. it should calculate:\n", + "\n", + "\\begin{align}\n", + " f(\\omega) = \\frac{1}{2\\pi} \\int_{-\\infty}^{+\\infty} \\, e^{i\\omega t} \\, f(t) \\ dt.\n", + "\\end{align}\n", + "\n", + "Hint: use your integration function from task 2.2.\n", + "\n", + "Then implement a unit test for your function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "37055009cb70e69bc9b1dbc761859c51", + "grade": true, + "grade_id": "cell-87ece8e50b1f8de5", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "49aa23055a91a51494bcb9d64924cc75", + "grade": true, + "grade_id": "cell-46e1530333341bc6", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# Implement your unit test here ...\n", + "\n", + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "028bf13b6bf982c70fd1057c9d6f23f6", + "grade": false, + "grade_id": "cell-dc5656a6bdea875a", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.8 [3 points]\n", + "Calculate the local density-of-states $\\rho_{loc}(\\omega)$ from the Fourier transform of $f(t)$ using all three time propagation methods: $U(\\tau)$, $U_{CN}(\\tau)$ and $U_{TZ}(\\tau)$.\n", + "\n", + "Start from $\\psi(x,t=0) = \\phi(x, x_{i=0}, \\sigma)$ and $\\psi(x,t=0) = \\phi(x, x_{i=n/2}, \\sigma)$, using a $n=100$ chain. Discretize your integration time grid as $t_j=j\\tau$, with $j=-150 \\dots 150$ and $\\tau=1.5$. Use again $a = 1$ and $\\sigma=0.25$.\n", + "\n", + "Be careful: for the Fourier transform you will need positive *and* negative time steps! Thus you will need to do two time propagations: one using $U(\\tau)$ towards positive times and one using $U(-\\tau)$ towards negative times, both starting from $\\psi(x,t=0)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "29ff620823bca3839839fbc35ba9b236", + "grade": true, + "grade_id": "cell-316f9c26031f89df", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "1c27de03eb5f84673d52e1e621c316ee", + "grade": true, + "grade_id": "cell-d7a678fdeef64ea2", + "locked": false, + "points": 0, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# Do your own testing here ...\n", + "\n", + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "markdown", + "checksum": "c3e0ecb1b67f93590abf1a796bd507b8", + "grade": false, + "grade_id": "cell-ffbf1e8460ac69d8", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Task 4.9 [6 points]\n", + "Use the Trotter-Suzuki decomposition to calculate the full density-of-states by averaging over about $100$ local density-of-states you obtained from the time propagation of $100$ random initial states $\\vec{c}(0)$. To this end, you will need to make sure that each $\\vec{c}(0)$ is (a) normalized and (b) can have positive *and* negative elements. \n", + "\n", + "Compare this approximation to the total density-of-states to the exact one from task 3.6, which you obtained directly from the eigenvalues.\n", + "\n", + "Hint: don't expect the results to be the exact same. Check for the location of the peaks, and whether they have a similar order of magnitude.\n", + "\n", + "Hint: if you did not get the Trotter-Suzuki decomposition to work, you can instead use the exact or the Crank-Nicolson time-propagation matrix." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "81edbb8d07068d29021696fd87a961ba", + "grade": true, + "grade_id": "cell-2493a46a63277eda", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "5438067dfec55e69ee224e67178d9e36", + "grade": true, + "grade_id": "cell-a40dfcd993da467c", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# Do your plotting here ...\n", + "\n", + "# YOUR CODE HERE\n", + "raise NotImplementedError()" + ] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}