{
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.4"
  },
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Implementierung einer quadratischen Finite-Elemente-Funktion\n",
      "\n",
      "In dieser \u00dcbung sollen analog zur linearen Finite-Elemente-Funktion der letzten \u00dcbung eine quadratische Finite-Elemente-Funktion implementiert werden.\n",
      "\n",
      "**Hinweis:**\n",
      "Falls Sie die Aufgaben in der bereitgestellen VM bearbeiten, m\u00fcssen Sie zun\u00e4chst die aktuell verf\u00fcgbaren Updates installieren.\n",
      "Geben Sie dazu die Befehle \"`sudo apt update`\" und \"`sudo apt dist-upgrade`\" im Terminal ein; geben Sie als Passwort \"`asdf`\" ein."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "import dune.common\n",
      "import dune.geometry\n",
      "import dune.grid"
     ],
     "language": "python",
     "metadata": {
      "scrolled": true
     },
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Aufgabe 1: Lokale Basisfunktionen (Quadratisch)\n",
      "\n",
      "In dieser Aufgabe sollen Sie die P2-Formfunktionen auf dem Referenzdreieck mit den Eckpunkten $x_0 = (0,0)$, $x_1 = (1,0)$ und $x_2 = (0,1)$, und den Kantenmittelpunkten $x_3 = (0.5, 0)$, $x_4 = (0, 0.5)$ und $x_5 = (0.5, 0.5)$ implementieren.\n",
      "\n",
      "Die Basisfunktionen $\\phi_i$ sind die quadratischen Polynomfunktionen mit der Eigenschaft $\\phi_i(x_j) = \\delta_{ij}$ f\u00fcr die Eck- und Kantenmittelpunkte $x_j$ des Dreiecks.\n",
      "\n",
      "Schreiben Sie eine Klasse `P2LocalBasis` mit den Methoden `evaluateFunction(self, xlocal)` und `evaluateJacobian(self, xlocal)`.\n",
      "Die Methode `evaluateFunction` soll ein numpy-Array mit den Werten aller P2-Basisfunktionen auf dem Dreieck im Punkt `xlocal` zur\u00fcckgeben.\n",
      "`evaluateJacobian` soll ein zweidimensionales numpy-Array mit den Gradienten aller P2-Basisfunktionen auf dem Dreieck zur\u00fcckgeben, so dass `evaluateJacobian(self, xlocal)[i]` der Gradient der `i`-ten Basisfunktion ist.\n",
      "\n",
      "![Nummerierung der Unterentit\u00e4ten f\u00fcr das Referenzdreieck](https://www.dune-project.org/doxygen/master/gg_triangle.png)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "class P2LocalBasis:\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "localBasis = P2LocalBasis()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\u00dcberpr\u00fcfen Sie, ob sich die Funktionen wie erwartet verhalten, indem Sie `evaluateFunction` und `evaluateJacobian` geeigneten Punkten aufrufen.\n",
      "\u00dcberpr\u00fcfen Sie insbesondere, dass die die Funktionswerte in jedem Punkt zu $1$, und die Gradienten zu $(0, 0)$ aufsummieren."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# ..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Aufgabe 2: Diskrete Gitterfunktionen\n",
      "\n",
      "In dieser Aufgabe sollen Sie eine Klasse `P2Function` implementieren, die eine stetige, st\u00fcckweise quadratische Funktion auf dem Gitter darstellt.\n",
      "Sei `u` der Koeffizientenvektor einer solchen Gitterfunktion bez\u00fcglich der Knotenbasis.\n",
      "Die Klasse `P2Function` soll den Koeffizientenvektor `u` und das Gitter als Attribute halten und sich in lokalen Koordinaten bez\u00fcglich einzelner Elemente auswerten lassen.\n",
      "\n",
      "Legen Sie eine Klasse `P2Function` an und implementieren Sie die Methoden `__init__(self, grid, u)`, `__call__(self, element, xlocal)` und `gradient(self, element, xlocal)`.\n",
      "Die Methode `__init__` soll hierbei die \u00fcbergebenen Argumente -- das Gitter `grid` und den Koeffizientenvektor `u` -- als Attribute speichern.\n",
      "Weiterhin soll eine Instanz der Klasse `P2LocalBasis` als Attribut gespeichert werden.\n",
      "\n",
      "`__call__` soll die Funktion auf dem Element `element` im Punkt `xlocal` auswerten; verwenden Sie hierzu die `P2LocalBasis`.\n",
      "Die Methode `gradient` soll entsprechend die Ableitung berechnen.\n",
      "Beachten Sie, dass `P2LocalBasis` die Ableitung bez\u00fcglich der Koordinaten auf dem Referenzelement zur\u00fcckgibt; die notwendigen Informationen f\u00fcr die Transformation erhalten Sie aus `element.geometry`.\n",
      "\n",
      "**Hinweis:**\n",
      "Speichern Sie in `u` zuerst alle Knotenfreiheitsgrade gefolgt von allen Kantenfreiheitsgraden.\n",
      "Die Anzahl der Knoten und Kanten im Gitter erhalten Sie aus der `grid.size(codim)`-Methode."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "class P2Function:\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Aufgabe 3: Interpolation\n",
      "\n",
      "Sei `f` eine beliebige Pythonfunktion, die eine Funktion $\\Omega \\to \\mathbb{R}$ implementiert.\n",
      "\n",
      "Schreiben Sie eine Funktion `interpolate(grid, f)`, die die Funktion `f` im P2-Funktionenraum interpoliert und den zugeh\u00f6rigen Koeffizientenvektor als numpy-Vektor zur\u00fcckgibt.\n",
      "\n",
      "**Hinweis:**\n",
      "Die UGGrid-Implementierung erlaubt es nicht direkt \u00fcber alle Kanten des Gitters zu iterieren.\n",
      "Die Funktion soll \u00fcber alle daher Gitterelemente iterieren und auf jedem Element geeignet interpolieren."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def interpolate(grid, f):\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Aufgabe 4: Berechnung des Interpolationsfehlers\n",
      "\n",
      "In dieser Aufgabe soll der Interpolationsfehler in der $L^2$- und $H^1$-Norm f\u00fcr verschiedene Funktionen und verschiedene Gitterweiten berechnet werden.\n",
      "\n",
      "Interpolieren Sie die Funktionen $f_0(x) = x_0^2 + x_1^2$, $f_1(x) = \\sin(\\pi x_0) + \\cos(\\pi x_1)$, $f_2(x) = |x_0 - 0.3333|$ und $f_3(x) = |x_0 - 0.0625|$ jeweils auf einem $n\\times n$-Dreiecksgitter mit $n = 10, 20, 40, 80$.\n",
      "Berechnen Sie jeweils den Interpolationsfehler $\\| f_i - f_{i,h} \\|_{L^2(\\Omega)}$ und $\\| f_i - f_{i,h} \\|_{H^1(\\Omega)}$; verwenden Sie dabei eine Quadraturregel vierter Ordnung.\n",
      "\n",
      "Wie verh\u00e4lt sich der Fehler als Funktion von $h = 1/n$?\n",
      "Vergleichen Sie mit dem Fehler bei Interpolation durch P1-Funktionen vom letzten \u00dcbungsblatt."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# ..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "(Schreiben Sie hier Ihre Antwort.)"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}