EpetraMapsAndVectors-rise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# PyTrilinos: Epetra Maps & Vectors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Epetra Maps\n",
    "\n",
    "* A \"map\" describes the distribution of global node (or element) indices across all processors\n",
    "* A \"node\" is a calculation point, e.g. finite elements, finite differences, etc.\n",
    "* \"global\" refers to a node numbering scheme that describes the entire model, i.e. what it would be if it where only run on a single processor\n",
    "* \"local\" refers to a on processor node numbering scheme \n",
    "* 4 ways to construct a map\n",
    "\n",
    "```python\n",
    "Map(numGE, iBase, comm)\n",
    "Map(numGE, numME, iBase, comm)\n",
    "Map(numGE, myGEs, iBase, comm)\n",
    "Map(map)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Epetra Map: Example 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting EpetraMap1.py\n"
     ]
    }
   ],
   "source": [
    "%%file EpetraMap1.py\n",
    "#!/usr/bin/env python\n",
    "from PyTrilinos import Epetra\n",
    "comm = Epetra.PyComm()\n",
    "standard_map = Epetra.Map(10, 0, comm)\n",
    "print(\"My global indices are: \" + str(standard_map.MyGlobalElements()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!mpiexec -np 2 python EpetraMap1.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Epetra Map: Example 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%file EpetraMap2.py\n",
    "#!/usr/bin/env python\n",
    "from PyTrilinos import Epetra\n",
    "comm = Epetra.PyComm() \n",
    "\n",
    "number_of_global_elements = 20 \n",
    "number_of_elements_on_first_processor = 4\n",
    "\n",
    "if comm.MyPID() == 0:\n",
    "    number_of_my_elements = number_of_elements_on_first_processor\n",
    "else:\n",
    "    number_of_my_elements = (number_of_global_elements -\n",
    "                             number_of_elements_on_first_processor) // (comm.NumProc() - 1)\n",
    "    \n",
    "standard_map = Epetra.Map(number_of_global_elements, number_of_my_elements, 0, comm)\n",
    "print(\"My global indices are: \" + str(standard_map.MyGlobalElements()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!mpiexec -np 2 python EpetraMap2.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!mpiexec -np 3 python EpetraMap2.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Epetra Map: Example 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%file EpetraMap3.py\n",
    "#!/usr/bin/env python\n",
    "from PyTrilinos import Epetra\n",
    "comm = Epetra.PyComm()\n",
    "\n",
    "if comm.MyPID() == 0:\n",
    "    my_global_elements = [0,2,4]\n",
    "else:\n",
    "    my_global_elements = [1,3,5,6]\n",
    "    \n",
    "standard_map = Epetra.Map(7, my_global_elements, 0, comm)\n",
    "print (\"My global indices are: \" + str(standard_map.MyGlobalElements()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!mpiexec -np 2 python EpetraMap3.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Epetra Vectors\n",
    "\n",
    "* Inherits from Numpy's `numpy.ndarray` \n",
    "  * Epetra Vectors are Numpy arrays\n",
    "\n",
    "* Distributed over processors according to the associated `Epetra.Map()`\n",
    "* Type: `double`\n",
    "  * See `Epetra.IntVector()` for `int` type \n",
    "  \n",
    "* Several useful constructors\n",
    "\n",
    "```python\n",
    "Vector(map, zeroOut=True)\n",
    "Vector(map, array)\n",
    "Vector(vector)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Epetra Vector: Example 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%file EpetraVector1.py\n",
    "#!/usr/bin/env python\n",
    "from PyTrilinos import Epetra\n",
    "import numpy as np\n",
    "\n",
    "comm = Epetra.PyComm()\n",
    "standard_map = Epetra.Map(10, 0, comm)\n",
    "x = Epetra.Vector(standard_map)\n",
    "\n",
    "x[:] = np.arange(standard_map.NumMyElements())\n",
    "\n",
    "print(\"My (local, global) indices are: \"+ str(np.array([x, standard_map.MyGlobalElements()], dtype=np.int).T))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!mpiexec -np 2 python EpetraVector1.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Epetra Vector: Example 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%file EpetraVector2.py\n",
    "#!/usr/bin/env python\n",
    "from PyTrilinos import Epetra \n",
    "import numpy as np\n",
    "\n",
    "comm = Epetra.PyComm()\n",
    "standard_map = Epetra.Map(10, 0, comm)\n",
    "\n",
    "x = Epetra.Vector(standard_map) \n",
    "y = Epetra.Vector(standard_map)\n",
    "\n",
    "x[:] = np.arange(standard_map.NumMyElements()) \n",
    "y[:] = x + 1\n",
    "\n",
    "tmp1 = x.Dot(y) \n",
    "tmp2 = x.Norm2() \n",
    "tmp3 = y.MaxValue()\n",
    "\n",
    "if comm.MyPID() == 0:\n",
    "    print(\"x . y = \" + str(tmp1[0]))\n",
    "    print(\"The L2 norm of x is = \" + str(tmp2[0])) \n",
    "    print(\"The max value of y is = \" + str(tmp3[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!mpiexec -np 2 python EpetraVector2.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Epetra Comm MPI-Style Methods\n",
    "\n",
    "* Several MPI-style methods available\n",
    "  \n",
    "  ```python\n",
    "   Broadcast(numpy.ndarray, int root)\n",
    "   GatherAll(PyObject obj) -> numpy.ndarray\n",
    "   SumAll(PyObject obj) -> numpy.ndarray\n",
    "   MaxAll(PyObject obj) -> numpy.ndarray\n",
    "   MinAll(PyObject obj) -> numpy.ndarray\n",
    "   ```\n",
    "   \n",
    "* All MPI methods available via `GetMpiComm`\n",
    "  * Example: `comm.GetMpiComm.Scatter(PyObject obj, root=0)`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Epetra Comm: Example\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%file EpetraComm.py\n",
    "#!/usr/bin/env python\n",
    "from PyTrilinos import Epetra \n",
    "import numpy as np\n",
    "comm = Epetra.PyComm()\n",
    "x = np.arange(5)\n",
    "tmp1 = comm.GatherAll(x)\n",
    "if comm.MyPID() == 0: print(tmp1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!mpiexec -np 2 python EpetraComm.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Epetra BlockMap and Epetra Multivector\n",
    "\n",
    "* Epetra Maps are Epetra BlockMaps\n",
    "  * With Point Size = 1\n",
    "  * Most `Map()` methods are defined for `BlockMaps()`\n",
    "\n",
    "* Epetra Vectors are Epetra MultiVectors\n",
    "  * With number of dimensions = 1\n",
    "  * Most `Vector()` methods are defined for `MultiVectors()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide_input": true,
    "init_cell": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "function hideElements(elements, start) {\n",
       "    for(var i = 0, length = elements.length; i < length;i++) {\n",
       "        if(i >= start) {\n",
       "            elements[i].style.display = \"none\";\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "var prompt_elements = document.getElementsByClassName(\"prompt\");\n",
       "hideElements(prompt_elements, 0)"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "function hideElements(elements, start) {\n",
    "    for(var i = 0, length = elements.length; i < length;i++) {\n",
    "        if(i >= start) {\n",
    "            elements[i].style.display = \"none\";\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "var prompt_elements = document.getElementsByClassName(\"prompt\");\n",
    "hideElements(prompt_elements, 0)"
   ]
  }
 ],
 "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.4"
  },
  "livereveal": {
   "autolaunch": false,
   "footer": "<img src='images/UT.png' width='220'>",
   "progress": true,
   "scroll": true,
   "theme": "simple"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}