{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 2. Solving a 1D diffusion equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Document Author: Dr. Vishal Sharma\n",
    "# Author email: sharma_vishal14@hotmail.com\n",
    "# License: MIT\n",
    "# This tutorial is applicable for NAnPack version 1.0.0-alpha4 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### I. Background\n",
    "\n",
    "The objective of this tutorial is to present the step-by-step solution of a 1D diffusion equation using NAnPack such that users can follow the instructions to learn using this package. The  numerical solution is obtained using the Forward Time Central Spacing (FTCS) method. The detailed description of the FTCS method is presented in Section IV of this tutorial.\n",
    "\n",
    "### II. Case Description\n",
    "\n",
    "We will be solving a classical probkem of a suddenly accelerated plate in fluid mechanicas which has the known exact solution. In this problem, the fluid is\n",
    "bounded between two parallel plates. The upper plate remains stationary and the lower plate is suddenly accelerated in *y*-direction at velocity $U_o$. It is\n",
    "required to find the velocity profile between the plates for the given initial and boundary conditions.\n",
    "\n",
    "(For the sake of simplicity in setting up numerical variables, let's assume that the *x*-axis is pointed in the upward direction and *y*-axis is pointed along the horizontal direction as shown in the schematic below:"
   ]
  },
  {
   "attachments": {
    "1be77927-d72d-49db-86dc-b2af1aeed6b7.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![parallel-plate-plot.png](attachment:1be77927-d72d-49db-86dc-b2af1aeed6b7.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Initial conditions**\n",
    "$$u(t=0.0, 0.0<x\\leq H) = 0.0 \\;m/s$$\n",
    "$$u(t=0.0, x=0.0) = 40.0 \\;m/s$$\n",
    "\n",
    "**Boundary conditions**\n",
    "$$u(t\\geq0.0, x=0.0) = 40.0 \\;m/s$$\n",
    "$$u(t\\geq0.0, x=H) = 0.0 \\;m/s$$\n",
    "\n",
    "Viscosity of fluid, $\\;\\;\\nu = 2.17*10^{-4} \\;m^2/s$  \n",
    "Distance between plates, $\\;\\;H = 0.04 \\;m$  \n",
    "Grid step size, $\\;\\;dx = 0.001 \\;m$  \n",
    "Simulation time, $\\;\\;T = 1.08 \\;sec$\n",
    "\n",
    "Specify the required simulation inputs based on our setup in the configuration file provided with this package. You may choose to save the configuration file with any other filename. I have saved the configuration file in the \"input\" folder of my project directory such that the relative path is `./input/config.ini`.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### III. Governing Equation\n",
    "\n",
    "The governing equation for the given application is the simplified for the the Navies-Stokes equation which is given as:\n",
    "\n",
    "$$\\frac{\\partial u} {\\partial t} = \\nu\\frac{\\partial^2 u}{\\partial x^2}$$\n",
    "\n",
    "This is the diffusion equation model and is classified as the parabolic PDE.\n",
    "\n",
    "### IV. FTCS method\n",
    "\n",
    "The forward time central spacing approximation equation in 1D is presented here. This is a time explicit method which means that one unknown is calculated using the known neighbouring values from the previous time step. Here *i* represents grid point location, *n*+1 is the future time step, and *n* is the current time step.\n",
    "\n",
    "$$u_{i}^{n+1} = u_{i}^{n} + \\frac{\\nu\\Delta t}{(\\Delta x)^2}(u_{i+1}^{n} - 2u_{i}^{n} + u_{i-1}^{n})$$\n",
    "\n",
    "The order of this approximation is $[(\\Delta t), (\\Delta x)^2]$\n",
    "\n",
    "The diffusion number is given as $d_{x} = \\nu\\frac{\\Delta t}{(\\Delta x)^2}$ and for one-dimensional applications the stability criteria is $d_{x}\\leq\\frac{1}{2}$ \n",
    "\n",
    "The solution presented here is obtained using a diffusion number = 0.5 (CFL = 0.5 in configuration file). Time step size will be computed using the expression of diffusion number. Beginners are encouraged to try diffusion numbers greater than 0.5 as an exercise after running this script.\n",
    "\n",
    "Users are encouraged to read my blogs on numerical methods - [link here](https://www.linkedin.com/in/vishalsharmaofficial/detail/recent-activity/posts/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### V. Script Development\n",
    "\n",
    "*Please note that this code script is provided in file `./examples/tutorial-02-diffusion-1D-solvers-FTCS.py`.*\n",
    "\n",
    "As per the Python established coding guidelines [PEP 8](https://www.python.org/dev/peps/pep-0008/#imports), all package imports must be done at the top part of the script in the following sequence -- \n",
    "1. import standard library\n",
    "2. import third party modules\n",
    "3. import local application/library specific\n",
    "\n",
    "Accordingly, in our code we will importing the following required modules (in alphabetical order). If you are using Jupyter notebook, hit `Shift + Enter` on each cell after typing the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from nanpack.benchmark import ParallelPlateFlow\n",
    "import nanpack.preprocess as pre\n",
    "from nanpack.grid import RectangularGrid\n",
    "from nanpack.parabolicsolvers import FTCS\n",
    "import nanpack.postprocess as post"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the first step in simulation, we have to tell our script to read the inputs and assign those inputs to the variables/objects that we will use in our entire code. For this purpose, there is a class `RunConfig` in `nanpack.preprocess` module. We will call this class and assign an object (instance) to it so that we can use its member variables. The `RunConfig` class is written in such a manner that its methods get executed as soon as it's instance is created. The users must provide the configuration file path as a parameter to `RunConfig` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*******************************************************\n",
      "*******************************************************\n",
      "Starting configuration.\n",
      "\n",
      "Searching for simulation configuration file in path:\n",
      "\"D:/MyProjects/projectroot/nanpack/input/config.ini\"\n",
      "SUCCESS: Configuration file parsing.\n",
      "Checking whether all sections are included in config file.\n",
      "Checking section SETUP: Completed.\n",
      "Checking section DOMAIN: Completed.\n",
      "Checking section MESH: Completed.\n",
      "Checking section IC: Completed.\n",
      "Checking section BC: Completed.\n",
      "Checking section CONST: Completed.\n",
      "Checking section STOP: Completed.\n",
      "Checking section OUTPUT: Completed.\n",
      "Checking numerical setup.\n",
      "User inputs in SETUP section check: Completed.\n",
      "Accessing domain geometry configuration: Completed\n",
      "Accessing meshing configuration: Completed.\n",
      "Calculating grid size: Completed.\n",
      "Assigning COLD-START initial conditions to the dependent term.\n",
      "Initialization: Completed.\n",
      "Accessing boundary condition settings: Completed\n",
      "Accessing constant data: Completed.\n",
      "Calculating time step size for the simulation: Completed.\n",
      "Calculating maximum iterations/steps for the simulation: Completed.\n",
      "Accessing simulation stop settings: Completed.\n",
      "Accessing settings for storing outputs: Completed.\n",
      "\n",
      "**********************************************************\n",
      "CASE DESCRIPTION                SUDDENLY ACC. PLATE\n",
      "SOLVER STATE                    TRANSIENT\n",
      "MODEL EQUATION                  DIFFUSION\n",
      "DOMAIN DIMENSION                1D\n",
      "    LENGTH                      0.04\n",
      "GRID STEP SIZE\n",
      "    dX                          0.001\n",
      "TIME STEP                       0.002\n",
      "GRID POINTS\n",
      "    along X                     41\n",
      "DIFFUSION CONST.                2.1700e-04\n",
      "DIFFUSION NUMBER                0.5\n",
      "TOTAL SIMULATION TIME           1.08\n",
      "NUMBER OF TIME STEPS            468\n",
      "START CONDITION                 COLD-START\n",
      "**********************************************************\n",
      "SUCEESS: Configuration completed.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "FileName = \"path/to/project/input/config.ini\" # specify the correct file path\n",
    "cfg = pre.RunConfig(FileName) # cfg is an instance of RunConfig class which can be used to access class variables. You may choose any variable in place of cfg."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will obtain several configuration messages on your output screen so that you can verify that your inputs are correct and that the configuration is successfully completed. Next step is the assignment of initial conditions and the boundary conditions. For assigning boundary conditions, I have created a function `BC()` which we will be calling in the next cell. I have included this function at the bottom of this tutorial for your reference. It is to be noted that U is the dependent variable that was initialized when we executed the configuration, and thus we will be using `cfg.U` to access the initialized U. In a similar manner, all the inputs provided in the configuration file can be obtained by using configuration class object `cfg.` as the prefix to the variable names. Users are allowed to use any object of their choice.\n",
    "\n",
    "*If you are using Jupyter Notebook, the function BC must be executed before referencing to it, otherwise, you will get an error. Jump to the bottom of this notebook where you see code cell # 1 containing the `BC()` function*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign initial conditions\n",
    "cfg.U[0] = 40.0\n",
    "cfg.U[1:] = 0.0\n",
    "\n",
    "# Assign boundary conditions\n",
    "U = BC(cfg.U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will be calculating location of all grid points within the domain using the function `RectangularGrid()` and save values into X. We will also require to calculate diffusion number in X direction. In nanpack, the program treats the diffusion number = CFL for 1D applications that we entered in the configuration file, and therefore this step may be skipped, however, it is not the same in two-dimensional applications and therefore to stay consistent and to avoid confusion we will be using the function `DiffusionNumbers()` to compute the term `diffX`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uniform rectangular grid generation in cartesian coordinate system: Completed.\n"
     ]
    }
   ],
   "source": [
    "X, _ = RectangularGrid(cfg.dX, cfg.iMax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating diffusion numbers: Completed.\n"
     ]
    }
   ],
   "source": [
    "diffX,_ = pre.DiffusionNumbers(cfg.Dimension, cfg.diff, cfg.dT, cfg.dX)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will initialize some local variables before start the time stepping:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "Error = 1.0 # variable to keep track of error\n",
    "n = 0 # variable to advance in time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start time loop using while loop such that if one of the condition returns False, the time stepping will be stopped. For explanation of each line, see the comments. Please note the identation of the codes within the while loop. Take extra care with indentation as Python is very particular about it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   ITER           ERROR\n",
      "   ----           -----\n",
      "     10      4.92187500\n",
      "     20      3.52394104\n",
      "     30      2.88928896\n",
      "     40      2.50741375\n",
      "     50      2.24550338\n",
      "     60      2.05156084\n",
      "     70      1.90048503\n",
      "     80      1.77844060\n",
      "     90      1.67704721\n",
      "    100      1.59085792\n",
      "    110      1.51614304\n",
      "    120      1.45025226\n",
      "    130      1.39125374\n",
      "    140      1.33771501\n",
      "    150      1.28856146\n",
      "    160      1.24298016\n",
      "    170      1.20035213\n",
      "    180      1.16020337\n",
      "    190      1.12216882\n",
      "    200      1.08596559\n",
      "    210      1.05137298\n",
      "    220      1.01821734\n",
      "    230      0.98636083\n",
      "    240      0.95569280\n",
      "    250      0.92612336\n",
      "    260      0.89757851\n",
      "    270      0.86999638\n",
      "    280      0.84332454\n",
      "    290      0.81751777\n",
      "    300      0.79253655\n",
      "    310      0.76834575\n",
      "    320      0.74491380\n",
      "    330      0.72221190\n",
      "    340      0.70021355\n",
      "    350      0.67889409\n",
      "    360      0.65823042\n",
      "    370      0.63820074\n",
      "    380      0.61878436\n",
      "    390      0.59996158\n",
      "    400      0.58171354\n",
      "    410      0.56402217\n",
      "    420      0.54687008\n",
      "    430      0.53024053\n",
      "    440      0.51411737\n",
      "    450      0.49848501\n",
      "    460      0.48332837\n",
      "\n",
      "STATUS: SOLUTION OBTAINED AT\n",
      "TIME LEVEL= 1.08 s.\n",
      "TIME STEPS= 468\n",
      "\n",
      "Writing convergence log file: Completed.\n",
      "Files saved:\n",
      "\"D:/MyProjects/projectroot/nanpack/output/HISTftcs1D.dat\".\n"
     ]
    }
   ],
   "source": [
    "while n <= cfg.nMax and Error > cfg.ConvCrit: # start loop\n",
    "    Error = 0.0 # reset error to 0.0 at the beginning of each step\n",
    "    n += 1 # advance the value of n at each step\n",
    "    Uold = U.copy() # store solution at time level, n\n",
    "    U = FTCS(Uold, diffX) # solve for U using FTCS method at time level n+1\n",
    "    Error = post.AbsoluteError(U, Uold) # calculate errors\n",
    "    U = BC(U) # Update BC\n",
    "    post.MonitorConvergence(cfg, n, Error) # Use this function to monitor convergence\n",
    "    post.WriteSolutionToFile(U, n, cfg.nWrite, cfg.nMax,\\\n",
    "                             cfg.OutFileName, cfg.dX) # Write output to file\n",
    "    post.WriteConvHistToFile(cfg, n, Error) # Write convergence log to history file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above convergence monitor, it is worth noting that the solution error is gradually moving towards zero which is what we need to confirm stability in the solution. If the solution becomes unstable, the errors will rise, probably upto the point where your code will crash. As you know that the solution obtained is a time-dependent solution and therefore, we didn't allow the code to run until the convergence is observed. If a steady-state solution is desired, change the STATE key in the configuration file equals to \"STEADY\" and specify a much larger value of nMax key, say nMax = 5000. This is left as an exercise for the users to obtain a stead-state solution. Also, try running the solution with the larger grid step size, $\\Delta x$ or a larger time step size, $\\Delta t$.\n",
    "\n",
    "After the time stepping is completed, save the final results to the output files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write output to file\n",
    "post.WriteSolutionToFile(U, n, cfg.nWrite, cfg.nMax,\n",
    "                         cfg.OutFileName, cfg.dX)\n",
    "# Write convergence history log to a file\n",
    "post.WriteConvHistToFile(cfg, n, Error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verify that the files are saved in the target directory.\n",
    "Now let us obtain analytical solution of this flow that will help us in validating our codes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Obtain analytical solution\n",
    "Uana = ParallelPlateFlow(40.0, X, cfg.diff, cfg.totTime, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will validate our results by plotting the results using the matplotlib package that we have imported above. Type the following lines of codes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rc(\"font\", family=\"serif\", size=8) # Assign fonts in the plot\n",
    "fig, ax = plt.subplots(dpi=150) # Create axis for plotting\n",
    "plt.plot(U, X, \">-.b\", linewidth=0.5, label=\"FTCS\",\\\n",
    "         markersize=5, markevery=5) # Plot data with required labels and markers, customize the plot however you may like\n",
    "plt.plot(Uana, X, \"o:r\", linewidth=0.5, label=\"Analytical\",\\\n",
    "             markersize=5, markevery=5) # Plot analytical solution on the same plot\n",
    "plt.xlabel('Velocity (m/s)') # X-axis labelling\n",
    "plt.ylabel('Plate distance (m)') # Y-axis labelling\n",
    "plt.title(f\"Velocity profile\\nat t={cfg.totTime} sec\", fontsize=8) # Plot title\n",
    "plt.legend()\n",
    "plt.show() # Show plot- this command is very important"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for the boundary conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def BC(U):\n",
    "    \"\"\"Return the dependent variable with the updated values at the boundaries.\"\"\"\n",
    "    U[0] = 40.0\n",
    "    U[-1] = 0.0\n",
    "\n",
    "    return U"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations, you have completed the first coding tutoria using nanpack package and verified that your codes produced correct results. If you solve some other similar diffusion-1D model example, share it with the nanpack community. I will be excited to see your projects."
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}