{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "from IPython.core.display import HTML "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1\n",
    "---\n",
    "\n",
    "Consider the flow of a fluid $A$ that has the following density $\\rho$, and a viscosity $\\mu$ down a pipe of diamtere $D$ and surface roughness $e$ at a mean flow velocity $V$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://www.lmnoeng.com/Pressure/Pressure_Drop_dwg.jpg\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(url= \"https://www.lmnoeng.com/Pressure/Pressure_Drop_dwg.jpg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are measuring the pressure drop in the pipe between two different position $\\Delta p = p_2 - p_1$ separated by a distance $L$.\n",
    "$$\\Delta p_L = f(V, D, \\rho, \\mu, L, e)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Buckingham Pi theorem we can reduce the dimensionality of the problem\n",
    "$$f(V, D, \\rho, \\mu, L, e) \\implies f(\\pi_1, \\pi_2, \\cdots)$$ \n",
    "where $\\pi_i$ are dimensionless parameters constructed from the original variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from src.buckinghampi import BuckinghamPi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5040/5040 [00:12<00:00, 411.17it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------------\n",
      "L/e\n",
      "D/e\n",
      "V*e*rho/mu\n",
      "dp*e**2*rho/mu**2\n",
      "-----------------\n",
      "e/L\n",
      "L**2*dp*rho/mu**2\n",
      "D/L\n",
      "L*V*rho/mu\n",
      "-----------------\n",
      "L/e\n",
      "D/e\n",
      "mu/(V*e*rho)\n",
      "dp/(V**2*rho)\n",
      "-----------------\n",
      "e/L\n",
      "D/L\n",
      "mu/(L*sqrt(dp)*sqrt(rho))\n",
      "V*sqrt(rho)/sqrt(dp)\n",
      "-----------------\n",
      "L/e\n",
      "D/e\n",
      "mu/(sqrt(dp)*e*sqrt(rho))\n",
      "V*sqrt(rho)/sqrt(dp)\n",
      "-----------------\n",
      "e/L\n",
      "dp/(V**2*rho)\n",
      "mu/(L*V*rho)\n",
      "D/L\n",
      "-----------------\n",
      "L/e\n",
      "D/e\n",
      "V*e*rho/mu\n",
      "dp*e/(V*mu)\n",
      "-----------------\n",
      "e/L\n",
      "D/L\n",
      "L**2*dp*rho/mu**2\n",
      "V*mu/(L*dp)\n",
      "-----------------\n",
      "D/L\n",
      "e/L\n",
      "L*dp/(V*mu)\n",
      "L*V*rho/mu\n",
      "-----------------\n",
      "e/D\n",
      "L/D\n",
      "D**2*dp*rho/mu**2\n",
      "V*mu/(D*dp)\n",
      "-----------------\n",
      "e/D\n",
      "L/D\n",
      "D*dp/(V*mu)\n",
      "D*V*rho/mu\n",
      "-----------------\n",
      "e/D\n",
      "L/D\n",
      "mu/(D*sqrt(dp)*sqrt(rho))\n",
      "V*sqrt(rho)/sqrt(dp)\n",
      "-----------------\n",
      "D/L\n",
      "e/L\n",
      "V*mu/(L*dp)\n",
      "V**2*rho/dp\n",
      "-----------------\n",
      "L/D\n",
      "e/D\n",
      "V*mu/(D*dp)\n",
      "V**2*rho/dp\n",
      "-----------------\n",
      "D*V*rho/mu\n",
      "e/D\n",
      "D**2*dp*rho/mu**2\n",
      "L/D\n",
      "-----------------\n",
      "dp/(V**2*rho)\n",
      "e/D\n",
      "mu/(D*V*rho)\n",
      "L/D\n",
      "-----------------\n",
      "V*mu/(dp*e)\n",
      "L/e\n",
      "V**2*rho/dp\n",
      "D/e\n",
      "-----------------\n",
      "dp*e/(V*mu)\n",
      "L*dp/(V*mu)\n",
      "D*dp/(V*mu)\n",
      "V**2*rho/dp\n",
      "-----------------\n",
      "D*V*rho/mu\n",
      "V*e*rho/mu\n",
      "dp/(V**2*rho)\n",
      "L*V*rho/mu\n",
      "-----------------\n",
      "L/e\n",
      "dp*e**2*rho/mu**2\n",
      "D/e\n",
      "V*mu/(dp*e)\n",
      "-----------------\n",
      "D*sqrt(dp)*sqrt(rho)/mu\n",
      "sqrt(dp)*e*sqrt(rho)/mu\n",
      "V*sqrt(rho)/sqrt(dp)\n",
      "L*sqrt(dp)*sqrt(rho)/mu\n"
     ]
    }
   ],
   "source": [
    "pipe_flow = BuckinghamPi(physical_dimensions='m l t')\n",
    "pipe_flow.add_variable(name='dp',expression='m/(l*t**2)')\n",
    "pipe_flow.add_variable(name='V',expression='l/t')\n",
    "pipe_flow.add_variable(name='D',expression='l')\n",
    "pipe_flow.add_variable(name='rho',expression='m/(l**3)')\n",
    "pipe_flow.add_variable(name='L',expression='l')\n",
    "pipe_flow.add_variable(name='mu',expression='m/(l*t)')\n",
    "pipe_flow.add_variable(name='e',expression='l')\n",
    "\n",
    "pipe_flow.generate_pi_terms()\n",
    "\n",
    "for piterms in pipe_flow.pi_terms:\n",
    "  print('-----------------')\n",
    "  for term in piterms:\n",
    "    print(term)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2\n",
    "---\n",
    "The stability of a numerical time integrator in a fluid flow simulation for an incompressible flow on a staggered uniform grid is hinged upon the following set of variables:\n",
    "\n",
    "* Advection velocity: $u \\rightarrow \\frac{L}{T}$\n",
    "* Density of the fluid: $\\rho \\rightarrow \\frac{M}{L**3}$\n",
    "* Dynamic viscosity: $\\mu \\rightarrow \\frac{M}{LT}$\n",
    "* Grid spacing: $\\mathrm{d}x \\rightarrow L$\n",
    "* Time step: $\\mathrm{d}t \\rightarrow T$\n",
    "\n",
    "using the Buckingham Pi module we can obtain the dimensionless $\\pi$ terms that describe this example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 120/120 [00:00<00:00, 617.75it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------------\n",
      "dx**2*rho/(dt*mu)\n",
      "dt*u/dx\n",
      "-----------------\n",
      "dx*sqrt(rho)/(sqrt(dt)*sqrt(mu))\n",
      "sqrt(dt)*sqrt(rho)*u/sqrt(mu)\n",
      "-----------------\n",
      "dx/(dt*u)\n",
      "dt*rho*u**2/mu\n",
      "-----------------\n",
      "dx*rho*u/mu\n",
      "dt*mu/(dx**2*rho)\n",
      "-----------------\n",
      "dx*rho*u/mu\n",
      "dt*u/dx\n",
      "-----------------\n",
      "dt*mu/(dx**2*rho)\n",
      "dt*u/dx\n",
      "-----------------\n",
      "dx/(dt*u)\n",
      "mu/(dt*rho*u**2)\n",
      "-----------------\n",
      "mu/(dx*rho*u)\n",
      "dt*u/dx\n",
      "-----------------\n",
      "dt*rho*u**2/mu\n",
      "dx*rho*u/mu\n"
     ]
    }
   ],
   "source": [
    "stability = BuckinghamPi('M L T')\n",
    "stability.add_variable('u','L/T')\n",
    "stability.add_variable('rho','M/(L**3)')\n",
    "stability.add_variable('mu','M/(L*T)')\n",
    "stability.add_variable('dx','L')\n",
    "stability.add_variable('dt','T')\n",
    "stability.generate_pi_terms()\n",
    "\n",
    "for piterms in stability.pi_terms:\n",
    "  print('-----------------')\n",
    "  for term in piterms:\n",
    "    print(term)\n"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}