Learning_FEM_1D_step2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "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 2\n",
    "\n",
    "In this Step, we develop a class for the MESH\n",
    "- we handle material property layout\n",
    "- mesh generation, including the use non-uniform meshes \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1caff238-ae73-4817-afef-b7cd93a5566f",
   "metadata": {},
   "source": [
    "## Class MESH "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cbe2825",
   "metadata": {},
   "source": [
    "### Assignment: Creating a 1D Mesh Class for Finite Element Method (FEM) Simulations\n",
    "\n",
    "#### Objective:\n",
    "In this assignment, you will create a Python class called `MESH` that is designed to generate a 1D mesh for use in a finite element method (FEM) simulation. The class will take inputs defining material regions and source distributions and will produce the mesh, assigning material and source IDs to each spatial cell. You will also implement logging to provide detailed output about the mesh generation process.\n",
    "\n",
    "#### Requirements:\n",
    "\n",
    "1. **Class Definition**:\n",
    "   - Create a class named `MESH` in Python.\n",
    "\n",
    "2. **Constructor (`__init__` method)**:\n",
    "   - The constructor should take the following parameters:\n",
    "     - `mat_layout`: A list of integers representing the material ID for each region.\n",
    "     - `src_layout`: A list of integers representing the source ID for each region.\n",
    "     - `width`: A list of floats representing the physical width of each region.\n",
    "     - `n_ref`: A list of integers representing the number of spatial cells to divide each region into (refinement level).\n",
    "     - `verbose`: A boolean flag (`True` or `False`) that controls the level of detail in the logging output. When `True`, the logger should output detailed debugging information.\n",
    "   - **Input Validation**:\n",
    "     - Ensure that `mat_layout`, `src_layout`, `width`, and `n_ref` are all lists of the same length. If they are not, raise a `ValueError` with an appropriate error message.\n",
    "   - **Attributes**:\n",
    "     - `self.n_zones`: The number of regions (derived from the length of `width`).\n",
    "     - `self.n_cells`: The total number of spatial cells (sum of `n_ref`).\n",
    "     - `self.dx`: A NumPy array containing the width of each spatial cell.\n",
    "     - `self.J`: A NumPy array containing half of the width of each spatial cell.\n",
    "     - `self.cell2mat`: A NumPy array mapping each cell ID to its corresponding material ID.\n",
    "     - `self.cell2src`: A NumPy array mapping each cell ID to its corresponding source ID.\n",
    "   - **Logging**:\n",
    "     - Implement logging within the class using Python’s `logging` module.\n",
    "     - Configure the logger to output messages at the `DEBUG` level if `verbose=True`, otherwise use the `INFO` level.\n",
    "     - Log the range of cell IDs associated with each material region during mesh creation.\n",
    "\n",
    "3. **Connectivity Method (`connectivity` method)**:\n",
    "   - Implement a method named `connectivity` within the `MESH` class.\n",
    "   - This method should create and assign a 2D NumPy array `self.gn` that maps each cell to its left and right neighbors.\n",
    "   - Each row in `self.gn` should contain two integers: the current cell index and the next cell index.\n",
    "   - Log the connectivity information for each cell using the logger.\n",
    "\n",
    "4. **Additional Specifications**:\n",
    "   - Ensure the class handles edge cases such as the first and last cells in the mesh correctly.\n",
    "   - Use `numpy` for array operations.\n",
    "   - Do not allow any cell indices to go out of bounds during connectivity generation.\n",
    "\n",
    "5. **Testing the Class**:\n",
    "   - After implementing the `MESH` class, create a test case with the following inputs:\n",
    "     ```python\n",
    "     mat_layout = [1, 2, 3]\n",
    "     src_layout = [4, 5, 6]\n",
    "     width = [10.0, 20.0, 15.0]\n",
    "     n_ref = [5, 10, 7]\n",
    "     ```\n",
    "   - Instantiate the `MESH` class with `verbose=True`.\n",
    "   - Ensure that the log outputs include details about the range of cells for each material and the connectivity information for each cell.\n",
    "\n",
    "6. **Submission**:\n",
    "   - Submit the Python file containing the `MESH` class definition.\n",
    "   - Include a short report (1-2 pages) explaining your implementation, the purpose of each method, and how logging is handled.\n",
    "   - Provide screenshots or log outputs demonstrating that the class behaves as expected with the provided test case.\n",
    "\n",
    "#### Grading Criteria:\n",
    "- **Correctness** (40%): Does the class correctly generate the mesh and connectivity based on the inputs?\n",
    "- **Code Quality** (30%): Is the code well-organized, with clear naming conventions, comments, and appropriate use of logging?\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",
    "- Make sure to test your class with different values of `mat_layout`, `src_layout`, `width`, and `n_ref` to ensure it handles various scenarios correctly.\n",
    "- Think carefully about the structure of your connectivity matrix, especially how it will be used later in FEM simulations.\n",
    "- Use the logging output to help debug and verify that each part of the mesh generation process is functioning as expected.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66012faf",
   "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": "code",
   "execution_count": 5,
   "id": "3f13fc5b",
   "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": "code",
   "execution_count": 6,
   "id": "1fe12513",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-08-14 13:41:41,942 - __main__ - DEBUG - MESH::range for current material: 0 to 5\n",
      "2024-08-14 13:41:41,942 - __main__ - DEBUG - MESH::range for current material: 5 to 15\n"
     ]
    }
   ],
   "source": [
    "mesh = MESH(mat_layout=[0, 1], src_layout=[3, 4], width=[10, 20], n_ref=[5, 10], verbose=True)\n"
   ]
  }
 ],
 "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
}