JuliaFEM.jl/notebooks/2015-06-14-data-structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data structures\n",
    "\n",
    "**Author(s)**: Jukka Aho\n",
    "\n",
    "**Abstract**: Description of data structures.\n",
    "\n",
    "## Revision history\n",
    "\n",
    "### 2015-06-14\n",
    "- Initial version.\n",
    "\n",
    "### 2015-09-25\n",
    "- Complete rewrite. The main ideas proposed in earlier version didn't work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data fields on elements\n",
    "\n",
    "Typical element structure so far:\n",
    "\n",
    "    type MySuperElement <: Element\n",
    "        connectivity :: Array{Int, 1}  # describes how dofs of this element is connected to another elements\n",
    "        fields :: ???\n",
    "    end\n",
    "\n",
    "- Fields must be interpolable, in space $\\mathbb{C}^n \\times \\mathbb{R}$, i.e. $f(\\boldsymbol{\\xi}, t) = \\sum_i \\phi_i(\\boldsymbol{\\xi}) f_i(t) = \\sum_i \\phi_i(\\boldsymbol{\\xi}) \\sum_j \\varphi_j(t) f_{ij}$, where $f_{ij}$ is scalar, tensor or vector defined in element area $e$ by some basis functions $\\phi(\\boldsymbol{\\xi})$ and $\\varphi(t)$. Parameter $t$ is normally considered as \"time\" and $\\xi$ is dimensionless coordinate. Parameter $t$ has not necessarily to be time, it could be for example angle $\\alpha \\in [-2\\pi, 2\\pi]$ or similar.\n",
    "- We store mainly three fields, scalar field, vector field, tensor field. Field may or may not be dependent from parameters $\\xi$ or $t$.\n",
    "- $t$ is discretized to several steps $\\{t_0, t_1, \\ldots, t_n\\}$. Each discrete time $t_i$ may contain several iterations until convergence. We want to save and get access to all of this data if needed.\n",
    "- So in practice we have a set of fields $f(\\boldsymbol{\\xi})$ over time domain $t$. Typically some fields, like Geometry, is introduced only in time $t_0$. Some other fields, like boundary load, may be \"active\" only on some time $\\hat{t} \\subset t$. Some care must be taken of how to extrapolate field variables.\n",
    "- In the simplest case (simple nonlinear quasistatic analysis), we have for instance $t \\in [0, 1]$ where boundary conditions are set in $t_0$ and load is set in $t_1$. We may use adaptive strategies to shorten time if convergence issues araises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Without time domain\n",
    "\n",
    "Without time we have something like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "using ForwardDiff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type Field{T}\n",
    "    time :: Float64\n",
    "    increment :: Int64\n",
    "    values :: Array{T, 1}\n",
    "end\n",
    "\n",
    "type Basis\n",
    "    basis :: Function\n",
    "    dbasisdxi :: Function\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "* (generic function with 158 methods)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function Field(time, values)\n",
    "    Field(time, 1, values)\n",
    "end\n",
    "function Basis(basis)\n",
    "    Basis(basis, ForwardDiff.jacobian(basis))\n",
    "end\n",
    "call(b::Basis, xi) = b.basis(xi)\n",
    "Base.(:*)(x::Array{Float64, 1}, f::Field) = sum(x .* f.values)\n",
    "Base.(:*)(b::Basis, f::Field) = (x) -> b(x)*f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can do something like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field{Float64}(0.0,1,[0.0,1.0])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = Basis((ξ) -> [0.5*(1.0-ξ[1]), 0.5*(1.0+ξ[1])])\n",
    "u = Field(0.0, [0.0, 1.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N([0.0])*u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(N*u)([0.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending to time domain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we want to interpolate over time domain. Maybe something like this would do the job:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field{Float64}(0.0,1,[0.0,3.0])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Base.(:*)(k::Float64, f::Field) = Field(f.time, k*f.values)\n",
    "u1 = Field(0.0, [0.0, 1.0])\n",
    "3.0*u1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field{Float64}(0.0,1,[1.0,3.0])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function Base.(:+)(f1::Field, f2::Field)\n",
    "    @assert(f1.time == f2.time, \"Cannot add fields: time mismatch, $(f1.time) != $(f2.time)\")\n",
    "    Field(f1.time, f1.values + f2.values)\n",
    "end\n",
    "u1 = Field(0.0, [0.0, 1.0])\n",
    "u2 = Field(0.0, [1.0, 2.0])\n",
    "u1 + u2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field{Float64}(0.0,1,[0.5,1.5])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u1 = Field(0.0, [0.0, 1.0])\n",
    "u2 = Field(0.0, [1.0, 2.0])\n",
    "\n",
    "t = Basis((t) -> [1-t, t])\n",
    "u = Field[u1, u2]\n",
    "Base.(:*)(x::Array{Float64, 1}, f::Array{Field}) = sum(x .* f)\n",
    "Base.(:*)(b::Basis, f::Array{Field}) = (t) -> b(t)*f\n",
    "(t*u)(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Semisummary\n",
    "\n",
    "Putting this together so far:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ϕ = Basis((ξ) -> [0.5*(1.0-ξ[1]), 0.5*(1.0+ξ[1])])\n",
    "φ = Basis((t) -> [1-t, t])\n",
    "u1 = Field(0.0, [0.0, 1.0])\n",
    "u2 = Field(0.0, [1.0, 2.0])\n",
    "# interpolate displacement u1 in mid-point ξ=[0.0] on element\n",
    "(ϕ*u1)([0.0]) # => 0.5\n",
    "# interpolate displacement field [u1, u2] in time t=0.5\n",
    "(φ*Field[u1, u2])(0.5) # => Field{Float64}(:displacement,[0.5,1.5])\n",
    "# interpolate displacement in element area ξ and time t\n",
    "d(ξ, t) = (ϕ*(φ*Field[u1, u2])(t))(ξ)\n",
    "d([0.0], 0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Makes sense, since deformation from $u_1$ to $u_2$ at $t=0.5$ is $\\begin{bmatrix}0.5 & 1.5\\end{bmatrix}$ and taking the midpoint of this makes exactly $1.0$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Towards generalization\n",
    "\n",
    "So at this point we are able to interpolate $u(\\xi)$ in time $t$. This is a set of discrete fields and needs to figure out which fields are needed to interpolate. So we have $u_0, u_1, \\ldots, u_i$ fields. Each time needs to be aware of it's time $t_i$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Field{"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Return a field in some time t.\n",
    "\"\"\"\n",
    "function call(fields::Array{Field, 1}, t::Float64)\n",
    "    if t <= fields[1].time\n",
    "        return fields[1]\n",
    "    end\n",
    "    if t >= fields[end].time\n",
    "        return fields[end]\n",
    "    end\n",
    "    i = length(fields)\n",
    "    while fields[i].time >= t\n",
    "        i -= 1\n",
    "    end\n",
    "    if fields[i].time == t\n",
    "        return fields[i]\n",
    "    end\n",
    "    #Logging.debug(\"doing linear interpolation between fields $i and $(i+1)\")\n",
    "    f1 = fields[i]\n",
    "    t1 = f1.time\n",
    "    f2 = fields[i+1]\n",
    "    t2 = f2.time\n",
    "    dt = t2 - t1\n",
    "    nw = (t2-t)/dt*f1.values + (t-t1)/dt*f2.values\n",
    "    f = Field(t, nw)\n",
    "    return f\n",
    "end\n",
    "function call(field::Field, t::Float64)\n",
    "    Field(t, field.increment, field.values)\n",
    "end\n",
    "\n",
    "u1 = Field(0.0, [0.0, 0.0])\n",
    "u2 = Field(1.0, [1.0, 2.0])\n",
    "u3 = Field(2.0, [0.5, 1.5])\n",
    "u = Field[u1, u2, u3]\n",
    "for f in [u(-Inf), u(0.0), u(0.5), u(1.0), u(1.5), u(2.0), u(Inf)]\n",
    "    println(f)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Handling of derivatives in multidimensional case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "* (generic function with 163 methods)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∂(h::Basis) = h.dbasisdxi\n",
    "diff(h::Basis) = h.dbasisdxi\n",
    "derivative(h::Basis) = h.dbasisdxi\n",
    "Base.(:*)(df::Function, fld::Field) = (ξ) -> df(ξ)*fld\n",
    "Base.length(f::Field) = length(f.values)\n",
    "Base.getindex(f::Field, i::Int64) = f.values[i]\n",
    "Base.(:*)(x::Array{Float64, 2}, fld::Field) = sum([fld[i]*x[i,:] for i in 1:length(fld)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: could not import Base.help into PyCall\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Float64}(0.0,1,[0.0,0.0])\n",
      "Field{Float64}(0.0,1,[0.0,0.0])\n",
      "Field{Float64}(0.5,1,[0.5,1.0])\n",
      "Field{Float64}(1.0,1,[1.0,2.0])\n",
      "Field{Float64}(1.5,1,[0.75,1.75])\n",
      "Field{Float64}(2.0,1,[0.5,1.5])\n",
      "Field{Float64}(2.0,1,[0.5,1.5])\n"
     ]
    }
   ],
   "source": [
    "using PyPlot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpolate midpoint of some field in function of time, i.e., construct $x(\\xi, t)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": [
       "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
      ],
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7f031d473250>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ϕ = Basis((ξ) -> [0.5*(1.0-ξ[1]), 0.5*(1.0+ξ[1])])\n",
    "u1 = Field(0.0, [0.0, 0.0])\n",
    "u2 = Field(1.0, [1.0, 2.0])\n",
    "u3 = Field(2.0, [0.5, 1.5])\n",
    "u = Field[u1, u2, u3]\n",
    "x(ξ, t) = ϕ(ξ)*u(t)\n",
    "t = linspace(-1.0, 4.0, 200)\n",
    "midpnt = zeros(length(t))\n",
    "for i =1:length(t)\n",
    "    midpnt[i] = x([0.0], t[i])\n",
    "end\n",
    "plot(t, midpnt, \"-k\", label=\"midpoint of some field\")\n",
    "legend()\n",
    "grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multidimensional interpolation $x(\\boldsymbol\\xi, t)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": [
       "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
      ],
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7f0326c86e10>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(-0.5,2.0,0.0,2.0)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = Basis((xi) ->\n",
    "    [(1-xi[1])*(1-xi[2])/4\n",
    "     (1+xi[1])*(1-xi[2])/4\n",
    "     (1+xi[1])*(1+xi[2])/4\n",
    "     (1-xi[1])*(1+xi[2])/4])\n",
    "X = Field(0.0, Vector[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]])\n",
    "u1 = Field(0.0, Vector[[0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]])\n",
    "u2 = Field(1.0, Vector[[-0.3, 0.2], [0.2, 0.0], [1.0, 0.0], [0.0, 1.0]])\n",
    "u = Field[u1, u2]\n",
    "N = 5\n",
    "x(ξ, t) = h(ξ)*(X(t) + u(t))\n",
    "for t in linspace(0, 1, N)\n",
    "    m = [x([-1, -1], t) x([1, -1], t) x([1, 1], t) x([-1, 1], t) x([-1, -1], t)]\n",
    "    midpnt = x([0, 0], t)\n",
    "    plot(m[1,:][:], m[2,:][:], \"-o\", label=\"t=$t\")\n",
    "    #plot(midpnt[1], midpnt[2], \"ko\")\n",
    "end\n",
    "legend()\n",
    "axis(\"equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To interpolate field $X$ using basis $h$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 0.5\n",
       " 0.5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(h*X)([0.0, 0.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 0.5\n",
       " 0.5"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h([0.0, 0.0])*X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To interpolate derivatives of field $X$ using basis $h$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2x2 Array{Float64,2}:\n",
       " 0.5  0.0\n",
       " 0.0  0.5"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(∂(h)*X)([0.0, 0.0])  # ∂(⋅) is equivalent to diff(⋅) and derivative(⋅)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2x2 Array{Float64,2}:\n",
       " 0.5  0.0\n",
       " 0.0  0.5"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∂(h)([0.0, 0.0])*X"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.5.0-dev",
   "language": "julia",
   "name": "julia-0.5"
  },
  "language_info": {
   "name": "julia",
   "version": "0.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}