lab-sessions/6-lab-session.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EE4375: Sixth Lab Session: Galerkin Finite Element Method for the Poisson Equation on the Unit Square "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **goals** of this sixth lab session of the [EE4375 Course](https://github.com/ziolai/finite_element_electrical_engineering/tree/main) are three-fold. \n",
    "\n",
    "The **first** goal is to implement a Galerkin finite element method using linear Lagrange shape functions to solve the two-dimensional Poisson equation $- \\bigtriangleup u = f$ on the unit square domain $\\Omega=(0,1)^2$ supplied with homogeneous Dirichlet boundary conditions $u = 0$ on $\\Gamma = \\partial \\Omega$. For illustration purposes, the unit square is employed as computational domain. The boundary value problem we intend to solver in this lab session is exactly the same as the boundary value problem we already solved in the third lab session. The extension to non-homogeneous Dirichlet or Neumann boundary conditions is left as an exercise. The assembly and the solve of the linear system will be explored. In the assembly process, a contribution per element to the matrix and right-hand side vector and a loop over elements is employed. The term element here refers to the triangle that is formed by three nodes of the mesh. Similarly to previous lab sessions, a sparse direct solver is employed to solve the resulting linear system. Unlike in the third lab session, non-uniform meshes can be employed. \n",
    "\n",
    "The **second** goal is to compare the numerical solution obtained with a two-dimensional analytical reference solution. The same reference solutions as in the third lab session can be used. \n",
    "\n",
    "The **third** goal is apply the two-dimensional finite element method to a coil-core-air configuration. Unlike in the third lab session, the mesh can be refined in regions of the computational domain with large variations in the solution.\n",
    "\n",
    "This lab session complements the lecture slides available at [EE4375 GitHub Directory](https://github.com/ziolai/finite_element_electrical_engineering/tree/main/slides).\n",
    "\n",
    "<b>Exercises</b> (details still to be supplied)\n",
    "1. extend testing of assembly and solve stage; "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "try\n",
    "    using Gmsh: gmsh\n",
    "catch\n",
    "    using gmsh\n",
    "end \n",
    "\n",
    "using LinearAlgebra \n",
    "using SparseArrays \n",
    "using StaticArrays\n",
    "using StaticRanges\n",
    "\n",
    "using BenchmarkTools\n",
    "\n",
    "using Test \n",
    "\n",
    "using Plots \n",
    "using GR "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a point in 2D is a tuple of 2 coordinates \n",
    "const Point2D = SVector{2,Float64};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 1: Struct and Auxilary Function Definitions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# struct to hold a single mesh element\n",
    "# compared to 4-lab-session, we extend a line segment to a triangle \n",
    "struct Element\n",
    "  p1::Point2D                   # coordinates first node \n",
    "  p2::Point2D                   # coordinates second node \n",
    "  p3::Point2D                   # coordinates third node     \n",
    "  e1::Int64                     # global index first node\n",
    "  e2::Int64                     # global index second node\n",
    "  e3::Int64                     # global index third node\n",
    "  Emat::MMatrix{3,3,Float64, 9} # matrix of basis function coefficients \n",
    "  area::Float64                 # area of the element \n",
    "end\n",
    "\n",
    "# struct to hold entire mesh\n",
    "struct Mesh\n",
    "  nnodes::Int64               # number of nodes \n",
    "  nelems::Int64               # number of elements\n",
    "  Elements::Array{Element,1}  # list of Elements \n",
    "  bndNodeIds::Vector{Int64}   # indices of nodes where Dirichlet bc are applied  \n",
    "  dofPerElem::Int64           # number of dofs per element \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "localElement (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# compute the area of the triangle with vertices p1, p2 and p3\n",
    "function localElement(p1,p2,p3) \n",
    "    p12  = p2 - p1\n",
    "    p13  = p3 - p1\n",
    "    area = .5*abs(cross(p12,p13))  \n",
    "    Xmat = SMatrix{3,3,Float64, 9}(p1[1], p2[1], p3[1], p1[2], p2[2], p3[2], 1, 1, 1) \n",
    "    rhs  = SMatrix{3,3,Float64, 9}(1I) \n",
    "    Emat = SMatrix{3,3,Float64, 9}(Xmat\\rhs);\n",
    "    return Emat, area\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>To do</b> Properly document the values that follow, in particular for refEmat. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define data on the reference element and the 5node mesh \n",
    "# for later use in this notebook \n",
    "refElemArea = 0.5\n",
    "refElemp1   = Point2D(0.,0.); \n",
    "refElemp2   = Point2D(1.,0.); \n",
    "refElemp3   = Point2D(0.,1.);\n",
    "refEmat     = SMatrix{3,3}(-1., -1., 0., 1., 0., 0., 0., 1.,0.)\n",
    "refElem     = Element(refElemp1, refElemp2, refElemp3, 1, 2, 3, refEmat, refElemArea)\n",
    "refElemAloc = refElemArea * [2., -1., -1., -1., 1., 0., -1., 0., 1.]\n",
    "refElemMloc = refElemArea/3 * SMatrix{3,3}(1I)\n",
    "testA5node  = sparse([1. 0. 0. 0. -1; 0. 1. 0. 0. -1.; 0. 0. 1. 0. -1.; 0. 0. 0. 1. -1.; -1. -1. -1. -1. 4.])\n",
    "testM5node  = refElemArea/3 * [1. 0. 0. 0. 0.; 0. 1. 0. 0. 0.; 0. 0. 1. 0. 0.; 0. 0. 0. 1. 0.; 0. 0. 0. 0. 2.];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@test localElement(refElemp1,refElemp2,refElemp3)[2] == refElemArea\n",
    "# @code_warntype area_triangle(p1,p2,p3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 2: Read Mesh From File and Store Mesh in Struct  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nodesFromGmsh (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# read elements from mesh file \n",
    "function meshFromGmsh(meshFile)    \n",
    "    \n",
    "    #..Initialize GMSH\n",
    "    gmsh.initialize()\n",
    "    \n",
    "    #..Read mesh from file\n",
    "    gmsh.open(meshFile)\n",
    "\n",
    "    #..Get the mesh nodes\n",
    "    #..Observe that although the mesh is two-dimensional,\n",
    "    #..the z-coordinate that is equal to zero is stored as well.\n",
    "    #..Observe that the coordinates are stored contiguously for computational efficiency\n",
    "    node_ids, node_coord, _ = gmsh.model.mesh.getNodes()\n",
    "    nnodes = length(node_ids)\n",
    "    #..sort the node coordinates by ID, such that Node one sits at row 1\n",
    "    tosort = [node_ids node_coord[1:3:end] node_coord[2:3:end]];\n",
    "    sorted = sortslices(tosort , dims = 1);\n",
    "    node_ids = sorted[:,1]\n",
    "    xnode = sorted[:,2]\n",
    "    ynode = sorted[:,3]\n",
    "\n",
    "    #..Get the mesh elements\n",
    "    #..Observe that we get all the two-dimensional triangular elements from the mesh\n",
    "    element_types, element_ids, element_connectivity = gmsh.model.mesh.getElements(2)\n",
    "    nelems = length(element_ids[1])\n",
    "      \n",
    "    #..Construct uninitialized array of length nelements  \n",
    "    Elements = Array{Element}(undef,nelems)\n",
    "\n",
    "    #..Construct the array of elements \n",
    "    for element_id in 1:nelems\n",
    "        e1 = element_connectivity[1][3*(element_id-1)+1]\n",
    "        e2 = element_connectivity[1][3*(element_id-1)+2]\n",
    "        e3 = element_connectivity[1][3*(element_id-1)+3]\n",
    "        p1 = Point2D(sorted[e1,2], sorted[e1,3])\n",
    "        p2 = Point2D(sorted[e2,2], sorted[e2,3])\n",
    "        p3 = Point2D(sorted[e3,2], sorted[e3,3])\n",
    "        Emat, area = localElement(p1,p2,p3); \n",
    "        Elements[element_id] = Element(p1,p2,p3,e1,e2,e3,Emat,area)\n",
    "    end\n",
    "\n",
    "    #..retrieve boundary nodes by loop over corner point and boundary edges\n",
    "    node_ids1=[]; node_ids2=[]; node_ids3=[]; node_ids4=[]; \n",
    "    node_ids5=[]; node_ids6=[]; node_ids7=[]; node_ids8=[]; \n",
    "    node_ids1, node_coord, _ = gmsh.model.mesh.getNodes(0,1)\n",
    "    node_ids2, node_coord, _ = gmsh.model.mesh.getNodes(0,2)\n",
    "    node_ids3, node_coord, _ = gmsh.model.mesh.getNodes(0,3)\n",
    "    node_ids4, node_coord, _ = gmsh.model.mesh.getNodes(0,4)\n",
    "    node_ids5, node_coord, _ = gmsh.model.mesh.getNodes(1,1)\n",
    "    node_ids6, node_coord, _ = gmsh.model.mesh.getNodes(1,2)\n",
    "    node_ids7, node_coord, _ = gmsh.model.mesh.getNodes(1,3)\n",
    "    node_ids8, node_coord, _ = gmsh.model.mesh.getNodes(1,4)\n",
    "    bnd_node_ids = union(node_ids1,node_ids2,node_ids3,node_ids4,node_ids5,node_ids6,node_ids7,node_ids8)\n",
    "    \n",
    "    #..Set DOF per element\n",
    "    dofPerElement = 3 \n",
    "    \n",
    "    #..Store data inside mesh struct  \n",
    "    mesh = Mesh(nnodes,nelems,Elements,bnd_node_ids,dofPerElement) \n",
    "    \n",
    "    #..Finalize gmsh\n",
    "    gmsh.finalize()\n",
    "    \n",
    "    return mesh \n",
    "end\n",
    "\n",
    "#..read nodes from mesh file (useful for post-processing)\n",
    "function nodesFromGmsh(meshFile)\n",
    "    \n",
    "    #..Initialize GMSH\n",
    "    gmsh.initialize()\n",
    "    \n",
    "    #..Read mesh from file\n",
    "    gmsh.open(meshFile)\n",
    "\n",
    "    #..Get the mesh nodes\n",
    "    #..Observe that although the mesh is two-dimensional,\n",
    "    #..the z-coordinate that is equal to zero is stored as well.\n",
    "    #..Observe that the coordinates are stored contiguously for computational\n",
    "    #..efficiency\n",
    "    node_ids, node_coord, _ = gmsh.model.mesh.getNodes()\n",
    "    nnodes = length(node_ids)\n",
    "    #..sort the node coordinates by ID, such that Node one sits at row 1\n",
    "    tosort = [node_ids node_coord[1:3:end] node_coord[2:3:end]];\n",
    "    sorted = sortslices(tosort , dims = 1);\n",
    "    node_ids = sorted[:,1]\n",
    "    xnode = sorted[:,2]\n",
    "    ynode = sorted[:,3]\n",
    "\n",
    "    #..Finalize gmsh\n",
    "    gmsh.finalize()\n",
    "    \n",
    "    return xnode,ynode \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Info    : Reading 'data/square-1.msh'...\n",
      "Info    : 9 entities\n",
      "Info    : 5 nodes\n",
      "Info    : 12 elements\n",
      "Info    : Done reading 'data/square-1.msh'\n",
      "Info    : Reading 'data/square.msh'...\n",
      "Info    : 9 entities\n",
      "Info    : 142 nodes\n",
      "Info    : 282 elements\n",
      "Info    : Done reading 'data/square.msh'\n"
     ]
    }
   ],
   "source": [
    "mesh = meshFromGmsh(\"data/square-1.msh\")\n",
    "xnode, ynode = nodesFromGmsh(\"data/square.msh\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 3: FEM Assembly  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "foo (generic function with 1 method)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creates n*[1., 0., 0. ; 0. 1. 0. ; 0. 0. 1.]\n",
    "# intended to illustrate features of sparse \n",
    "# see also https://discourse.julialang.org/t/advice-for-building-sparsematrix/18178/2 \n",
    "# see also https://discourse.julialang.org/t/improving-my-mental-model-why-is-sizehint-so-much-slower-than-zeros/78776 \n",
    "\n",
    "function foo(n)\n",
    " \n",
    "    #..set values   \n",
    "    nnodes     = 3 \n",
    "    dofPerElem = 9;\n",
    "     \n",
    "    #..allocate memory for global sparse matrix \n",
    "    # Avalues = zeros(Float64,dofPerElem*nelems)\n",
    "    # I = zeros(Int64,length(Avalues))\n",
    "    # J = zeros(Int64,length(Avalues)) \n",
    "    #..create and size I: two allocations (idem for J and Avalues)\n",
    "    I = Int64[]; sizehint!(I, dofPerElem*n)\n",
    "    J = Int64[]; sizehint!(J, dofPerElem*n)\n",
    "    Avalues = Float64[]; sizehint!(Avalues, dofPerElem*n)\n",
    "\n",
    "    #..for loop adds no allocations.. \n",
    "    for i = 1:n #..loop over number of elements..\n",
    "        Iloc = SVector{9,Int64}(1, 1, 1, 2, 2, 2, 3, 3, 3)\n",
    "        Jloc = SVector{9,Int64}(1, 2, 3, 1, 2, 3, 1, 2, 3)\n",
    "        Aloc = SVector{9,Float64}(1., 0., 0., 0., 1., 0., 0., 0., 1.) \n",
    "        for j=1:dofPerElem\n",
    "            push!(I,Iloc[j])\n",
    "            push!(J,Jloc[j])\n",
    "            push!(Avalues,Aloc[j])\n",
    "        end \n",
    "    end\n",
    "    \n",
    "    #..adds 5 allocations - but does *not* pay off.. \n",
    "    # A = sizehint!(spzeros(nnodes,nnodes),dofPerElem*n)\n",
    "\n",
    "    #..adds 12 allocations..\n",
    "    #..thus in total 12 + 6 = 18 allocations \n",
    "    #..independent of problem size n \n",
    "    A = sparse(I,J,Avalues,nnodes,nnodes)\n",
    "   \n",
    "    return Avalues \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 14.571477 seconds (18 allocations: 10.058 GiB, 3.66% gc time)\n"
     ]
    }
   ],
   "source": [
    "@time foo(30000000);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@code_warntype foo(30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 1.3: Check on Mesh Data Structure "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "totalArea = reduce(+,[mesh.Elements[i].area for i=1:mesh.nelems])\n",
    "@test totalArea ≈ 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 2.3: Stiffness Matrix Assembly  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "genStiffMat (generic function with 1 method)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function genLocStiffMat(element::Element)\n",
    "    eloc = SVector(element.e1, element.e2, element.e3)   \n",
    "    Emat = copy(element.Emat) \n",
    "    area = element.area \n",
    "    Iloc = SVector{9}((eloc[i] for i in axes(Emat,1) for j in axes(Emat,2))...)\n",
    "    Jloc = SVector{9}((eloc[j] for i in axes(Emat,1) for j in axes(Emat,2))...) \n",
    "    Emat[3,:] .= 0.;  \n",
    "    Amat = SMatrix{3,3}(area*(transpose(Emat)*Emat))\n",
    "    Aloc = vec(Amat)\n",
    "    return Iloc, Jloc, Aloc\n",
    "end\n",
    "\n",
    "function genStiffMat(mesh::Mesh)\n",
    " \n",
    "    #..recover number of elements  \n",
    "    nnodes      = mesh.nnodes \n",
    "    nelems      = mesh.nelems \n",
    "    dofPerElem  = mesh.dofPerElem\n",
    "    dofPerElem2 = dofPerElem^2\n",
    "    \n",
    "    #..allocate memory for global sparse matrix \n",
    "    I = Int64[]; sizehint!(I, dofPerElem2*nelems)\n",
    "    J = Int64[]; sizehint!(J, dofPerElem2*nelems)\n",
    "    Avalues = Float64[]; sizehint!(Avalues, dofPerElem2*nelems)\n",
    "\n",
    "    #..loop over number of elements..\n",
    "    for element in mesh.Elements \n",
    "        Iloc, Jloc, Aloc = genLocStiffMat(element)\n",
    "        for j=1:dofPerElem2\n",
    "            push!(I,Iloc[j])\n",
    "            push!(J,Jloc[j])\n",
    "            push!(Avalues,Aloc[j])\n",
    "        end \n",
    "    end\n",
    "        \n",
    "    A = sparse(I,J,Avalues,nnodes,nnodes)\n",
    "   \n",
    "    return A; \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Iloc, Jloc, Aloc = genLocStiffMat(refElem)\n",
    "@test Aloc == refElemAloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Info    : Reading 'data/square-1.msh'...\n",
      "Info    : 9 entities\n",
      "Info    : 5 nodes\n",
      "Info    : 12 elements\n",
      "Info    : Done reading 'data/square-1.msh'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mesh = meshFromGmsh(\"data/square-1.msh\");\n",
    "A = genStiffMat(mesh)\n",
    "@test A == testA5node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Info    : Reading 'data/square-1.msh'...\n",
      "Info    : 9 entities\n",
      "Info    : 5 nodes\n",
      "Info    : 12 elements\n",
      "Info    : Done reading 'data/square-1.msh'\n",
      "  0.000007 seconds (16 allocations: 2.625 KiB)\n",
      "Info    : Reading 'data/square-1.msh'...\n",
      "Info    : 9 entities\n",
      "Info    : 5 nodes\n",
      "Info    : 12 elements\n",
      "Info    : Done reading 'data/square-1.msh'\n",
      "  0.000012 seconds (16 allocations: 2.625 KiB)\n",
      "Info    : Reading 'data/square-10.msh'...\n",
      "Info    : 9 entities\n",
      "Info    : 142 nodes\n",
      "Info    : 286 elements\n",
      "Info    : Done reading 'data/square-10.msh'\n",
      "  0.000059 seconds (18 allocations: 103.984 KiB)\n",
      "Info    : Reading 'data/square-100.msh'...\n",
      "Info    : 9 entities\n",
      "Info    : 11833 nodes\n",
      "Info    : 23668 elements\n",
      "Info    : Done reading 'data/square-100.msh'\n",
      "  0.005169 seconds (23 allocations: 9.510 MiB)\n"
     ]
    }
   ],
   "source": [
    "mesh = meshFromGmsh(\"data/square-1.msh\");   @time genStiffMat(mesh); # <= force recompilation \n",
    "mesh = meshFromGmsh(\"data/square-1.msh\");   @time genStiffMat(mesh); \n",
    "mesh = meshFromGmsh(\"data/square-10.msh\");  @time genStiffMat(mesh); \n",
    "mesh = meshFromGmsh(\"data/square-100.msh\"); @time genStiffMat(mesh); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 3.3: Mass Matrix Assembly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function genLocMassMat(element::Element)\n",
    "    eloc = SVector(element.e1, element.e2, element.e3)  \n",
    "    Emat = copy(element.Emat)\n",
    "    area = element.area \n",
    "    Iloc = SVector{9}((eloc[i] for i in axes(Emat,1) for j in axes(Emat,2))...)\n",
    "    Jloc = SVector{9}((eloc[j] for i in axes(Emat,1) for j in axes(Emat,2))...) \n",
    "    Mloc = area/3*SMatrix{3,3}(1I) \n",
    "    return Iloc, Jloc, Mloc\n",
    "end\n",
    "\n",
    "function genMassMat(mesh::Mesh)\n",
    " \n",
    "    #..recover number of elements  \n",
    "    nelems     = mesh.nelems \n",
    "    dofPerElem = mesh.dofPerElem;\n",
    "     \n",
    "    #..preallocate the memory for local matrix contributions \n",
    "    Mvalues = zeros(Float64,dofPerElem*nelems)\n",
    "    I = zeros(Int64,length(Mvalues))\n",
    "    J = zeros(Int64,length(Mvalues)) \n",
    "\n",
    "    for i = 1:nelems #..loop over number of elements..\n",
    "        element          = mesh.Elements[i]\n",
    "        Iloc, Jloc, Mloc = genLocMassMat(element)\n",
    "        irng             = mrange(dofPerElem*i-8, dofPerElem*i) \n",
    "        I[irng]          = Iloc \n",
    "        J[irng]          = Jloc \n",
    "        Mvalues[irng]    = Mloc         \n",
    "    end\n",
    "    \n",
    "    M = sparse(I,J,Mvalues)\n",
    "   \n",
    "    return M; \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Iloc, Jloc, Mloc = genLocMassMat(refElem)\n",
    "@test Mloc == refElemMloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = meshFromGmsh(\"data/square-1.msh\");\n",
    "M = genMassMat(mesh)\n",
    "@test M == testM5node "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 4.3: Right-Hand Side Assembly using Analytically Specified Source Function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mySourceFct(x) = x[1]+x[2] \n",
    "\n",
    "function genLocVector(element::Element, sourceFct::Function)\n",
    "    ploc = SVector(element.p1, element.p2, element.p3)   \n",
    "    Iloc = SVector(element.e1, element.e2, element.e3)   \n",
    "    area = element.area \n",
    "    floc = area/3*sourceFct.(ploc)\n",
    "    return Iloc, floc\n",
    "end\n",
    "\n",
    "function genVector(mesh, sourceFct::F) where F \n",
    " \n",
    "    #..recover number of elements  \n",
    "    nelems  = mesh.nelems \n",
    "    nnodes = mesh.nnodes \n",
    "     \n",
    "    #..preallocate the memory for local matrix contributions \n",
    "    f = zeros(Float64,nnodes)\n",
    "\n",
    "    for i = 1:nelems #..loop over number of elements..\n",
    "        element::Element = mesh.Elements[i]\n",
    "        Iloc, floc = genLocVector(element,sourceFct)\n",
    "        f[Iloc] += floc \n",
    "    end\n",
    "       \n",
    "    return f; \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mesh = meshFromGmsh(\"square-1.msh\");   @code_warntype generateVector(mesh,mySourceFct);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = meshFromGmsh(\"data/square-1.msh\");   @time genVector(mesh,mySourceFct); # <= force recompilation\n",
    "mesh = meshFromGmsh(\"data/square-1.msh\");   @time genVector(mesh,mySourceFct); \n",
    "mesh = meshFromGmsh(\"data/square-10.msh\");  @time genVector(mesh,mySourceFct); \n",
    "mesh = meshFromGmsh(\"data/square-100.msh\"); @time genVector(mesh,mySourceFct); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 4: FEM Solve  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 1.4: Handle Dirichlet Essential Boundary Conditions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function handleBoundary!(mesh,A,f)\n",
    "    bndNodeIds = mesh.bndNodeIds; \n",
    "    #..handle essential boundary conditions \n",
    "    A[bndNodeIds,:] .= 0;\n",
    "    A[bndNodeIds,bndNodeIds] = Diagonal(ones(size(bndNodeIds)))\n",
    "    f[bndNodeIds] .= 0;\n",
    "    return A, f  \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = meshFromGmsh(\"data/square-10.msh\"); A = genStiffMat(mesh); f = genVector(mesh,mySourceFct);\n",
    "A,f = handleBoundary!(mesh,A,f);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 2.4: Solve Linear System "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function genSolution!(mesh,A,f)\n",
    "    A, f = handleBoundary!(mesh,A,f)\n",
    "    u = A\\f \n",
    "    return u \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = meshFromGmsh(\"data/square-10.msh\");   \n",
    "A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); # <= force recompilation\n",
    "@time genSolution!(mesh,A,f);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = meshFromGmsh(\"data/square-10.msh\");  \n",
    "xnode,ynode = nodesFromGmsh(\"data/square-10.msh\")\n",
    "@time A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); \n",
    "@time u = genSolution!(mesh,A,f)\n",
    "GR.trisurf(xnode,ynode,u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = meshFromGmsh(\"data/square-1.msh\");   \n",
    "@time A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); \n",
    "@time u = genSolution!(mesh,A,f)\n",
    "\n",
    "mesh = meshFromGmsh(\"data/square-1.msh\");   \n",
    "@time A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); \n",
    "@time u = genSolution!(mesh,A,f)\n",
    "\n",
    "mesh = meshFromGmsh(\"data/square-10.msh\");  \n",
    "@time A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); \n",
    "@time u = genSolution!(mesh,A,f)\n",
    "\n",
    "mesh = meshFromGmsh(\"data/square-100.msh\"); \n",
    "@time A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); \n",
    "@time u = genSolution!(mesh,A,f)\n",
    "\n",
    "mesh = meshFromGmsh(\"data/square-1000.msh\"); \n",
    "@time A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); \n",
    "@time u = genSolution!(mesh,A,f);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 3: Magnetic Field by Coil  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# source function attached to the callable struct \n",
    "function mySourceFct(x)\n",
    "    return (x[1]>0.3)*(x[1]<0.7)*(x[2]>0.7)*(x[2]<0.9) - (x[1]>0.3)*(x[1]<0.7)*(x[2]>0.1)*(x[2]<0.3)\n",
    "#    return (x[1].>0.3)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh = meshFromGmsh(\"data/square-10.msh\"); \n",
    "xnode, ynode = nodesFromGmsh(\"data/square-10.msh\")\n",
    "A = genStiffMat(mesh); f= genVector(mesh,mySourceFct); \n",
    "u = genSolution!(mesh,A,f);\n",
    "\n",
    "GR.subplot(1,2,1)\n",
    "p1 = GR.trisurf(xnode,ynode,f)\n",
    "GR.subplot(1,2,2)\n",
    "p1 = GR.tricont(xnode,ynode,u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 4: Post-Processing for the Magnetic Flux "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function genDerivLoc(element::Element,u)\n",
    "    ploc = SVector(element.p1, element.p2, element.p3)   \n",
    "    Iloc = SVector(element.e1, element.e2, element.e3)   \n",
    "    Emat = copy(element.Emat)\n",
    "    Emat[3,:] .= 0.; \n",
    "    area = element.area \n",
    "    uloc = u[Iloc] \n",
    "    xmid = sum(ploc)/3\n",
    "    Bx = -dot(uloc,Emat[2,:])\n",
    "    By = dot(uloc,Emat[2,:])\n",
    "    normB2 = Bx^2 + By^2 \n",
    "    return xmid, Bx, By, normB2\n",
    "end\n",
    "\n",
    "function genDeriv(mesh, u)\n",
    "\n",
    "    #..recover number of elements  \n",
    "    nelems  = mesh.nelems \n",
    "    nnodes = mesh.nnodes \n",
    "\n",
    "    #..allocate memory for arrays \n",
    "    xmid   = zeros(Point2D,nelems)\n",
    "    Bx     = zeros(Float64,nelems)\n",
    "    By     = zeros(Float64,nelems)\n",
    "    normB2 = zeros(Float64,nelems)\n",
    "\n",
    "    for element_id in 1:nelems\n",
    "        element::Element = mesh.Elements[element_id]\n",
    "        xmid[element_id], Bx[element_id], By[element_id], normB2[element_id] = genDerivLoc(element,u) \n",
    "    end \n",
    "    \n",
    "    return xmid, Bx, By, normB2 \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xmid, Bx, By, normB2 = genDeriv(mesh, u); \n",
    "xxmid = [x[1] for x in xmid]\n",
    "yxmid = [x[2] for x in xmid]\n",
    "display(typeof(xxmid)) \n",
    "display(typeof(yxmid))\n",
    "display(typeof(Bx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = nodesFromGmsh(\"data/square-1.msh\")\n",
    "z = zeros(size(x))\n",
    "II = [mesh.Elements[i].e1 for i=1:mesh.nelems]\n",
    "JJ = [mesh.Elements[i].e2 for i=1:mesh.nelems]\n",
    "KK = [mesh.Elements[i].e3 for i=1:mesh.nelems]\n",
    "value = [mesh.Elements[i].p1[1] for i=1:mesh.nelems];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PlotlyJS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "methods(PlotlyJS.mesh3d) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edit(\"/Users/djplahaye/.julia/packages/PlotlyBase/4NWbR/src/api.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [0., 1, 2, 0]\n",
    "y = [0., 0, 1, 2]\n",
    "z = [0., 2, 0, 1]\n",
    "i = [0, 0, 0, 1]\n",
    "j = [1, 2, 3, 2]\n",
    "k = [2, 3, 1, 3]\n",
    "PlotlyJS.mesh3d(x, y, z) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PlotlyJS.mesh3d(x,y,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plots.plot(xmid) # works \n",
    "#Plots.surface(xxmid, yxmid,Bx) # works \n",
    "#Plots.surface(xxmid, yxmid,(x, y) -> x^2 + y^2) # works\n",
    "#Plots.contour(xxmid[p], yxmid[p],(x, y) -> x^2 + y^2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GR.surface(xxmid, yxmid,(x, y) -> x^2 + y^2)\\\n",
    "GR.scatter(xxmid, yxmid,(x, y) -> x^2 + y^2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xmid, Bx, By, normB2 = genDeriv(mesh, u)\n",
    "GR.subplot(1,3,1)\n",
    "p1 = GR.tricont(xmid[1],xmid[2],normB2)\n",
    "GR.subplot(1,3,2)\n",
    "p1 = GR.tricont(xmid[1],xmid[2],Bx)\n",
    "GR.subplot(1,3,3)\n",
    "p1 = GR.tricont(xmid[1],xmid[2],By)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.1",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}