docs/tutorial/2_solving_a_problem.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# PySPH Tutorial:  Solving a simple problem\n",
    "\n",
    "*Prabhu Ramachandran*\n",
    "\n",
    "Department of Aerospace Engineering, IIT Bombay\n",
    "\n",
    "----------\n",
    "\n",
    "\n",
    "Let us try to solve a little problem: the motion of an elliptical drop of water.\n",
    "\n",
    "\n",
    "Initial conditions:\n",
    "\n",
    "- $\\rho = 1.0$\n",
    "- Particles are inside a circle of $x^2 + y^2 < 1$\n",
    "- $dx = 0.025, h = 1.3 dx$\n",
    "- $u = -100 x, v = 100 y $\n",
    "- Choose $c_s = 1400, dt=5e-6, tf=0.0076$\n",
    "- Fluid is incompressible.\n",
    "\n",
    "The velocity field of the initial condition looks as shown in the picture below:\n",
    "\n",
    "<img width=400 height=400 src=\"images/elliptical_drop_ic.png\"/>\n",
    "\n",
    "Let us solve this with the WCSPH scheme.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Solving this with PySPH\n",
    "\n",
    "\n",
    "1. Subclass the `Application` class (`pysph.solver.application.Application`).\n",
    "2. Add a `create_particles(self)` method which returns a tuple/list of particle arrays.\n",
    "3. Add a `create_scheme(self)` method which returns a suitably configured \"WCSPH scheme\".\n",
    "\n",
    "\n",
    "### Exercise\n",
    "\n",
    "- Starting with the example below, create the particles correctly below.  \n",
    "- Put this in a separate file called `ed.py`. \n",
    "- Remember to set the properties: `u, v, rho, h, m`.\n",
    "- Don't run this from IPython.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from pysph.solver.application import Application\n",
    "from pysph.base.utils import get_particle_array\n",
    "\n",
    "\n",
    "class EllipticalDrop(Application):\n",
    "    def create_particles(self):\n",
    "        return []\n",
    "\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    app = EllipticalDrop()\n",
    "    app.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution\n",
    "\n",
    "Try solving this yourselves and then compare with the solution below.\n",
    "\n",
    "DON'T run this yet!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%load solutions/ed0.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Creating the scheme\n",
    "\n",
    "- Now that the particles are created, let us create the scheme.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from pysph.solver.application import Application\n",
    "from pysph.base.utils import get_particle_array\n",
    "from pysph.sph.scheme import WCSPHScheme  #  <--- ADDED\n",
    "\n",
    "class EllipticalDrop(Application):\n",
    "    def create_particles(self):\n",
    "        # ...\n",
    "        self.scheme.setup_properties([pa])  # <--- ADDED\n",
    "        return pa\n",
    "        \n",
    "    def create_scheme(self):\n",
    "        s = WCSPHScheme(\n",
    "            ['fluid'], [], dim=2, rho0=1.0, c0=1400,\n",
    "            h0=1.3*0.025, hdx=1.3, gamma=7.0, alpha=0.1, beta=0.0\n",
    "        )\n",
    "        dt = 5e-6\n",
    "        tf = 0.0076\n",
    "        s.configure_solver(\n",
    "            dt=dt, tf=tf,\n",
    "        )\n",
    "        return s        \n",
    "\n",
    "\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    app = EllipticalDrop()\n",
    "    app.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Exercise\n",
    "\n",
    "- Modify your example to add the changes made above.\n",
    "- Run the example as `python ed.py`\n",
    "- Visualize the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution\n",
    "\n",
    "Try to get the example running, see the solution below if you are stuck."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%load solutions/ed.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution discussion\n",
    "\n",
    "Recall that you can run the example as follows (on a terminal):\n",
    "\n",
    "    > python ed.py\n",
    "        \n",
    "Try this:\n",
    "\n",
    "    > python ed.py -h\n",
    "    \n",
    "You can also run the example to use OpenMP like so:\n",
    "\n",
    "    > python ed.py --openmp\n",
    "    \n",
    "With multiple cores this should produce some speed-up.\n",
    "\n",
    "The runs will produce output inside the `ed_output` directory.\n",
    "\n",
    "- You can use `-d output_dir` to have the output generated in the `output_dir` instead.\n",
    "    \n",
    "    \n",
    "You can visualize the output using:\n",
    "\n",
    "    > pysph view ed_output\n",
    "    \n",
    "    \n",
    "Note that the output directory also contains a very useful log file that is handy when debugging, in this case the file would be `ed_output/ed.log`.  \n",
    "\n",
    "The output directory contains the data saved at different times in either `*.npz` or `*.hdf5` files depending on your installation.  The next chapter explores post-processing a little."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Running the example from inside IPython\n",
    "\n",
    "**NOTE:**  If you want to run the example on an IPython notebook you may do so, but you will need to create the app instance as follows::\n",
    "\n",
    "```\n",
    "if __name__ == '__main__':\n",
    "    app = EllipticalDrop(fname='ed')\n",
    "```\n",
    "\n",
    "Note the addition of `fname='ed'`.  The filename and output directory to pick is determined by the filename and on IPython this is not meaningful, so if you want the output generated in the right directory, you must explicitly pass fname.  When run externally from Python, this is automatically determined for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Exploring a bit more\n",
    "\n",
    "- Learn more about the `WCSPHScheme`\n",
    "- Learn about the `configure_solver` method and its options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from pysph.sph.scheme import WCSPHScheme\n",
    "WCSPHScheme.configure_solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Homework1\n",
    "\n",
    "- Go over this tutorial: http://pysph.readthedocs.io/en/latest/tutorial/circular_patch_simple.html\n",
    "- Familiarize yourself with it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Advanced exercise\n",
    "\n",
    "- Take the above example `ed.py` as a starting point and copy it to `dam_break.py`.\n",
    "- Modify the `dam_break.py` to solve the 2D dam break problem, as below\n",
    "- Fluid height = 2\n",
    "- Fluid width = 1.0\n",
    "- Container height = 4\n",
    "- Container width = 4\n",
    "- Assume g=9.81 m/s\n",
    "\n",
    "- Use 2-3 layers of particles for the boundary\n",
    "\n",
    "\n",
    "```\n",
    "    |                         |\n",
    "    |                         |           \n",
    "    |   1                     |\n",
    "    |*******                  |   4     \n",
    "    |*******                  |\n",
    "    |*******  2               |\n",
    "    |*******                  |\n",
    "    ---------------------------\n",
    "    \n",
    "                 4\n",
    "```\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}