JuliaFEM.jl/docs/tutorials/2015-09-15-2d-segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculating mortar projection matrices\n",
    "\n",
    "Author(s): Jukka Aho\n",
    "\n",
    "**Abstract**: Evaluate mortar projection matrices in 2d and 3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "using JuliaFEM\n",
    "using JuliaFEM: Seg2, Basis, Field, FieldSet, dinterpolate, interpolate, get_connectivity\n",
    "using PyPlot\n",
    "using ForwardDiff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create some test boundaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rlinspace (generic function with 1 method)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function rlinspace(X1, X2, R, n, p0)\n",
    "    fx(ϕ, xc) = R*cos(ϕ) + xc\n",
    "    fy(ϕ, yc) = R*sin(ϕ) + yc\n",
    "    function F(p)\n",
    "        ϕ1, ϕ2, xc, yc = p\n",
    "        return [\n",
    "            fx(ϕ1, xc) - X1[1]\n",
    "            fy(ϕ1, yc) - X1[2]\n",
    "            fx(ϕ2, xc) - X2[1]\n",
    "            fy(ϕ2, yc) - X2[2]\n",
    "        ]\n",
    "    end\n",
    "    J = ForwardDiff.jacobian(F)\n",
    "    p = copy(p0)\n",
    "    for i=1:10\n",
    "        dp = -J(p) \\ F(p)\n",
    "        p += dp\n",
    "        if norm(dp) < 1.0e-9\n",
    "            println(\"Converged. p = $p\")\n",
    "            break\n",
    "        end\n",
    "    end\n",
    "    ϕ1, ϕ2, xc, yc = p\n",
    "    ϕ = linspace(ϕ2, ϕ1, n)\n",
    "    return fx(ϕ, xc), fy(ϕ, yc)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "interpolate (generic function with 11 methods)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function FEM.interpolate(basis::Basis, field::Field, xis::Array{Vector,1})\n",
    "    [FEM.interpolate(basis, field, xi) for xi in xis]\n",
    "end\n",
    "#FEM.interpolate(Γ₁[1], \"geometry\", Vector[[-1.0], [1.0]], 0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converged. p = [4.2905787641613236,5.624156522861784,0.04706336239279979,6.561746550428803]"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x000000002F321F98>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(-0.1,4.0)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Converged. p = [2.110067133637596,1.2802355090457196,1.5675520985912952,-3.7904167887303712]\n"
     ]
    }
   ],
   "source": [
    "srand(42)\n",
    "\n",
    "nsl = 6\n",
    "nm = 5\n",
    "\n",
    "ϕ11 = 5.4\n",
    "ϕ12 = 4.6\n",
    "R1 = 5\n",
    "xc1 = -0.8\n",
    "yc1 = 9.9\n",
    "X1 = [-2.0, 2.0]\n",
    "X2 = [4.0, 3.5]\n",
    "x1, y1 = rlinspace(X1, X2, R1, nsl, [ϕ11, ϕ12, xc1, yc1])\n",
    "\n",
    "ϕ11 = 2.2\n",
    "ϕ12 = 1.1\n",
    "R1 = 5\n",
    "xc1 = 1.9\n",
    "yc1 = -4.1\n",
    "X1 = [-1.0, 0.5]\n",
    "X2 = [3.0, 1.0]\n",
    "x2, y2 = rlinspace(X1, X2, R1, nsl, [ϕ11, ϕ12, xc1, yc1])\n",
    "\n",
    "#x1 = linspace(0, 3, nsl) + rand(nsl)*0.1\n",
    "#y1 = 0.5*rand(nsl)\n",
    "#x2 = linspace(0, 3, nm) + rand(nm)*0.1 + 0.4\n",
    "#y2 = 0.5*rand(nm) + 0.5\n",
    "\n",
    "\"\"\"\n",
    "Calculate element local normal field\n",
    "\"\"\"\n",
    "function calculate_normals!(element::Seg2, time, field_name=\"normal\")\n",
    "    normal_fieldset = FieldSet(field_name)\n",
    "    normal_field = Field(time, Vector[])\n",
    "    tangent(xi) = dinterpolate(element, \"geometry\", xi, time)\n",
    "    for xi in Vector[[-1.0], [1.0]]\n",
    "        t = tangent(xi)\n",
    "        n = [-t[2], t[1]]\n",
    "        push!(normal_field, n/norm(n))\n",
    "    end\n",
    "    push!(normal_fieldset, normal_field)\n",
    "    push!(element, normal_fieldset)\n",
    "end\n",
    "\n",
    "function create_elements(X, sid=0)\n",
    "    Γ = []\n",
    "    nnodes = size(X, 2)\n",
    "    nelements = nnodes-1\n",
    "    for i=1:nelements\n",
    "        con = sid+[i, i+1]\n",
    "        el = Seg2(con)\n",
    "        push!(el, FieldSet(\"geometry\", [Field(0.0, Vector[X[:, i], X[:, i+1]])]))\n",
    "        push!(Γ, el)\n",
    "    end\n",
    "    return Γ\n",
    "end\n",
    "\n",
    "function plot_element(el; plot_with_normal=false)\n",
    "    # create a array of vectors\n",
    "    xis = linspace([-1.0], [1.0], 3)\n",
    "    time = 0.0\n",
    "    coords = interpolate(el, \"geometry\", xis, time)\n",
    "    ncoords = interpolate(el, \"geometry\", xis, time)\n",
    "    normals = interpolate(el, \"normal\", xis, time)\n",
    "    xs = [X[1] for X in coords]\n",
    "    ys = [X[2] for X in coords]\n",
    "    plot(xs, ys, \"-\")\n",
    "    plot([xs[1], xs[end]], [ys[1], ys[end]], \"ko\")\n",
    "    plot([xs[1], xs[end]], [ys[1], ys[end]], \"ko\")\n",
    "    if plot_with_normal\n",
    "        for i=1:3\n",
    "            p0 = ncoords[i]\n",
    "            p1 = ncoords[i]+0.3*normals[i]\n",
    "            plot([p0[1], p1[1]], [p0[2], p1[2]], \"-k\")\n",
    "        end\n",
    "    end\n",
    "end\n",
    "\n",
    "Γ₁ = create_elements([x1 y1]', 0)\n",
    "Γ₂ = create_elements([x2 y2]', nsl);\n",
    "for el in [Γ₁; Γ₂]\n",
    "    calculate_normals!(el, 0.0)\n",
    "end\n",
    "\n",
    "figure(figsize=(10, 3))\n",
    "for el in Γ₁\n",
    "    plot_element(el; plot_with_normal=true)\n",
    "end\n",
    "for el in Γ₂\n",
    "    plot_element(el; plot_with_normal=false)\n",
    "end\n",
    "axis(\"equal\")\n",
    "ylim(-0.1, 4.0)\n",
    "#axis(\"off\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating surface normals\n",
    "\n",
    "To define so called \"continuous normal field\", normals must be unambiguous in nodes. This can be done by averaging normals of adjacent elements:\n",
    "\\begin{equation}\n",
    "\\mathbf{n}_{k}=\\frac{\\sum_{e=1}^{n_{k}^{\\mathrm{adj}}} \\mathbf{n}_{k}^{\\left(e\\right)}}{\\left\\Vert \\sum_{e=1}^{n_{k}^{\\mathrm{adj}}} \\mathbf{n}_{k}^{\\left(e\\right)}\\right\\Vert }.\n",
    "\\end{equation}\n",
    "\n",
    "In practice, we take average of all normal vectors connecting to some arbitrary node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "JuliaFEM.Field{Array{Array{T,1},1}}(0.0,1,Array{T,1}[[0.7021480119880804,-0.7120310170639945],[0.7021480119880804,-0.7120310170639945]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "FEM.interpolate(Γ₁[1][\"normal\"], 0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x000000002F310630>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(-0.1,3.6)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function average_normals!(elements, time, normal_field=\"normal\")\n",
    "    d = Dict()\n",
    "    # calculate sum of normals connecting to node k\n",
    "    for el in elements\n",
    "        c = get_connectivity(el)\n",
    "        n = interpolate(el[normal_field], time).values\n",
    "        for (ci, ni) in zip(c, n)\n",
    "            d[ci] = haskey(d, ci) ? d[ci] + ni : ni\n",
    "        end\n",
    "    end\n",
    "    # norm\n",
    "    for (ci, ni) in d\n",
    "        d[ci] /= norm(d[ci])\n",
    "    end\n",
    "    # update back to elements\n",
    "    for el in elements\n",
    "        c = get_connectivity(el)\n",
    "        #new_normals = Field(time, [d[ci] for ci in c])\n",
    "        #set_field(el, normal_field, new_normals)\n",
    "        #el[normal_field][end].values = new_normals\n",
    "        #push!(el[normal_field], new_normals)\n",
    "        el[normal_field][end].values = [d[ci] for ci in c]\n",
    "    end\n",
    "end\n",
    "\n",
    "average_normals!(Γ₁, 0.0)\n",
    "average_normals!(Γ₂, 0.0)\n",
    "\n",
    "figure(figsize=(10, 3))\n",
    "for el in Γ₁\n",
    "    plot_element(el; plot_with_normal=true)\n",
    "end\n",
    "for el in Γ₂\n",
    "    plot_element(el; plot_with_normal=false)\n",
    "end\n",
    "axis(\"equal\")\n",
    "ylim(-0.1, 3.6)\n",
    "#axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "calc_projection (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function newton(R, dR, x0=0.0; max_iterations=10, tol=1.0e-9)\n",
    "    x = x0\n",
    "    for i=1:max_iterations\n",
    "        dx = -R(x)/dR(x)\n",
    "        x += dx\n",
    "        if abs(dx) < tol\n",
    "            break\n",
    "        end\n",
    "    end\n",
    "    x\n",
    "end\n",
    "\n",
    "\"\"\"\n",
    "Find projection from slave nodes to master element.\n",
    "\n",
    "Parameters\n",
    "----------\n",
    "sel :: Element\n",
    "    slave element\n",
    "mel :: Element\n",
    "    master element\n",
    "sxi :: Vector\n",
    "    projection point in slave side (typically [-1.0] or [1.0])\n",
    "\n",
    "Returns\n",
    "-------\n",
    "mxi :: Vector\n",
    "    point in master element corresponding to xi in slave\n",
    "\n",
    "\"\"\"\n",
    "function calc_projection_from_slave_to_master(sel, mel, sxi; solver_options...)\n",
    "    # slave side point\n",
    "    X1 = interpolate(sel, :Geometry, sxi)\n",
    "    N1 = interpolate(sel, :Normals, sxi)\n",
    "    # master element function and their derivatives\n",
    "    X2(xi) = interpolate(mel, :Geometry, xi)\n",
    "    dX2(xi) = dinterpolate(mel, :Geometry, xi)\n",
    "    # residual & solution\n",
    "    R(xi) = det([X2(xi)-X1 N1])\n",
    "    dR(xi) = det([dX2(xi) N1])\n",
    "    mxi = newton(R, dR; solver_options...)\n",
    "    return [mxi]\n",
    "end\n",
    "\n",
    "\"\"\"\n",
    "Find projection from master to slave element.\n",
    "\n",
    "Parameters\n",
    "----------\n",
    "sel :: Element\n",
    "    slave element\n",
    "mel :: Element\n",
    "    master element\n",
    "mxi :: Vector\n",
    "    projection point in master side (typically [-1.0] or [1.0])\n",
    "\n",
    "Returns\n",
    "-------\n",
    "sxi :: Vector\n",
    "    point in slave element corresponding to xi in master\n",
    "\"\"\"\n",
    "function calc_projection_from_master_to_slave(sel, mel, mxi; solver_options...)\n",
    "    # slave element functions and their derivatives\n",
    "    X1(xi) = interpolate(sel, :Geometry, xi)\n",
    "    dX1(xi) = dinterpolate(sel, :Geometry, xi)\n",
    "    N1(xi) = interpolate(sel, :Normals, xi)\n",
    "    dN1(xi) = dinterpolate(sel, :Normals, xi)\n",
    "    # master side point\n",
    "    X2 = interpolate(mel, :Geometry, mxi)\n",
    "    # residual & solution\n",
    "    R(xi) = det([X1(xi)-X2 N1(xi)])\n",
    "    dR(xi) = det([dX1(xi) N1(xi)]) + det([X1(xi)-X2 dN1(xi)])\n",
    "    sxi = newton(R, dR; solver_options...)\n",
    "    return [sxi]\n",
    "end\n",
    "\n",
    "function has_projection(xi1, xi2)\n",
    "    l = abs(xi1[2]-xi1[1])[1]\n",
    "    return l > 1.0e-9\n",
    "end\n",
    "\n",
    "function calc_projection(sel, mel; clamp=true)\n",
    "    xi1a = calc_projection_from_master_to_slave(sel, mel, [-1.0])\n",
    "    xi1b = calc_projection_from_master_to_slave(sel, mel, [ 1.0])\n",
    "    xi2a = calc_projection_from_slave_to_master(sel, mel, [-1.0])\n",
    "    xi2b = calc_projection_from_slave_to_master(sel, mel, [ 1.0])\n",
    "    xi1 = Vector[xi1a, xi1b]\n",
    "    xi2 = Vector[xi2a, xi2b]\n",
    "    if clamp\n",
    "        clamp!(xi1, -1, 1)\n",
    "        clamp!(xi2, -1, 1)\n",
    "    end\n",
    "    return xi1, xi2\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "integrate_segment (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function integrate_segment(sel, mel, xi1, xi2)\n",
    "    nsel = get_number_of_basis_functions(sel)\n",
    "    nmel = get_number_of_basis_functions(mel)\n",
    "    De = zeros(nsel, nsel)\n",
    "    Me = zeros(nsel, nmel)\n",
    "    return De, Me\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7faed5beb5d0>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(-3.0,5.0,-0.1,3.6)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function plot_all()\n",
    "    figure(figsize=(10, 3))\n",
    "    for el in Γ₁\n",
    "        plot_element(el; plot_with_normal=true)\n",
    "    end\n",
    "    for el in Γ₂\n",
    "        plot_element(el; plot_with_normal=false)\n",
    "    end\n",
    "    for sel in Γ₁\n",
    "        for mel in Γ₂\n",
    "            xi1, xi2 = calc_projection(sel, mel)\n",
    "            if has_projection(xi1, xi2)\n",
    "                X1 = interpolate(sel, :Geometry, xi1)\n",
    "                X2 = interpolate(mel, :Geometry, xi2)\n",
    "                for s=1:2\n",
    "                    x = [X1[s][1], X2[s][1]]\n",
    "                    y = [X1[s][2], X2[s][2]]\n",
    "                    plot(x, y, \"-kx\")\n",
    "                end\n",
    "                De, Me = integrate_segment(sel, mel, xi1, xi2)\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "    axis(\"equal\")\n",
    "    ylim(-0.1, 3.6)\n",
    "    axis(\"off\")\n",
    "end\n",
    "\n",
    "plot_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A little experience, raise the degree of elements, smooth geometry, and test projection for 2nd order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: BoundsError: attempt to access (2,)\n  at index [2]\nwhile loading In[9], in expression starting on line 13",
     "output_type": "error",
     "traceback": [
      "LoadError: BoundsError: attempt to access (2,)\n  at index [2]\nwhile loading In[9], in expression starting on line 13",
      "",
      " in getindex at tuple.jl:8",
      " in get_detJ at /home/jukka/.julia/v0.5/JuliaFEM/src/equations.jl:50",
      " in fit_derivative_field! at /home/jukka/.julia/v0.5/JuliaFEM/src/elements.jl:434",
      " [inlined code] from In[9]:14",
      " in anonymous at no file:0"
     ]
    }
   ],
   "source": [
    "# to raise degree of elements and smooth geometry\n",
    "function tangent(el, xi)\n",
    "    normal = interpolate(el, :Normals, xi)\n",
    "    [0 -1; 1 0]'*normal\n",
    "end\n",
    "for el in [Γ₁; Γ₂]\n",
    "    set_degree(el, 2)\n",
    "    for field in (:Geometry, :Normals)\n",
    "        push!(el.fields[field], [0.0, 0.0])\n",
    "        el.fields[field] = el.fields[field][1:get_number_of_basis_functions(el)]\n",
    "    end\n",
    "end\n",
    "for el in [Γ₁; Γ₂]\n",
    "    fit_derivative_field!(el, :Geometry, tangent, Int[1, 2])\n",
    "end\n",
    "plot_all()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.0",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}