--- /dev/null
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Tutorial-1\n",
+ "\n",
+ "The first thing to do to use the python wrappers is to import the package. **PyDealII** is only a shell and importing it will only allow you to call\n",
+ "```python \n",
+ "help(PyDealII)\n",
+ "``` \n",
+ "**PyDealII** is composed of two libraries: \n",
+ " - **PyDealII.Debug** which uses the debug version of **deal.II**\n",
+ " - **PyDealII.Release** which uses the release version of **deal.II**\n",
+ " \n",
+ "In this tutorial, we import the debug version of the library as **dealii**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "import PyDealII.Debug as dealii"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We start by creating a 2D **Triangulation** of an hyper cube and we globally refine it twice. You can read the documention of **Triangulation** by typing:\n",
+ "```python\n",
+ "help(dealii.Triangulation)\n",
+ "```\n",
+ "This will show you all the functions associated with **Triangulation** and for each one, you will get a short explanation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "triangulation = dealii.Triangulation('2D')\n",
+ "triangulation.generate_hyper_cube()\n",
+ "triangulation.refine_global(2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we would like to visualize the mesh that has been created. We can output a _vtu_ file using\n",
+ "```python\n",
+ "triangulation.write('triangulation.vtu', 'vtu')\n",
+ "```\n",
+ "and then use VisIt or Paraview. This is probably what you want to do for a 3D **Triangulation**. However, in this tutorial, we will create a function to plot the result using matplotlib. This will allow us to look at the mesh inside the notebook. To do that we will use _matplotlib_ and _numpy_."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "from matplotlib.patches import Polygon\n",
+ "from matplotlib.collections import PatchCollection\n",
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The function below takes as input a **Triangulation** and a function that is used to define the color scheme. In this function, we loop over all the active cells, get the coordinates of the vertices, and use these coordinates to create polygons that we plot. We can loop over the active cells using\n",
+ "```python\n",
+ "for cell in triangulation.active_cells()\n",
+ "```\n",
+ "Once we have a cell, we can get any vertex using\n",
+ "```python\n",
+ "vertex = cell.get_vertex(i)\n",
+ "```\n",
+ "Since a _vertex_ is a **Point**, we can the coordinates of the **Point** using\n",
+ "```python\n",
+ "x = vertex.x\n",
+ "y = vertex.y\n",
+ "z = vertex.z\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def plot_triangulation(triangulation, color_scheme):\n",
+ " fig, ax = plt.subplots()\n",
+ " patches = []\n",
+ " colors = []\n",
+ " cell_id = 0 \n",
+ " for cell in triangulation.active_cells():\n",
+ " quad_vertices = np.zeros((4,2))\n",
+ " # The shift variable is used to reorder the vertices because\n",
+ " # deal.II and matplotlib require different ordering\n",
+ " shift = [0,1,3,2]\n",
+ " for i in range(4):\n",
+ " vertex = cell.get_vertex(i)\n",
+ " quad_vertices[shift[i]][0] = vertex.x\n",
+ " quad_vertices[shift[i]][1] = vertex.y\n",
+ " quad = Polygon(quad_vertices, closed=True)\n",
+ " patches.append(quad)\n",
+ " colors.append(color_scheme(cell_id, cell))\n",
+ " cell_id += 1\n",
+ " p = PatchCollection(patches) \n",
+ " p.set_array(np.array(colors))\n",
+ " ax.add_collection(p, autolim=True)\n",
+ " ax.autoscale_view()\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We know define a color scheme function and plot the **Triangulation**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x7f24415ba828>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def color_sc(cell_id, cell):\n",
+ " return cell_id\n",
+ "\n",
+ "plot_triangulation(triangulation, color_sc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now let's assume that the left half of the domain is composed of a different material than the right half of the domain. We will loop over all the cells and if the abscissa of the cell barycenter is less than 0.5, we will assign zero to the *material_id* of the cell. The others cells will be assigned a *material_id* of one.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x7f24351b8278>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for cell in triangulation.active_cells():\n",
+ " if cell.barycenter().x < 0.5:\n",
+ " cell.material_id = 0\n",
+ " else:\n",
+ " cell.material_id = 1\n",
+ "\n",
+ "def mat_id_color_sc(cell_id, cell):\n",
+ " return cell.material_id\n",
+ "\n",
+ "plot_triangulation(triangulation, mat_id_color_sc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will refine isotropically the cells that have a *material_id* equal to zero and plot the **Triangulation**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x7f24350972b0>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for cell in triangulation.active_cells():\n",
+ " if cell.material_id == 0:\n",
+ " cell.refine_flag ='isotropic'\n",
+ "triangulation.execute_coarsening_and_refinement()\n",
+ "\n",
+ "plot_triangulation(triangulation, color_sc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will now show how to merge two **Triangulations**. In order to merge the two **Triangulations**, we will need to move (shift) the second **Triangulation** such that it doesn't overlap with the first one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n1CDjLkkNMu6S1CDjLkkN+n8frNamzekaCQAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x7f243502add8>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "triangulation_2 = dealii.Triangulation('2D')\n",
+ "triangulation_2.generate_hyper_cube()\n",
+ "triangulation_2.refine_global(2)\n",
+ "triangulation_2.shift([2.,0.])\n",
+ "\n",
+ "plot_triangulation(triangulation_2, color_sc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We are now almost ready to merge the **Triangulations**. However, deal.II does not allow us to merge **Triangulations** that have been refined. We can use the *flatten_triangulation* function to create new **Triangulations** that are not refined but this function does not work if the mesh contains hanging nodes. Thus, we need to modify the first triangulation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x7f2474278748>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "flatten_triangulation_1 = dealii.Triangulation('2D')\n",
+ "triangulation.generate_hyper_cube()\n",
+ "triangulation.refine_global(2)\n",
+ "triangulation.flatten_triangulation(flatten_triangulation_1)\n",
+ "flatten_triangulation_2 = dealii.Triangulation('2D')\n",
+ "triangulation_2.flatten_triangulation(flatten_triangulation_2)\n",
+ "triangulation_3 = dealii.Triangulation('2D')\n",
+ "triangulation_3.merge_triangulations(flatten_triangulation_1, flatten_triangulation_2)\n",
+ "\n",
+ "plot_triangulation(triangulation_3, color_sc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Like expected the second **Triangulation** is moved too far on the right. This mistake can easily fixed by moving *flatten_triangulation_2* to the left and merging the **Triangulations** once again. We can see the advantage of using python over C++. In C++, we would have to recompile and rerun the code while in python we can very easily fix our mistake."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0x7f2434f4c828>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "flatten_triangulation_2.shift([-1.,0])\n",
+ "triangulation_3.merge_triangulations(flatten_triangulation_1, flatten_triangulation_2)\n",
+ "\n",
+ "plot_triangulation(triangulation_3, color_sc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that we are done generating the grid, we need to save it in a format that will make it easy to load in our C++ code. This can be done using the _save_ function python and then using the _Triangulation::load()_ function in C++. The only caveat is that **parallel::distributed::Triangulation** cannot load a grid which has refined cells. Once again this can be fixed by flattening the **Triangulation** (this is not necessary here)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "triangulation_3.save('merged_triangulation')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The C++ code to load the mesh is\n",
+ "```C++\n",
+ "triangulation.load('merged_triangulation');\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**NOTE**\n",
+ "If the C++ code throws an exception, the error message will be shown. However, if the code segfaults then the kernel will simply be killed. In this case, the easiest way to debug your code is to use gdb to find the problem. This can be done by exporting your notebook as a python code and then typing:\n",
+ "``` bash\n",
+ "gdb python\n",
+ "run my_program.py\n",
+ "```\n",
+ "Below, we show an example of an error message coming from the C++ code."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "RuntimeError",
+ "evalue": "\n--------------------------------------------------------\nAn error occurred in line <443> of file </home/jovyan/work/dealii/contrib/python-bindings/source/cell_accessor_wrapper.cc> in function\n dealii::python::PointWrapper dealii::python::CellAccessorWrapper::get_vertex(int) const\nThe violated condition was: \n i<std::pow(2,dim)\nAdditional information: \n Requested vertex number 5does not exist. The largest vertex number acceptable is 3\n--------------------------------------------------------\n",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m<ipython-input-12-93dcdab2ba83>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcell\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtriangulation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactive_cells\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mvertex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcell\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_vertex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m: \n--------------------------------------------------------\nAn error occurred in line <443> of file </home/jovyan/work/dealii/contrib/python-bindings/source/cell_accessor_wrapper.cc> in function\n dealii::python::PointWrapper dealii::python::CellAccessorWrapper::get_vertex(int) const\nThe violated condition was: \n i<std::pow(2,dim)\nAdditional information: \n Requested vertex number 5 does not exist. The largest vertex number acceptable is 3\n--------------------------------------------------------\n"
+ ]
+ }
+ ],
+ "source": [
+ "for cell in triangulation.active_cells():\n",
+ " vertex = cell.get_vertex(5)"
+ ]
+ }
+ ],
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
projects / dealii.git / commitdiff