Learning_FEM_1D_step3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ae3723a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time as time\n",
    "\n",
    "from scipy import sparse\n",
    "from scipy.sparse import linalg\n",
    "\n",
    "from matplotlib import cm\n",
    "from matplotlib.ticker import LinearLocator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4393e128",
   "metadata": {},
   "source": [
    "# Learning the Finite Element Method. Step 3\n",
    "\n",
    "In this Step, we continue using **classes**.\n",
    "- we discuss additional boundary conditions (namely, Neumann BC and Robin BC in addition to the Dirichlet BC we have been using so far)\n",
    "- we code an FEM class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86b0e870",
   "metadata": {},
   "source": [
    "# Boundary Conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd307547",
   "metadata": {},
   "source": [
    "### Boundary Conditions in 1D Finite Element Method (FEM) Codes: Dirichlet, Neumann, and Robin\n",
    "\n",
    "Boundary conditions are essential in solving differential equations, as they define the behavior of the solution at the boundaries of the domain. In the context of the 1D Finite Element Method (FEM), boundary conditions are used to specify how the solution behaves at the edges of the domain (e.g., at \\(x = 0\\) and \\(x = L\\), where \\(L\\) is the length of the domain). The three most common types of boundary conditions are Dirichlet, Neumann, and Robin. Below is a detailed explanation of each type.\n",
    "\n",
    "#### 1. **Dirichlet Boundary Conditions**\n",
    "\n",
    "Dirichlet boundary conditions specify the value of the solution directly at the boundary. In mathematical terms, if \\( u(x) \\) is the solution to the differential equation, a Dirichlet boundary condition at \\( x = 0 \\) would be of the form:\n",
    "\n",
    "\\[ u(0) = u_0 \\]\n",
    "\n",
    "where \\( u_0 \\) is a known constant.\n",
    "\n",
    "**Example Application in 1D FEM:**\n",
    "In a 1D FEM code, applying a Dirichlet boundary condition means directly setting the value of the solution vector at the boundary node to the specified value. For instance, if your domain is divided into finite elements with nodes at \\( x = 0 \\) and \\( x = L \\), you would enforce the Dirichlet condition by modifying the global stiffness matrix and load vector to ensure that the solution at the boundary node equals \\( u_0 \\).\n",
    "\n",
    "**Implementation Tip:**\n",
    "In practice, this might involve setting the corresponding row in the stiffness matrix to zero (except for the diagonal element) and setting the load vector entry to the value \\( u_0 \\). The stiffness matrix entry at the boundary node's diagonal would typically be set to 1 to maintain matrix stability.\n",
    "\n",
    "#### 2. **Neumann Boundary Conditions**\n",
    "\n",
    "Neumann boundary conditions specify the value of the derivative (flux) of the solution at the boundary. For example, a Neumann boundary condition at \\( x = 0 \\) might be expressed as:\n",
    "\n",
    "\\[ \\frac{du}{dx}\\bigg|_{x=0} = q_0 \\]\n",
    "\n",
    "where \\( q_0 \\) is a known constant flux.\n",
    "\n",
    "**Example Application in 1D FEM:**\n",
    "In 1D FEM, Neumann boundary conditions are applied by adjusting the load vector. The specified flux \\( q_0 \\) is added directly to the load vector entry corresponding to the boundary node. This reflects the influence of the boundary condition on the overall solution.\n",
    "\n",
    "**Implementation Tip:**\n",
    "To implement a Neumann boundary condition, simply modify the load vector entry at the boundary node to include the contribution from the boundary flux. The stiffness matrix remains unchanged.\n",
    "\n",
    "#### 3. **Robin Boundary Conditions**\n",
    "\n",
    "Robin boundary conditions are a combination of Dirichlet and Neumann boundary conditions. They specify a linear combination of the solution and its derivative at the boundary. The general form of a Robin boundary condition at \\( x = 0 \\) is:\n",
    "\n",
    "\\[ \\alpha u(0) + \\beta \\frac{du}{dx}\\bigg|_{x=0} = \\gamma \\]\n",
    "\n",
    "where \\( \\alpha \\), \\( \\beta \\), and \\( \\gamma \\) are known constants.\n",
    "\n",
    "**Example Application in 1D FEM:**\n",
    "In 1D FEM, Robin boundary conditions require modifying both the stiffness matrix and the load vector. The boundary condition introduces additional terms that couple the solution and its derivative, and these must be incorporated into the global system of equations.\n",
    "\n",
    "**Implementation Tip:**\n",
    "To implement a Robin boundary condition:\n",
    "- Adjust the stiffness matrix at the boundary node by adding a term proportional to \\( \\alpha \\).\n",
    "- Modify the load vector entry by adding a term proportional to \\( \\gamma \\) and possibly \\( \\beta \\) depending on the discretization scheme.\n",
    "\n",
    "### Summary\n",
    "\n",
    "In summary, each type of boundary condition in 1D FEM—Dirichlet, Neumann, and Robin—has a specific role in defining the behavior of the solution at the domain boundaries:\n",
    "\n",
    "- **Dirichlet:** Directly sets the solution value at the boundary.\n",
    "- **Neumann:** Specifies the derivative (flux) of the solution at the boundary.\n",
    "- **Robin:** Combines both the solution value and its derivative at the boundary.\n",
    "\n",
    "Correctly implementing these boundary conditions is crucial for ensuring the accuracy and stability of the FEM solution. Understanding how to apply them in a 1D FEM code lays the groundwork for extending these concepts to more complex problems and higher dimensions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06494061",
   "metadata": {},
   "source": [
    "# class for FEM solver"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f6ad31",
   "metadata": {},
   "source": [
    "### Assignment: Implementing a 1D Finite Element Method (FEM) Solver\n",
    "\n",
    "#### Objective:\n",
    "In this assignment, you will develop a Python class called `FEM_solver` that implements the Finite Element Method (FEM) for solving 1D partial differential equations (PDEs). The class will be capable of generating elemental matrices, assembling the global system, applying various boundary conditions, and solving the system of equations. You will also implement methods to ensure the class handles different types of boundary conditions, such as Dirichlet, Neumann, and Robin.\n",
    "\n",
    "#### Requirements:\n",
    "\n",
    "1. **Class Definition**:\n",
    "   - Create a Python class named `FEM_solver`.\n",
    "\n",
    "2. **Constructor (`__init__` method)**:\n",
    "   - The constructor should take the following parameters:\n",
    "     - `degree`: An integer specifying the degree of the quadrature for numerical integration. Default is 3.\n",
    "     - `verbose`: A boolean flag (`True` or `False`) that controls the verbosity of the output. When `True`, additional information about the matrices and vectors should be printed.\n",
    "   - Inside the constructor:\n",
    "     - Initialize the basis functions and their derivatives using the `basis()` method.\n",
    "     - Compute the elemental matrices by calling the `compute_elemental_matrices(degree)` method.\n",
    "\n",
    "3. **Basis Functions (`basis` method)**:\n",
    "   - Implement a method named `basis` that defines:\n",
    "     - `self.b`: A list of lambda functions representing the basis functions over the reference element \\([-1, 1]\\).\n",
    "     - `self.dbdx`: A list of lambda functions representing the derivatives of the basis functions with respect to the spatial coordinate.\n",
    "\n",
    "4. **Elemental Matrices (`compute_elemental_matrices` method)**:\n",
    "   - Implement a method named `compute_elemental_matrices(degree)` that:\n",
    "     - Uses Gauss-Legendre quadrature of the specified `degree` to integrate the basis functions and their derivatives.\n",
    "     - Computes the elemental stiffness matrix `self.Kxx`, the mass matrix `self.M`, and the load vector `self.Q`.\n",
    "     - If `verbose` is `True`, prints the matrices and vector for debugging purposes.\n",
    "\n",
    "5. **System Assembly (`assemble_system` method)**:\n",
    "   - Implement a method named `assemble_system(mesh, prop, bc)` that:\n",
    "     - Assembles the global stiffness matrix `A` and the global load vector `rhs` based on the properties of the mesh and materials.\n",
    "     - Applies material properties and source terms from the `prop` dictionary.\n",
    "     - Calls the `apply_boundary_conditions(A, rhs, bc, n_nodes)` method to apply boundary conditions.\n",
    "     - Returns the assembled global stiffness matrix `A` and load vector `rhs`.\n",
    "\n",
    "6. **Boundary Conditions (`apply_boundary_conditions` method)**:\n",
    "   - Implement a method named `apply_boundary_conditions(A, rhs, bc, n_nodes)` that:\n",
    "     - Applies Dirichlet, Neumann, and Robin boundary conditions as specified in the `bc` dictionary.\n",
    "     - Modifies `A` and `rhs` in place according to the boundary conditions.\n",
    "     - Returns the modified `A` and `rhs`.\n",
    "\n",
    "7. **System Solver (`solve_system` method)**:\n",
    "   - Implement a method named `solve_system(A, b)` that:\n",
    "     - Solves the linear system \\(Ax = b\\) using a sparse solver and returns the solution vector.\n",
    "\n",
    "8. **Testing the Class**:\n",
    "   - After implementing the `FEM_solver` class, create a test case with a simple mesh and material properties.\n",
    "   - Define boundary conditions (Dirichlet, Neumann, and Robin) and verify that the class handles them correctly.\n",
    "   - Use the `verbose=True` flag to check the output of the elemental matrices and the assembled system.\n",
    "\n",
    "9. **Submission**:\n",
    "   - Submit the Python file containing the `FEM_solver` class definition.\n",
    "   - Include a short report (1-2 pages) explaining your implementation, the purpose of each method, and how boundary conditions are handled.\n",
    "   - Provide examples of the test cases you used and their results.\n",
    "\n",
    "#### Grading Criteria:\n",
    "- **Correctness** (40%): Does the class correctly implement the FEM and handle the various boundary conditions?\n",
    "- **Code Quality** (30%): Is the code well-organized, with clear naming conventions, comments, and appropriate use of functions?\n",
    "- **Error Handling** (10%): Does the code appropriately handle invalid inputs and edge cases?\n",
    "- **Documentation and Reporting** (20%): Is the class well-documented with meaningful docstrings? Does the report clearly explain the design and functionality?\n",
    "\n",
    "---\n",
    "\n",
    "### Tips:\n",
    "- Pay close attention to the application of boundary conditions, as this is crucial for the correct behavior of the FEM solver.\n",
    "- Test your class thoroughly with different configurations to ensure it handles various scenarios as expected.\n",
    "- Use the `verbose` option to debug and verify the internal calculations of the class.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ccc4e28",
   "metadata": {},
   "source": [
    "## Implement this yourself\n",
    "\n",
    "## The answer is below but only look at it after genuinely trying to do it yourself"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dbc12cf",
   "metadata": {},
   "source": [
    "# FEM class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5ebbe6a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FEM_solver:\n",
    "    def __init__(self, degree=3, verbose=False):\n",
    "        self.verbose = verbose\n",
    "        \n",
    "        # Compute the cFEM basis functions\n",
    "        self.basis()\n",
    "        \n",
    "        # Compute the elemental matrices\n",
    "        self.compute_elemental_matrices(degree)\n",
    "\n",
    "    \n",
    "    \n",
    "    def basis(self):\n",
    "        \"\"\"Defines the basis functions and their derivatives for the FEM.\"\"\"\n",
    "        self.b = [\n",
    "            lambda u: (1 - u) / 2,  # First basis function\n",
    "            lambda u: (1 + u) / 2   # Second basis function\n",
    "        ]\n",
    "        \n",
    "        self.dbdx = [\n",
    "            lambda u: -0.5,  # Derivative of the first basis function\n",
    "            lambda u: 0.5    # Derivative of the second basis function\n",
    "        ]        \n",
    "        \n",
    "    def compute_elemental_matrices(self, degree):\n",
    "        \"\"\"Computes the elemental matrices for the FEM based on the provided degree.\"\"\"\n",
    "        # Select spatial quadrature\n",
    "        [x_,w_] = np.polynomial.legendre.leggauss(degree)\n",
    "\n",
    "        # Initialize local matrices\n",
    "        local_dofs = len(self.b)\n",
    "        self.Kxx = np.zeros((local_dofs,local_dofs))\n",
    "        self.M   = np.zeros((local_dofs,local_dofs))\n",
    "        self.Q   = np.zeros(local_dofs)\n",
    "\n",
    "        # Compute matrices using quadrature points\n",
    "        for (uq,wuq) in zip(x_,w_):\n",
    "            for i,(fi,fxi) in enumerate(zip(self.b,self.dbdx)):\n",
    "                self.Q[i]   += wuq * fi(uq)\n",
    "                for j,(fj,fxj) in enumerate(zip(self.b,self.dbdx)):\n",
    "                    self.M[i,j]   += wuq * fi (uq) * fj (uq)\n",
    "                    self.Kxx[i,j] += wuq * fxi(uq) * fxj(uq)\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"Stiffness Matrix (Kxx):\\n\", self.Kxx)\n",
    "            print(\"Mass Matrix (M):\\n\", self.M)\n",
    "            print(\"Load Vector (Q):\\n\", self.Q)\n",
    "            \n",
    "\n",
    "    def assemble_system(self, mesh, prop, bc):\n",
    "        \"\"\"Assembles the global FEM system including stiffness matrix and load vector.\"\"\"\n",
    "        # Sanity check on boundary conditions\n",
    "        if len(bc) !=2:\n",
    "            raise ValueError('bc dictionary must have 2 keys')\n",
    "                \n",
    "        # Initialize global stiffness matrix and load vector\n",
    "        n_nodes = mesh.n_cells + 1\n",
    "        A = sparse.lil_matrix((n_nodes,n_nodes))\n",
    "        # rhs\n",
    "        rhs = np.zeros(n_nodes)\n",
    "\n",
    "        # Loop over elements to assemble the global system\n",
    "        for iel in range(mesh.n_cells):\n",
    "            mat_id = mesh.cell2mat[iel]\n",
    "            src_id = mesh.cell2src[iel]\n",
    "            src_prop = prop['src'][src_id]\n",
    "            difc = prop['D'][mat_id]\n",
    "            siga = prop['siga'][mat_id]\n",
    "            \n",
    "            for i,glob_i in enumerate(mesh.gn[iel,:]):\n",
    "                rhs[glob_i] += src_prop * mesh.J[iel] * self.Q[i]\n",
    "                \n",
    "                for j,glob_j in enumerate(mesh.gn[iel,:]):\n",
    "                    A[glob_i,glob_j] += difc * 1/mesh.J[iel] * self.Kxx[i,j] \\\n",
    "                                        + siga * mesh.J[iel] * self.M[i,j]\n",
    "\n",
    "        # Apply boundary conditions\n",
    "        self.apply_boundary_conditions(A, rhs, bc, n_nodes)\n",
    "\n",
    "        return A, rhs\n",
    "    \n",
    "\n",
    "    def apply_boundary_conditions(self, A, rhs, bc, n_nodes):\n",
    "        \"\"\"Applies the Dirichlet, Neumann, and Robin boundary conditions.\"\"\"\n",
    "        dir_nodes = []\n",
    "        u_dir = []\n",
    "\n",
    "        # Apply Dirichlet conditions\n",
    "        if bc['xmin']['type'] == 'dirichlet':\n",
    "            dir_nodes.append(0)\n",
    "            u_dir.append(bc['xmin']['value'])\n",
    "        if bc['xmax']['type'] == 'dirichlet':\n",
    "            dir_nodes.append(n_nodes - 1)\n",
    "            u_dir.append(bc['xmax']['value'])\n",
    "\n",
    "        dir_nodes = np.asarray(dir_nodes)\n",
    "        \n",
    "        for i, inode in enumerate(dir_nodes):\n",
    "            A[inode, :] = 0.\n",
    "            A[inode, inode] = 1.\n",
    "            rhs[inode] = u_dir[i]\n",
    "\n",
    "        # Apply Robin conditions\n",
    "        if bc['xmin']['type'] == 'robin':\n",
    "            A[0, 0] += 0.5\n",
    "            rhs[0] += 2 * bc['xmin']['value']\n",
    "        if bc['xmax']['type'] == 'robin':\n",
    "            A[-1, -1] += 0.5\n",
    "            rhs[-1] += 2 * bc['xmax']['value']\n",
    "\n",
    "        # Apply Neumann conditions\n",
    "        if bc['xmin']['type'] == 'neumann':\n",
    "            rhs[0] += bc['xmin']['value']\n",
    "        if bc['xmax']['type'] == 'neumann':\n",
    "            rhs[-1] += bc['xmax']['value']\n",
    "\n",
    "        return A, rhs\n",
    "   \n",
    "    def solve_system(self, A, b):\n",
    "        \"\"\"Solves the linear system Ax = b using sparse matrix solver.\"\"\"\n",
    "        solution = linalg.spsolve(A.tocsc(), b)\n",
    "\n",
    "        return solution   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cac66823",
   "metadata": {},
   "source": [
    "## Class MESH (copied from Step-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4edff80e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "\n",
    "class MESH:\n",
    "    def __init__(self, mat_layout, src_layout, width, n_ref, verbose=False):\n",
    "        # Create a logger\n",
    "        self.logger = logging.getLogger(__name__)\n",
    "        \n",
    "        # Set the logging level based on the verbose flag\n",
    "        if verbose:\n",
    "            self.logger.setLevel(logging.DEBUG)\n",
    "        else:\n",
    "            self.logger.setLevel(logging.INFO)\n",
    "        \n",
    "        # Ensure we have a StreamHandler to output logs in Jupyter\n",
    "        if not self.logger.hasHandlers():\n",
    "            handler = logging.StreamHandler()\n",
    "            handler.setLevel(logging.DEBUG if verbose else logging.INFO)\n",
    "            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n",
    "            handler.setFormatter(formatter)\n",
    "            self.logger.addHandler(handler)\n",
    "        \n",
    "        if len(mat_layout) != len(src_layout):\n",
    "            raise ValueError(\"MESH::mat_layout and src_layout must be of the same length\")\n",
    "        if len(mat_layout) != len(width):\n",
    "            raise ValueError(\"MESH::mat_layout and width must be of the same length\")\n",
    "        if len(width) != len(n_ref):\n",
    "            raise ValueError(\"MESH::width and nref must be of the same length\")\n",
    "            \n",
    "        # Number of materials and cells\n",
    "        self.n_zones = len(width)\n",
    "        self.n_cells = np.sum(n_ref)\n",
    "\n",
    "        # Initialize arrays: cell width\n",
    "        dx = np.zeros(self.n_cells)\n",
    "        # Initialize arrays: mapping from cell ID to material/src ID\n",
    "        cell2mat = np.zeros(self.n_cells, dtype=int)\n",
    "        cell2src = np.zeros(self.n_cells, dtype=int)\n",
    "\n",
    "        ibeg = 0\n",
    "        for m in range(self.n_zones):\n",
    "            # create cellID to matID mapping\n",
    "            iend = ibeg + n_ref[m]\n",
    "#             if verbose:\n",
    "#                 print(\"MESH::range for current material:\", ibeg, iend)\n",
    "            self.logger.debug(f\"MESH::range for current material: {ibeg} to {iend}\")\n",
    "            dx[ibeg:iend] = width[m] / n_ref[m]\n",
    "            cell2mat[ibeg:iend] = mat_layout[m]\n",
    "            cell2src[ibeg:iend] = src_layout[m]\n",
    "            ibeg = iend\n",
    "        \n",
    "        # Store arrays in the object\n",
    "        self.dx = np.copy(dx)\n",
    "        self.J = np.copy(dx)/2. # Jacobian of the mapping, in 1D = Half-cell widths for FEM\n",
    "        self.cell2mat = np.copy(cell2mat)\n",
    "        self.cell2src = np.copy(cell2src)\n",
    "\n",
    "        # Generate connectivity\n",
    "        self.connectivity()\n",
    "\n",
    "    \n",
    "    def connectivity(self):\n",
    "        \"\"\"Generate the connectivity matrix for a 1D mesh.\"\"\"\n",
    "        # gn is the global numbering. \n",
    "        # another (longer) name for gn would be connectivity_matrix\n",
    "        self.gn = np.zeros((self.n_cells,2),dtype=int)\n",
    "\n",
    "        iel = 0\n",
    "        for i in range(self.n_cells):\n",
    "            # Connect each cell left to right\n",
    "            self.gn[iel,0] = iel\n",
    "            self.gn[iel,1] = iel+1\n",
    "\n",
    "            iel += 1    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ed07c4",
   "metadata": {},
   "source": [
    "# Example-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "522d977c-4def-40d8-8351-262e20f24243",
   "metadata": {},
   "outputs": [],
   "source": [
    "D = np.array([2.,1.])\n",
    "sigma = np.array([0.2,1.])\n",
    "q = np.array([0.,10.])\n",
    "\n",
    "prop = {}\n",
    "prop['src']  = q\n",
    "prop['D']    = D\n",
    "prop['siga'] = sigma\n",
    "\n",
    "bc = {}\n",
    "bc['xmin']={'type':'dirichlet','value':2.}\n",
    "bc['xmax']={'type':'dirichlet','value':5.}\n",
    "\n",
    "\n",
    "# pick 10 regions\n",
    "imat_geo = [0, 0, 0, 1, 0, 1, 0, 1, 0, 0]\n",
    "\n",
    "np.random.seed(123456)\n",
    "r = np.random.random(10)\n",
    "widths = 1. + 0.*r\n",
    "# print(widths)\n",
    "\n",
    "nrefs_coarse =  3*np.ones(len(imat_geo),dtype=int)\n",
    "nrefs_fine   = 30*np.ones(len(imat_geo),dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8b907094-4649-4e62-88fd-e7440488fd72",
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh_coarse = MESH(imat_geo, imat_geo, widths, nrefs_coarse)\n",
    "mesh_fine   = MESH(imat_geo, imat_geo, widths, nrefs_fine  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "da1c48b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create solver object\n",
    "solver = FEM_solver()\n",
    "\n",
    "# solve\n",
    "A_coarse,b_coarse = solver.assemble_system(mesh_coarse,prop,bc)\n",
    "solution_coarse = solver.solve_system(A_coarse,b_coarse)\n",
    "\n",
    "# solve\n",
    "A_fine,b_fine = solver.assemble_system(mesh_fine,prop,bc)\n",
    "solution_fine = solver.solve_system(A_fine, b_fine)\n",
    "\n",
    "# plots\n",
    "x_coarse = np.cumsum(mesh_coarse.dx); x_coarse = np.insert(x_coarse,0,0.)\n",
    "x_fine = np.cumsum(mesh_fine.dx); x_fine = np.insert(x_fine,0,0.)\n",
    "\n",
    "fig, axs = plt.subplots(1,2,figsize=(10,4))\n",
    "\n",
    "axs[0].plot(x_coarse,solution_coarse, label='num.coarse')\n",
    "axs[0].plot(x_fine  ,solution_fine  , label='num.fine')\n",
    "axs[0].grid(True)\n",
    "axs[0].legend()\n",
    "axs[0].set_xlabel('x')\n",
    "axs[0].set_title('simple problem')\n",
    "\n",
    "# zoom\n",
    "axs[1].plot(x_coarse,solution_coarse, label='num.coarse')\n",
    "axs[1].plot(x_fine  ,solution_fine  , label='num.fine')\n",
    "axs[1].grid(True)\n",
    "axs[1].legend()\n",
    "axs[1].set_xlabel('x')\n",
    "axs[1].set_title('simple problem (zoom)')\n",
    "axs[1].set_xlim([3.5,8.2])\n",
    "axs[1].set_ylim([6.7,7.8])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5e712a2-ceaf-4066-b0f9-fb73fdab613c",
   "metadata": {},
   "source": [
    "# Example-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e2588c70-4c07-46eb-8c8e-c25886715d54",
   "metadata": {},
   "outputs": [],
   "source": [
    "D = np.array([2.])\n",
    "sigma = np.array([0.])\n",
    "q = np.array([0.])\n",
    "\n",
    "prop = {}\n",
    "prop['src']  = q\n",
    "prop['D']    = D\n",
    "prop['siga'] = sigma\n",
    "\n",
    "bc = {}\n",
    "bc['xmin']={'type':'robin','value':1.}\n",
    "bc['xmax']={'type':'robin','value':0.}\n",
    "\n",
    "\n",
    "# pick 1 region\n",
    "imat_geo = [0]\n",
    "\n",
    "widths = np.array([10.])\n",
    "\n",
    "nrefs_coarse =  3*np.ones(len(imat_geo),dtype=int)\n",
    "nrefs_fine   = 30*np.ones(len(imat_geo),dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "86b7f0ea-cae4-46c3-a9ae-ddc8586cc832",
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh_coarse = MESH(imat_geo, imat_geo, widths, nrefs_coarse)\n",
    "mesh_fine   = MESH(imat_geo, imat_geo, widths, nrefs_fine  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f1b62a29-7fe5-4119-adb3-c9d2b778e494",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create solver object\n",
    "solver = FEM_solver()\n",
    "\n",
    "# solve\n",
    "A_coarse,b_coarse = solver.assemble_system(mesh_coarse,prop,bc)\n",
    "solution_coarse = solver.solve_system(A_coarse,b_coarse)\n",
    "\n",
    "# solve\n",
    "A_fine,b_fine = solver.assemble_system(mesh_fine,prop,bc)\n",
    "solution_fine = solver.solve_system(A_fine, b_fine)\n",
    "\n",
    "# plots\n",
    "x_coarse = np.cumsum(mesh_coarse.dx); x_coarse = np.insert(x_coarse,0,0.)\n",
    "x_fine = np.cumsum(mesh_fine.dx); x_fine = np.insert(x_fine,0,0.)\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x_coarse,solution_coarse, label='num.coarse')\n",
    "plt.plot(x_fine  ,solution_fine  , label='num.fine')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.xlabel('x')\n",
    "plt.title('pure scatterer problem')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b7f9b8-86b4-4615-a855-ce4fd0265f08",
   "metadata": {},
   "source": [
    "# Example-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c7a90014-385b-4523-9177-77a5a7af67e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "D = np.array([2.])\n",
    "sigma = np.array([0.1])\n",
    "q = np.array([1.])\n",
    "\n",
    "prop = {}\n",
    "prop['src']  = q\n",
    "prop['D']    = D\n",
    "prop['siga'] = sigma\n",
    "\n",
    "bc = {}\n",
    "bc['xmin']={'type':'neumann','value':-1.}\n",
    "bc['xmax']={'type':'neumann','value':0.}\n",
    "\n",
    "\n",
    "# pick 1 region\n",
    "imat_geo = [0]\n",
    "\n",
    "widths = np.array([10.])\n",
    "\n",
    "nrefs_coarse =  5*np.ones(len(imat_geo),dtype=int)\n",
    "nrefs_fine   = 50*np.ones(len(imat_geo),dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7dfbda73-ca4c-4d1a-be51-832cb78ba01b",
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh_coarse = MESH(imat_geo, imat_geo, widths, nrefs_coarse)\n",
    "mesh_fine   = MESH(imat_geo, imat_geo, widths, nrefs_fine  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cafa4ca6-4df4-428f-bfa2-97536340c6a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create solver object\n",
    "solver = FEM_solver()\n",
    "\n",
    "# solve\n",
    "A_coarse,b_coarse = solver.assemble_system(mesh_coarse,prop,bc)\n",
    "solution_coarse = solver.solve_system(A_coarse,b_coarse)\n",
    "\n",
    "# solve\n",
    "A_fine,b_fine = solver.assemble_system(mesh_fine,prop,bc)\n",
    "solution_fine = solver.solve_system(A_fine, b_fine)\n",
    "\n",
    "# plots\n",
    "x_coarse = np.cumsum(mesh_coarse.dx); x_coarse = np.insert(x_coarse,0,0.)\n",
    "x_fine = np.cumsum(mesh_fine.dx); x_fine = np.insert(x_fine,0,0.)\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x_coarse,solution_coarse, label='num.coarse')\n",
    "plt.plot(x_fine  ,solution_fine  , label='num.fine')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.xlabel('x')\n",
    "plt.title('example-3')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}