diff --git a/notebooks/2015-05-29-parsing-mesh-files.ipynb b/notebooks/2015-05-29-parsing-mesh-files.ipynb deleted file mode 100644 index 6803c5a..0000000 --- a/notebooks/2015-05-29-parsing-mesh-files.ipynb +++ /dev/null @@ -1,191 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's collect here examples how to parse mesh files (i.e. topologies; nodes and connectivity) from different kind of sources." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "f = open(\"../testdata/tripod.GiD.msh\");\n", - "data = readlines(f)\n", - "close(f)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Dict{Any,Any} with 0 entries" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type Node\n", - " node_id\n", - " coords\n", - "end\n", - "type Element\n", - " element_id\n", - " node_ids\n", - "end\n", - "nodes = Dict()\n", - "elements = Dict()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Entering section Coordinates\n", - "Leaving section Coordinates\n", - "Entering section Elements\n", - "Leaving section Elements\n", - "Mesh parsed\n" - ] - } - ], - "source": [ - "section = \"\"\n", - "for line in data\n", - " line = strip(line)\n", - " if line == \"Coordinates\" || line == \"Elements\"\n", - " section = line\n", - " println(\"Entering section \",section)\n", - " end\n", - " if beginswith(line, \"end\")\n", - " println(\"Leaving section \",section)\n", - " section = \"\"\n", - " end\n", - " if section == \"Coordinates\"\n", - " m = matchall(r\"[-0-9.]+\", line)\n", - " if length(m) == 0\n", - " continue\n", - " end\n", - " id = integer(m[1])\n", - " coords = float(m[2:end])\n", - " nodes[id] = Node(id, coords)\n", - " end\n", - " if section == \"Elements\"\n", - " #println(line)\n", - " m = matchall(r\"[0-9]+\", line)\n", - " #println(m)\n", - " if length(m) == 0\n", - " continue\n", - " end\n", - " id = integer(m[1])\n", - " #println(line)\n", - " #println(m)\n", - " #print(id)\n", - " node_ids = m[2:end]\n", - " #println(id,node_ids)\n", - " elements[id] = Element(id, map(integer, node_ids))\n", - " end\n", - "end\n", - "println(\"Mesh parsed\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "10-element Array{Int64,1}:\n", - " 1411\n", - " 1527\n", - " 1338\n", - " 1581\n", - " 1467\n", - " 1431\n", - " 1375\n", - " 1494\n", - " 1557\n", - " 1455" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "elements[100].node_ids" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "10-element Array{Node,1}:\n", - " Node(1411,[1.55541,4.93615,12.9066])\n", - " Node(1527,[3.55077,4.78495,12.5057])\n", - " Node(1338,[1.26995,2.70013,12.9378])\n", - " Node(1581,[2.09046,5.60655,10.2598])\n", - " Node(1467,[2.56484,4.86055,12.7445])\n", - " Node(1431,[2.42483,3.74254,12.7719])\n", - " Node(1375,[1.41281,3.81814,12.923]) \n", - " Node(1494,[1.82293,5.27135,11.5832])\n", - " Node(1557,[2.82062,5.19575,11.3827])\n", - " Node(1455,[1.68021,4.15334,11.5988])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "map(id -> nodes[id], elements[100].node_ids)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.3.8", - "language": "julia", - "name": "julia-0.3" - }, - "language_info": { - "name": "julia", - "version": "0.3.8" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-05-31-experimenting-dual-numbers.ipynb b/notebooks/2015-05-31-experimenting-dual-numbers.ipynb deleted file mode 100644 index 3a026f7..0000000 --- a/notebooks/2015-05-31-experimenting-dual-numbers.ipynb +++ /dev/null @@ -1,655 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#Automatic differentiation\n", - "\n", - "Author(s): [Jukka Aho]()\n", - "\n", - "https://github.com/ovainola/JuliaFEM/issues/14\n", - "\n", - "Some tests considering automatic differentiation. Basic question is: *how much do we lose on computation time using automatic differentiation compared to the analytical tangent stiffness matrix*?\n", - "\n", - "It is already known that evaluation of Jacobian takes $n$ function calls, where $n$ is number of unknown parameters. Analytical solution takes only one call, but the function is more cumbersome and needs more cpu time. In linear 2d quadrangle case I assume that we need 8 calls per element. We can expect that autodiffed stiffness matrix evaluation is a bit slower, but interesting question is that are these two strategies even in same decade. FENiCS uses automatic differentiation succesfully so in principle it should work.\n", - "\n", - "**TODO**\n", - "\n", - "- Evaluate 10000 tangent stiffness matrices analytically (nonlinear_stiffness) and 10000 stiffness matrices using automatic differentiation (Kt).\n", - "- @time it.\n", - "- Check that analytical and automatically differentiated matrices match, they should be 1:1.\n", - "- Optimize tangent stiffness matrix code for both cases\n", - "\n", - "ForwardDiff is not behaving nicely (or at least I cannot debug it), so we need to try DualNumbers directly. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Loading help data...\n" - ] - } - ], - "source": [ - "using DualNumbers\n", - "using PyPlot" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example: solving scalar equation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Find root for $f(x) = -2 + x + x^2$. Roots are $\\{-2, 1\\}$." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "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" - ], - "text/plain": [ - "Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "x = linspace(-5, 5)\n", - "f(x) = -2 + x + x.^2\n", - "plot(x, f(x), \"-k\")\n", - "grid()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.0 -2.0\n", - "1.2 0.8\n", - "1.011764705882353 0.18823529411764703\n", - "1.00004577706569 0.011718928816662783\n", - "1.000000000698492 4.577636719815749e-5\n", - "1.0 6.984919306363482e-10\n", - "1.0 0.0\n", - "1.0 0.0\n", - "1.0 0.0\n", - "1.0 0.0\n" - ] - } - ], - "source": [ - "x = 0\n", - "for i = 1:10\n", - " e = f(dual(x, 1)) # here we evaluate function f using dual number\n", - " dx = real(e)/epsilon(e) # calculate dx and perform newton iteration\n", - " x -= dx\n", - " println(x, \" \", dx)\n", - "end" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Works like a charm. We get derivative and function evaluated at same time. Beautiful solution." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Multidimensional functions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "From ForwardDiff example:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluated\n", - "Evaluated\n" - ] - }, - { - "data": { - "text/plain": [ - "3x2 Array{Float64,2}:\n", - " 4.2 1.0 \n", - " 3.0 0.0 \n", - " 14.175 29.7675" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using ForwardDiff\n", - "\n", - "function f!(x, y)\n", - " println(\"Evaluated\")\n", - " y[1] = x[1]^2+x[2]\n", - " y[2] = 3*x[1]\n", - " y[3] = x[1]^2*x[2]^3\n", - "end\n", - "\n", - "# Using forwarddiff_jacobian\n", - "j = forwarddiff_jacobian(f!, Float64, fadtype=:dual, n=2, m=3)\n", - "\n", - "j([2.1, 1.5])" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluated\n", - "Evaluated\n" - ] - }, - { - "data": { - "text/plain": [ - "3x2 Array{Float64,2}:\n", - " 6.0 1.0\n", - " 3.0 0.0\n", - " 384.0 432.0" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "j([3.0, 4.0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " That is, we need $n=2$ evaluations to get Jacobian. Each time." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "# Comparisons" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "3x3 Array{Float64,2}:\n", - " 96.0 24.0 0.0\n", - " 24.0 96.0 0.0\n", - " 0.0 0.0 36.0" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Partial derivatives of bilinear Lagrange polynomials\n", - "dNdξ(ξ) = [[-(1-ξ[2])/4.0 -(1-ξ[1])/4.0],\n", - " [ (1-ξ[2])/4.0 -(1+ξ[1])/4.0],\n", - " [ (1+ξ[2])/4.0 (1+ξ[1])/4.0],\n", - " [-(1+ξ[2])/4.0 (1-ξ[1])/4.0]] \n", - "\n", - "E = 90\n", - "ν = 0.25\n", - "\n", - "μ = E/(2*(1+ν))\n", - "λ = E*ν/((1+ν)*(1-2*ν))\n", - "λ = 2*λ*μ/(λ + 2*μ)\n", - "\n", - "δ = eye(2)\n", - "C = zeros(2, 2, 2, 2)\n", - "C_sym = zeros(size(C))\n", - "\n", - "for i=1:2\n", - " for j=1:2\n", - " for k=1:2\n", - " for l=1:2\n", - " C[i,j,k,l] = λ*δ[i,j]*δ[k,l] + μ*(δ[i,k]*δ[j,l] + δ[i,l]*δ[j,k]) \n", - " end\n", - " end\n", - " end\n", - "end\n", - "\n", - "for i=1:2\n", - " for j=1:2\n", - " for k=1:2\n", - " for l=1:2\n", - " C_sym[i,k,j,l] = 1/4*(C[i,k,j,l] + C[i,k,l,j] + C[k,i,j,l] + C[k,i,l,j])\n", - " end\n", - " end\n", - " end\n", - "end\n", - "\n", - "D = E/(1-ν^2)*[[1 ν 0], [ν 1 0], [0 0 (1-ν)/2]]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1x4 Array{Int64,2}:\n", - " 1 1 1 1" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a = 1/sqrt(3)\n", - "ipoints = [[-a -a], [a -a], [a a], [-a a]]\n", - "iweights = [1 1 1 1]" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "nonlinear_stiffness (generic function with 1 method)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function nonlinear_stiffness(X, u)\n", - " n_integration_points = length(iweights)\n", - " n_problem_dimension = 2\n", - " n_solution_dimension = 2\n", - " n_shape_functions = 4\n", - " n_dofs = n_solution_dimension*n_shape_functions\n", - " K2_L = zeros((n_dofs, n_dofs))\n", - " K2_NL = zeros((n_dofs, n_dofs))\n", - " T = zeros((n_solution_dimension, n_shape_functions))\n", - " B_L = zeros(3, 8)\n", - " B_NL = zeros(4, 8)\n", - "\n", - " for m = 1:n_integration_points\n", - " ξ = ipoints[m, :]\n", - " w = iweights[m]\n", - "\n", - " Jᵀ = X*dNdξ(ξ)\n", - " ∇N = inv(Jᵀ)*dNdξ(ξ)'\n", - " ∇u = u*∇N'\n", - " F = I + ∇u # Deformation gradient\n", - "\n", - " detJ = det(Jᵀ)\n", - " #detF = det(F)\n", - " E = 1/2*(∇u + ∇u' + ∇u'*∇u) # Green-Lagrange strain tensor\n", - " P = λ*trace(E)*eye(2) + 2*μ*E # PK2 stress tensor\n", - " S = F*P\n", - "\n", - " B_L[:,:] = 0\n", - " for i = 0:3\n", - " B_L[1, i*2+1] = F[1, 1]*∇N[1, i+1]\n", - " B_L[1, i*2+2] = F[2, 1]*∇N[1, i+1]\n", - " B_L[2, i*2+1] = F[1, 2]*∇N[2, i+1]\n", - " B_L[2, i*2+2] = F[2, 2]*∇N[2, i+1]\n", - " B_L[3, i*2+1] = F[1, 1]*∇N[2, i+1] + F[1, 2]*∇N[1, i+1]\n", - " B_L[3, i*2+2] = F[2, 1]*∇N[2, i+1] + F[2, 2]*∇N[1, i+1]\n", - " end\n", - " K2_L += w*B_L'*D*B_L*detJ\n", - "\n", - " τ = zeros(4, 4)\n", - " τ[1:2,1:2] = S\n", - " τ[3:4,3:4] = S\n", - " B_NL[:,:] = 0.0\n", - " for i=0:3\n", - " B_NL[1, 2*i+1] = ∇N[1, i+1]\n", - " B_NL[2, 2*i+1] = ∇N[2, i+1]\n", - " B_NL[3, 2*i+2] = ∇N[1, i+1]\n", - " B_NL[4, 2*i+2] = ∇N[2, i+1]\n", - " end\n", - " K2_NL += w*B_NL'*τ*B_NL*detJ\n", - "\n", - " # Nodal forces\n", - " T += w*S*∇N*detJ\n", - "\n", - " end\n", - "\n", - " return T', K2_L+K2_NL\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x4 Array{Int64,2}:\n", - " 0 0 1 0\n", - " 0 0 0 0" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X = [0 0; 1 0; 1 1; 0 1]'\n", - "u = [0 0; 0 0; 1 0; 0 0]'" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "elapsed time: 1.159613267 seconds (79896004 bytes allocated, 4.41% gc time)\n" - ] - }, - { - "data": { - "text/plain": [ - "(\n", - "4x2 Array{Float64,2}:\n", - " -60.6667 -24.0\n", - " -1.33333 -8.0\n", - " 133.333 35.0\n", - " -71.3333 -3.0,\n", - "\n", - "8x8 Array{Float64,2}:\n", - " 136.333 34.0 -29.3333 -2.0 … -34.0 23.0 2.0 \n", - " 34.0 81.6667 6.0 3.33333 -71.6667 -7.0 -13.3333\n", - " -42.3333 6.0 83.3333 10.0 -28.0 -45.0 12.0 \n", - " -2.0 -9.66667 10.0 52.6667 -11.3333 11.0 -31.6667\n", - " -127.333 -33.0 -20.6667 -19.0 55.0 -153.333 -3.0 \n", - " -34.0 -69.0 -28.0 -36.0 … 162.667 7.0 -57.6667\n", - " 33.3333 -7.0 -33.3333 11.0 7.0 175.333 -11.0 \n", - " 2.0 -3.0 12.0 -20.0 -79.6667 -11.0 102.667 )" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "@time nonlinear_stiffness(X, u)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "calculate_internal_energy! (generic function with 2 methods)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function gauss2d(J, Wint)\n", - " a = 1/sqrt(3)\n", - " ipoints = [[-a -a], [a -a], [a a], [-a a]]\n", - " iweights = [1 1 1 1]\n", - " Wint[:,:] = 0\n", - "\n", - " for m = 1:length(iweights)\n", - " w = iweights[m]\n", - " ξ = ipoints[m, :]\n", - " Wint[:,:] += w*J(ξ)\n", - " end\n", - "end\n", - "\n", - "function calculate_internal_energy!(X, u, Wint, dNdξ, λ, μ, dim=2)\n", - " u = reshape(u, 2, 4)\n", - " X = reshape(X, 2, 4)\n", - " Wint = reshape(Wint, 2, 4)\n", - " I = eye(dim)\n", - " \n", - " function J(ξ)\n", - " Jᵀ = X*dNdξ(ξ)\n", - " ∇N = inv(Jᵀ)*dNdξ(ξ)'\n", - " ∇u = u*∇N'\n", - " F = I + ∇u # Deformation gradient\n", - " E = 1/2*(∇u' + ∇u + ∇u'*∇u) # Green-Lagrange strain tensor\n", - " P = λ*trace(E)*I + 2*μ*E # PK1 stress tensor\n", - " S = F*P # PK2 stress tensor\n", - " return S*∇N*det(Jᵀ)\n", - " end\n", - "\n", - " gauss2d(J, Wint)\n", - " u = reshape(u, 8)\n", - " X = reshape(X, 8)\n", - " Wint = reshape(Wint, 8)\n", - "\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "8-element Array{Float64,1}:\n", - " -60.6667 \n", - " -24.0 \n", - " -1.33333\n", - " -8.0 \n", - " 133.333 \n", - " 35.0 \n", - " -71.3333 \n", - " -3.0 " - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function Winte!(u, Wint)\n", - " calculate_internal_energy!(X, u, Wint, dNdξ, λ, μ)\n", - "end\n", - "Wint = zeros(8)\n", - "Winte!(reshape(u, 8), Wint)\n", - "Wint" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "g! (generic function with 1 method)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using ForwardDiff\n", - "Kt = forwarddiff_jacobian!(Winte!, Float64, fadtype=:dual, n=8, m=8)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "ename": "LoadError", - "evalue": "`dual_fad` has no method matching dual_fad(::Function, ::Array{Int64,1}, ::Array{Float64,2}, ::Array{Dual{Float64},1}, ::Array{Dual{Float64},1})\nwhile loading In[14], in expression starting on line 2", - "output_type": "error", - "traceback": [ - "`dual_fad` has no method matching dual_fad(::Function, ::Array{Int64,1}, ::Array{Float64,2}, ::Array{Dual{Float64},1}, ::Array{Dual{Float64},1})\nwhile loading In[14], in expression starting on line 2", - "", - " in g! at /home/jukka/.julia/v0.3/ForwardDiff/src/dual_fad/multivariate_range.jl:18" - ] - } - ], - "source": [ - "J = zeros(8, 8)\n", - "Kt(reshape(u, 8), J)\n", - "Kt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This ForwardDiff package is just not working as expected. We have well defined function but for some reason it's just not working. Bad code." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "elapsed time: 1.198824455 seconds (532828332 bytes allocated, 27.60% gc time)\n" - ] - } - ], - "source": [ - "function calc_1()\n", - " for i=1:10000\n", - " K, T = nonlinear_stiffness(X, u)\n", - " end\n", - "end\n", - "@time calc_1()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.3.8", - "language": "julia", - "name": "julia-0.3" - }, - "language_info": { - "name": "julia", - "version": "0.3.8" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-05-31-two-element-solution.ipynb b/notebooks/2015-05-31-two-element-solution.ipynb deleted file mode 100644 index baaf3a2..0000000 --- a/notebooks/2015-05-31-two-element-solution.ipynb +++ /dev/null @@ -1,565 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#Assembly\n", - "\n", - "Let's make two element model and assemble it. We split the previous one element model to 2 quadrilaterals, make assembly and solve it. Small modifications to functions, I think it's better that they don't allocate memory but do in place operations. \n", - "\n", - "**TODO**\n", - "- Tangent stiffness is calculated using forward finite difference. I think we should try ReverseDiffSparse for it's sparse matrix support, but I don't know how to use it. Or alternatively use FAD like before and assemble after linearization. It would be nice experiment to try linearization *after* assembly, would it work?\n", - "- Verify calculations using some well known FEM software.\n", - "\n", - "\n", - "Author: Jukka Aho\n", - "\n", - "Email: " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0x00000c95556709c2" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tic()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Dict{Any,Any} with 0 entries" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type Node\n", - " coords\n", - "end\n", - "type Element\n", - " node_ids\n", - "end\n", - "elements = Dict()\n", - "nodes = Dict()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Element([5,6,3,2])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ndim = 2\n", - "nnodes = 6\n", - "\n", - "nodes[1] = Node([0, 1, 0])\n", - "nodes[2] = Node([5, 1, 0])\n", - "nodes[3] = Node([10, 1, 0])\n", - "nodes[4] = Node([0, 0, 0])\n", - "nodes[5] = Node([5, 0, 0])\n", - "nodes[6] = Node([10, 0, 0])\n", - "elements[1] = Element([4, 5, 2, 1])\n", - "elements[2] = Element([5, 6, 3, 2])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(36.0,24.0)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Partial derivatives of bilinear Lagrange polynomials\n", - "dNdξ(ξ) = [[-(1-ξ[2])/4.0 -(1-ξ[1])/4.0],\n", - " [ (1-ξ[2])/4.0 -(1+ξ[1])/4.0],\n", - " [ (1+ξ[2])/4.0 (1+ξ[1])/4.0],\n", - " [-(1+ξ[2])/4.0 (1-ξ[1])/4.0]] \n", - "\n", - "E = 90\n", - "ν = 0.25\n", - "μ = E/(2*(1+ν))\n", - "λ = E*ν/((1+ν)*(1-2*ν))\n", - "λ = 2*λ*μ/(λ + 2*μ)\n", - "μ, λ" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "calculate_internal_energy! (generic function with 2 methods)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function calculate_internal_energy!(X, u, Wint, dNdξ, λ, μ, dim=2)\n", - " \"\"\"Calculate internal energy for a single element.\n", - "\n", - " Parameters\n", - " ----------\n", - " X : array [dim x nodes]\n", - " u : array [dim x nodes]\n", - " dNdξ : shape function derivatives\n", - " λ : float\n", - " μ : float\n", - " dim : integer, optinal\n", - "\n", - " Returns\n", - " -------\n", - " Nothing, this is inplace function\n", - " \n", - " \"\"\"\n", - " I = eye(dim)\n", - " \n", - " function J(ξ)\n", - " Jᵀ = X*dNdξ(ξ)\n", - " ∇N = inv(Jᵀ)*dNdξ(ξ)'\n", - " ∇u = u*∇N'\n", - " F = I + ∇u # Deformation gradient\n", - " E = 1/2*(∇u' + ∇u + ∇u'*∇u) # Green-Lagrange strain tensor\n", - " P = λ*trace(E)*I + 2*μ*E # PK1 stress tensor\n", - " S = F*P # PK2 stress tensor\n", - " return S*∇N*det(Jᵀ)\n", - " end\n", - "\n", - " a = 1/sqrt(3)\n", - " ipoints = [[-a -a], [a -a], [a a], [-a a]]\n", - " iweights = [1 1 1 1]\n", - "\n", - " for m = 1:length(iweights)\n", - " w = iweights[m]\n", - " ξ = ipoints[m, :]\n", - " Wint[:,:] += w*J(ξ)\n", - " end\n", - "\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x4 Array{Float64,2}:\n", - " -60.6667 -1.33333 133.333 -71.3333\n", - " -24.0 -8.0 35.0 -3.0 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Wint = zeros(2, 4)\n", - "X = [0 0; 1 0; 1 1; 0 1]'\n", - "u = [0 0; 0 0; 1 0; 0 0]'\n", - "calculate_internal_energy!(X, u, Wint, dNdξ, λ, μ)\n", - "Wint" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "assemble! (generic function with 1 method)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function assemble!(u, R)\n", - " \"\"\" Assemble global residual vector R = T - F\n", - " \"\"\"\n", - " R[:] = 0.0\n", - " u = reshape(u, ndim, nnodes)\n", - " R = reshape(R, ndim, nnodes)\n", - " \n", - " Xe = zeros(ndim, 4)\n", - " Winte = zeros(ndim, 4)\n", - " \n", - " # Internal forces, T\n", - " for i=1:length(elements) # loop through elements\n", - " Xe[:,:] = 0.0 # FIXME: how to efficiently empty array?\n", - " el = elements[i]\n", - " nids = el.node_ids\n", - " for i=1:length(nids) # loop through nodes\n", - " Xe[:,i] = nodes[nids[i]].coords[1:2]\n", - " end\n", - " Winte[:,:] = 0.0\n", - " calculate_internal_energy!(Xe, u[:,nids], Winte, dNdξ, λ, μ)\n", - " R[:,nids] += Winte\n", - " end\n", - "\n", - " # External forces, F\n", - " # T - F = T + (-F)\n", - " R[2, 3] += 2 # Force to the tip of härveli\n", - "\n", - " u = reshape(u, ndim*nnodes)\n", - " R = reshape(R, ndim*nnodes)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1x12 Array{Float64,2}:\n", - " 0.0 0.0 34.8853 16.2 140.715 78.6 … -64.1013 -36.0 -111.499 -56.8" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "R = zeros(ndim*nnodes)\n", - "u = [0 0; 0 0; 1 0; 0 0; 0 0; 0 0]'\n", - "#u = [0 0; 0 0; 1 0; 0 0]'\n", - "assemble!(reshape(u, ndim*nnodes), R)\n", - "R'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We should use ReverseDiffSparse because of it's sparse matrix support" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# FIXME: I don't know how to get these working!\n", - "#using ReverseDiffSparse\n", - "#using ForwardDiff\n", - "#Kt! = forwarddiff_jacobian!(assemble!, Float64, fadtype=:dual, n=12, m=12)\n", - "#Kt!(reshape(u, 12), Kt)\n", - "#Kt" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Lin (generic function with 2 methods)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# So we go to plan B. FIXME: change this to analytical version\n", - "\n", - "function Lin(f!, h=1.0e-6)\n", - "\n", - " function D!(x, J)\n", - " J[:,:] = 0\n", - " N = length(x)\n", - " Δx = zeros(N)\n", - " y = zeros(N)\n", - " Δy = zeros(N)\n", - " f!(x, y) # Evaluate function f in x and store results to y\n", - " for i=1:N\n", - " Δx[:] = 0.0\n", - " Δx[i] += h\n", - " f!(x+Δx, Δy) # Evaluate function f in x+Δx and store results to Δy\n", - " J[i, :] = (Δy-y) / h\n", - " end\n", - " end\n", - "\n", - " return D!\n", - "\n", - "end" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Handling homogeneous Dirichlet conditions, using elimination.\n", - "\n", - "**INFO**: We could try something like this: http://www.code-aster.org/V2/doc/default/en/man_r/r3/r3.03.01.pdf\n", - "\n", - "Here's an idea how to make a very simply elimination" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x6 Array{Int64,2}:\n", - " 1 0 0 1 0 0\n", - " 1 0 0 1 0 0" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fixed_dofs = integer(zeros(ndim, nnodes))\n", - "fixed_dofs[:,1] = fixed_dofs[:,4] = 1\n", - "fixed_dofs" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x6 Array{Int64,2}:\n", - " 0 1 1 0 1 1\n", - " 0 1 1 0 1 1" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "free_dofs = integer(ones(ndim, nnodes)) - fixed_dofs\n", - "free_dofs" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1x8 Array{Int64,2}:\n", - " 3 4 5 6 9 10 11 12" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "free_dofs = find(free_dofs)\n", - "free_dofs'" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting Newton iterations\n", - "Iteration 1, norm = 12.031651257897487\n", - "Iteration 2, norm = 3.141275068747564\n", - "Iteration 3, norm = 1.1530769747882408\n", - "Iteration 4, norm = 0.2665784114781298\n", - "Iteration 5, norm = 0.035146969229970175\n", - "Iteration 6, norm = 0.003125584242156337\n", - "Iteration 7, norm = 2.227371173806294e-6\n", - "Iteration 8, norm = 2.1397676611257455e-10\n", - "Converged.\n" - ] - }, - { - "data": { - "text/plain": [ - "2x6 Array{Float64,2}:\n", - " 0.0 -0.106192 -1.69115 0.0 -0.761252 -2.48604\n", - " 0.0 -2.10509 -6.00728 0.0 -1.89221 -5.5914 " - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function solve!(u, free_dofs; max_iterations=10, eps=1.0e-7)\n", - " ∇R = Lin(assemble!)\n", - " Kt = zeros(ndim*nnodes, ndim*nnodes)\n", - " R = zeros(size(u))\n", - " println(\"Starting Newton iterations\")\n", - " for i=1:max_iterations\n", - " print(\"Iteration \",i, \", \")\n", - " R[:] = 0.0\n", - " assemble!(u, R) # Calculate internal energy in nodes and store results to R\n", - " ∇R(u, Kt) # Linearize residual in u and save result to Kt\n", - " # Solve !\n", - " du = Kt[free_dofs, free_dofs] \\ -R[free_dofs]\n", - " u[free_dofs] += du\n", - " println(\"norm = \",norm(du))\n", - " if norm(du) < eps\n", - " println(\"Converged.\")\n", - " break\n", - " end\n", - " end\n", - " return u\n", - "end\n", - "\n", - "u = zeros(ndim*nnodes)\n", - "solve!(u, free_dofs)\n", - "u = reshape(u, ndim, nnodes)\n", - "u" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "elapsed time: 4.541729719 seconds\n" - ] - }, - { - "data": { - "text/plain": [ - "4.541729719" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "toc()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.3.8", - "language": "julia", - "name": "julia-0.3" - }, - "language_info": { - "name": "julia", - "version": "0.3.8" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-06-15-performance-studies.ipynb b/notebooks/2015-06-15-performance-studies.ipynb deleted file mode 100644 index b375a49..0000000 --- a/notebooks/2015-06-15-performance-studies.ipynb +++ /dev/null @@ -1,382 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Compare analytical and autodiffed stiffness matrix\n", - "\n", - "Here we compare how much autodiffed solution is slower than analytical.\n", - "\n", - "Author(s): Jukka Aho \n", - "\n", - "Last updated:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2015-06-15" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using Dates\n", - "today()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "160" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using ForwardDiff\n", - "ENV[\"COLUMNS\"] = 160" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(36.0,24.0)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Partial derivatives of bilinear Lagrange polynomials\n", - "dNdξ(ξ) = [[-(1-ξ[2])/4.0 -(1-ξ[1])/4.0],\n", - " [ (1-ξ[2])/4.0 -(1+ξ[1])/4.0],\n", - " [ (1+ξ[2])/4.0 (1+ξ[1])/4.0],\n", - " [-(1+ξ[2])/4.0 (1-ξ[1])/4.0]] \n", - "\n", - "a = 1/sqrt(3)\n", - "ipoints = [[-a -a], [a -a], [a a], [-a a]]\n", - "iweights = [1 1 1 1]\n", - "\n", - "E = 90\n", - "ν = 0.25\n", - "μ = E/(2*(1+ν))\n", - "λ = E*ν/((1+ν)*(1-2*ν))\n", - "λ = 2*λ*μ/(λ + 2*μ)\n", - "μ, λ" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Version using automatic differentiation" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "calc_local_matrices! (generic function with 1 method)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function calc_local_matrices!(X, u, R, Kt; dim=2)\n", - " I = eye(dim)\n", - " \n", - " function calc_Wint!(u, Wint)\n", - " for m = 1:length(iweights)\n", - " w = iweights[m]\n", - " ξ = ipoints[m, :]\n", - " Jᵀ = X*dNdξ(ξ)\n", - " ∇N = inv(Jᵀ)*dNdξ(ξ)'\n", - " ∇u = u*∇N'\n", - " F = I + ∇u # Deformation gradient\n", - " E = 1/2*(∇u' + ∇u + ∇u'*∇u) # Green-Lagrange strain tensor\n", - " S = λ*trace(E)*I + 2*μ*E # PK2 stress tensor\n", - " P = F*S # PK1 stress tensor\n", - " Wint[:,:] += w*P*∇N*det(Jᵀ)\n", - " end\n", - " end\n", - "\n", - " # herlper for tangent stiffness matrix\n", - " function R!(u, R)\n", - " R[:] = 0\n", - " calc_Wint!(reshape(u, 2, 4), reshape(R, 2, 4))\n", - " #calc_Wext!(reshape(u, 2, 4), reshape(R, 2, 4))\n", - " end\n", - " Jacobian = ForwardDiff.forwarddiff_jacobian(R!, Float64, fadtype=:dual, n=8, m=8)\n", - "\n", - " Kt[:,:] = Jacobian(reshape(u, 8))\n", - " R!(reshape(u, 8), reshape(R, 8))\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converged in 6 iterations\n", - "[0.0 -0.3991450609547433 -0.07228582695592461 0.0\n", - " 0.0 -2.1779892317073504 -2.222244754401764 0.0]\n" - ] - } - ], - "source": [ - "# validation\n", - "X = [0 0; 10 0; 10 1; 0 1]'\n", - "u = zeros(2,4)\n", - "R = zeros(2,4)\n", - "Kt = zeros(8,8)\n", - "\n", - "free_dofs = [3, 4, 5, 6]\n", - "for i in 1:10\n", - " calc_local_matrices!(X, u, R, Kt)\n", - " R[2,3] += 2\n", - " du = Kt[free_dofs, free_dofs] \\ -reshape(R, 8)[free_dofs]\n", - " u[free_dofs] += du\n", - " if norm(du) < 1.0e-9\n", - " println(\"Converged in \", i, \" iterations\")\n", - " break\n", - " end\n", - "end\n", - "println(u)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "function test_algo1(N=10000)\n", - " for i=1:N\n", - " calc_local_matrices!(X, u, R, Kt)\n", - " end\n", - "end\n", - "test_algo1()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "elapsed time: 11.336512664 seconds (2020893880 bytes allocated, 26.15% gc time)\n" - ] - } - ], - "source": [ - "@time test_algo1()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Analytical tangent stiffness" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "calc_local_matrices2! (generic function with 1 method)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function calc_local_matrices2!(X, u, R, Kt; dim=2)\n", - " I = eye(dim)\n", - " R[:,:] = 0.0\n", - " Kt[:,:] = 0.0\n", - " N = 4 # number of shape functions\n", - "\n", - " dF = zeros(2, 2)\n", - "\n", - " for m = 1:length(iweights)\n", - " w = iweights[m]\n", - " ξ = ipoints[m, :]\n", - " Jᵀ = X*dNdξ(ξ)\n", - " detJ = det(Jᵀ)\n", - " ∇N = inv(Jᵀ)*dNdξ(ξ)'\n", - " ∇u = u*∇N'\n", - " F = I + ∇u # Deformation gradient\n", - " E = 1/2*(∇u' + ∇u + ∇u'*∇u) # Green-Lagrange strain tensor\n", - " S = λ*trace(E)*I + 2*μ*E # PK2 stress tensor\n", - " P = F*S # PK1 stress tensor\n", - " R[:,:] += w*P*∇N*detJ\n", - "\n", - " for p = 1:N\n", - " for i = 1:dim\n", - " dF[:,:] = 0.0\n", - " dF[i,:] = ∇N[:,p]\n", - " dE = 1/2*(F'*dF + dF'*F)\n", - " dS = λ*trace(dE)*I + 2*μ*dE\n", - " dP = dF*S + F*dS\n", - " for q = 1:N\n", - " for j = 1:dim\n", - " Kt[dim*(p-1)+i,dim*(q-1)+j] += w*(dP[j,:]*∇N[:,q])[1]*detJ\n", - " end\n", - " end\n", - " end\n", - " end\n", - "\n", - " end\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converged in 6 iterations\n", - "[0.0 -0.39914506095474317 -0.07228582695592449 0.0\n", - " 0.0 -2.1779892317073504 -2.222244754401764 0.0]\n" - ] - } - ], - "source": [ - "# validation\n", - "X = [0 0; 10 0; 10 1; 0 1]'\n", - "u = zeros(2,4)\n", - "R = zeros(2,4)\n", - "Kt = zeros(8,8)\n", - "\n", - "free_dofs = [3, 4, 5, 6]\n", - "for i in 1:10\n", - " calc_local_matrices2!(X, u, R, Kt)\n", - " R[2,3] += 2\n", - " du = Kt[free_dofs, free_dofs] \\ -reshape(R, 8)[free_dofs]\n", - " u[free_dofs] += du\n", - " if norm(du) < 1.0e-9\n", - " println(\"Converged in \", i, \" iterations\")\n", - " break\n", - " end\n", - "end\n", - "println(u)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "function test_algo2(N=10000)\n", - " for i=1:N\n", - " calc_local_matrices2!(X, u, R, Kt)\n", - " end\n", - "end\n", - "test_algo2()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "elapsed time: 8.447644445 seconds (1554800080 bytes allocated, 29.45% gc time)\n" - ] - } - ], - "source": [ - "@time test_algo2()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.3.8", - "language": "julia", - "name": "julia-0.3" - }, - "language_info": { - "name": "julia", - "version": "0.3.8" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-06-16-iterative-solvers.ipynb b/notebooks/2015-06-16-iterative-solvers.ipynb deleted file mode 100644 index 6170204..0000000 --- a/notebooks/2015-06-16-iterative-solvers.ipynb +++ /dev/null @@ -1,232 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Iterative solvers, numerical study of convergence\n", - "\n", - "Author(s): Jukka.Aho \n", - "\n", - "##Abstract\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Loading help data...\n" - ] - } - ], - "source": [ - "using PyPlot" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "endpoint of true solution: 0.5000000000000506\n", - "Reference norm: 3.182045987352757\n" - ] - } - ], - "source": [ - "N = 200\n", - "A = N*full(Tridiagonal(-ones(N-1), 2*ones(N), -1*ones(N-1)))\n", - "A[end,end] -= N\n", - "b = -1/N*ones(N)\n", - "b[end] += 1 + 1/(2*N)\n", - "x_true = A\\b\n", - "println(\"endpoint of true solution: \", x_true[end])\n", - "rnorm = norm(A\\b, 2)\n", - "println(\"Reference norm: \", rnorm)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Jacobi method" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "function solve_Jacobi(A, b, max_iterations=3000)\n", - " N = length(b)\n", - " R = A-diagm(diag(A))\n", - " invD = diagm(1./diag(A))\n", - " x = zeros(N)\n", - " norms = []\n", - " for i=1:max_iterations\n", - " x = invD*(b-R*x)\n", - " norms = [norms; norm(x)]\n", - " end\n", - " return x, norms\n", - "end\n", - "x_jacobi, norms_jacobi = solve_Jacobi(A, b);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Richardson method\n", - "\n", - "- is equivalent with deepest descent method for min 1/2*x'*A*x - b'x" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "function solve_Richardson(A, b, max_iterations=3000)\n", - " N = length(b)\n", - " x = zeros(N)\n", - " norms = []\n", - " la = sort(eigvals(A), rev=true)\n", - " wopt = 2/(maximum(la)+minimum(la))\n", - " # modification, remove wave of smallest and largest eigenvalue because they are anyway calculated.\n", - " # this increases convergence a bit\n", - " for i = 1:1\n", - " x = x - 1/la[i]*(A*x - b)\n", - " x = x - 1/la[end-i]*(A*x - b)\n", - " end\n", - " for i=1:max_iterations\n", - " x = x - wopt*(A*x - b)\n", - " norms = [norms; norm(x)]\n", - " end\n", - " return x, norms\n", - "end\n", - "\n", - "x_richardson, norms_richardson = solve_Richardson(A, b);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Conjugate gradient\n", - "## Successive over-relaxation\n", - "## GMRES\n", - "## MINRES" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Summary" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "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" - ], - "text/plain": [ - "Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(norms_jacobi, label=\"Jacobi\")\n", - "plot(norms_richardson, label=\"Richardson\")\n", - "plot([0, length(norms_jacobi)], [rnorm, rnorm], label=\"True\")\n", - "#ylim(0, 5)\n", - "legend()\n", - "title(\"Convergence\")\n", - "xlabel(\"iterations N\")\n", - "ylabel(\"L2 norm\")\n", - "grid()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "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" - ], - "text/plain": [ - "Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(x_jacobi, label=\"Jacobi\")\n", - "plot(x_richardson, label=\"Richardon\")\n", - "plot(A\\b, label=\"True\")\n", - "legend(loc=\"best\")\n", - "title(\"Solution x\")\n", - "grid()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.3.8", - "language": "julia", - "name": "julia-0.3" - }, - "language_info": { - "name": "julia", - "version": "0.3.8" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-06-20-export-to-xdmf.ipynb b/notebooks/2015-06-20-export-to-xdmf.ipynb deleted file mode 100644 index 3475f0f..0000000 --- a/notebooks/2015-06-20-export-to-xdmf.ipynb +++ /dev/null @@ -1,426 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exporting data to Xdmf format\n", - "\n", - "Author(s): Jukka Aho \n", - "\n", - "Python example how to export data to Xdmf format using Python" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import sys\n", - "import os\n", - "sys.path.append(os.path.expanduser('~/opt/xdmf/lib/python'))" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from Xdmf import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Export mesh" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "grid = XdmfUnstructuredGrid.New()\n", - "grid.setTime(XdmfTime.New(123))\n", - "geometry = XdmfGeometry.New()\n", - "topology = XdmfTopology.New()\n", - "geometry.setType(XdmfGeometryType.XYZ())\n", - "topology.setType(XdmfTopologyType.Mixed())" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0., 0., 0.],\n", - " [ 1., 0., 0.],\n", - " [ 0., 1., 0.],\n", - " [ 0., 0., 1.]])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "# one linear tetra\n", - "nodes = np.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])\n", - "nodes" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It needs to be in 1d list:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(nodes.flatten())" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "geometry.insertAsFloat32(0, list(nodes.flatten()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Topology; connect nodes 1 - 4 to form tetra\n", - "\n", - "List is here:\n", - "\n", - "http://public.kiteware.com/pipermail/2013-July/028859.html" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "topology.insertAsInt32(0, [0x6, 1, 2, 3, 4]) # Not sure starts this from 0 or 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**update**, node numbering starts from 0." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "grid.setGeometry(geometry)\n", - "grid.setTopology(topology)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Export fields" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Give scalar value to cells (i.e. elements)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "temperature = XdmfAttribute.New()\n", - "temperature.setType(XdmfAttributeType.Scalar())\n", - "temperature.setCenter(XdmfAttributeCenter.Cell())\n", - "temperature.setName(\"Temperature field\")\n", - "temperature.insertAsInt32(0, [56])\n", - "grid.insert(temperature)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Give vector values to nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "density = XdmfAttribute.New()\n", - "density.setType(XdmfAttributeType.Vector())\n", - "density.setCenter(XdmfAttributeCenter.Node())\n", - "density.setName(\"Density\")\n", - "density.insertAsFloat32(0, [1.3, 2.4, 4.5, 6.7])\n", - "grid.insert(density)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Write to file" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "I think this is not mandatory but create temporal collection anyway:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "coll = XdmfGridCollection.New()\n", - "coll.setType(XdmfGridCollectionType.Temporal())\n", - "coll.insert(grid)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create domain and write to disk" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "domain = XdmfDomain.New()\n", - "domain.insert(coll)\n", - "writer = XdmfWriter.New(\"testdata.xmf\")\n", - "domain.accept(writer)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "testdata.h5 testdata.xmf\r\n" - ] - } - ], - "source": [ - "!ls testdata*" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r\n", - "\r\n", - " \r\n", - " \r\n", - " \r\n", - " \r\n", - " \r\n", - " \r\n", - " \r\n", - " \r\n", - "\r\n" - ] - } - ], - "source": [ - "!cat testdata.xmf" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This time Xdmf decided to write results directly to the xml file. If the model is bigger the correct format is" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "\n", - "Structure of h5 file\n", - "\n", - "\n", - " File(filename=model.h5, title='', mode='r+', root_uep='/', filters=Filters(complevel=0, shuffle=False, fletcher32=False, least_significant_digit=None)) \n", - " / (RootGroup) '' \n", - " /Data0 (EArray(1125135,)) ''\n", - " atom := Float32Atom(shape=(), dflt=0.0)\n", - " maindim := 0 \n", - " flavor := 'numpy' \n", - " byteorder := 'little' \n", - " chunkshape := (1000,) \n", - " /Data1 (EArray(2680009,)) ''\n", - " atom := Int32Atom(shape=(), dflt=0)\n", - " maindim := 0 \n", - " flavor := 'numpy' \n", - " byteorder := 'little' \n", - " chunkshape := (1000,) \n", - " ...\n", - "\n", - "\n", - " In [7]: d.root.Data0[:]\n", - " Out[7]:\n", - " array([ 302.10440063, 222.19999695, 20.38028908, ..., -230. ,\n", - " 0. , 7.33333015], dtype=float32)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.9" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-06-25-shape-functions.ipynb b/notebooks/2015-06-25-shape-functions.ipynb deleted file mode 100644 index 3113e17..0000000 --- a/notebooks/2015-06-25-shape-functions.ipynb +++ /dev/null @@ -1,530 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Shape function and integration points\n", - "\n", - "Author(s): Jukka Aho\n", - "\n", - "**Abstract**: Shape functions and element descriptions used in JuliaFEM." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from sympy import *\n", - "#init_printing()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "xi = DeferredVector(r\"xi\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1D shape function" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Linear 2-node segment (Lagrange family)\n", - "\n", - "| | $\\xi_1$ |\n", - "| ----- | -------:|\n", - "| $N_1$ | -1 |\n", - "| $N_2$ | 1 |\n", - "\n", - "\\begin{equation}\n", - " \\left(\\mathbf{P}\\boldsymbol{\\alpha}\\right)\\left(\\xi_1\\right) = \\alpha_{1}+\\alpha_{2}\\xi_{1}\n", - "\\end{equation}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(Matrix([\n", - " [-xi[1]/2 + 1/2],\n", - " [ xi[1]/2 + 1/2]]), Matrix([\n", - " [-1/2],\n", - " [ 1/2]]))" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A = Matrix([[1, -1], [1, 1]])\n", - "P = Matrix([1, xi[1]]).T\n", - "N = (P*A.inv()).T\n", - "dN = Matrix([N.diff(xi[1]).T]).T\n", - "N, dN" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Quadratic 3-node segment (Lagrange family)\n", - "\n", - "| | $\\xi_1$ |\n", - "| ----- | -------:|\n", - "| $N_1$ | -1 |\n", - "| $N_2$ | 1 |\n", - "| $N_3$ | 0 |\n", - "\n", - "\\begin{equation}\n", - " \\left(\\mathbf{P}\\boldsymbol{\\alpha}\\right)\\left(\\xi_1\\right) = \\alpha_1 + \\alpha_2\\xi_1 + \\alpha_3\\xi_1^2\n", - "\\end{equation}" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(Matrix([\n", - " [xi[1]**2/2 - xi[1]/2],\n", - " [xi[1]**2/2 + xi[1]/2],\n", - " [ -xi[1]**2 + 1]]), Matrix([\n", - " [xi[1] - 1/2],\n", - " [xi[1] + 1/2],\n", - " [ -2*xi[1]]]))" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A = Matrix([[1, -1, (-1)**2],\n", - " [1, 1, 1**2],\n", - " [1, 0, 0**2]])\n", - "P = Matrix([1, xi[1], xi[1]**2]).T\n", - "N = (P*A.inv()).T\n", - "dN = Matrix([N.diff(xi[1]).T]).T\n", - "N, dN" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### P-elements" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2D shape functions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Linear triangle\n", - "\n", - "| | $\\xi_1$ | $\\xi_2$ |\n", - "| ----- | -------:| -------:|\n", - "| $N_1$ | 0 | 0 |\n", - "| $N_2$ | 1 | 0 |\n", - "| $N_3$ | 0 | 1 |" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(Matrix([\n", - " [-xi[1] - xi[2] + 1],\n", - " [ xi[1]],\n", - " [ xi[2]]]), Matrix([\n", - " [-1, -1],\n", - " [ 1, 0],\n", - " [ 0, 1]]))" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A = Matrix([[1, 0, 0], [1, 1, 0], [1, 0, 1]])\n", - "P = Matrix([1, xi[1], xi[2]]).T\n", - "N = (P*A.inv()).T\n", - "dN = Matrix([N.diff(xi[1]).T, N.diff(xi[2]).T]).T\n", - "N, dN" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Quadratic triangle\n", - "\n", - "| | $\\xi_1$ | $\\xi_2$ |\n", - "| ----- | -------:| -------:|\n", - "| $N_1$ | 0 | 0 |\n", - "| $N_2$ | 1 | 0 |\n", - "| $N_3$ | 0 | 1 |\n", - "| $N_4$ | 1/2 | 0 |\n", - "| $N_5$ | 1/2 | 1/2 |\n", - "| $N_6$ | 0 | 1/2 |" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Matrix([\n", - "[1, 0, 0, 0, 0, 0],\n", - "[1, 1, 0, 1, 0, 0],\n", - "[1, 0, 1, 0, 1, 0],\n", - "[1, 1/2, 0, 1/4, 0, 0],\n", - "[1, 1/2, 1/2, 1/4, 1/4, 1/4],\n", - "[1, 0, 1/2, 0, 1/4, 0]])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "P = Matrix([1, xi[1], xi[2], xi[1]**2, xi[2]**2, xi[1]*xi[2]]).T\n", - "A = Matrix([\n", - " P.subs({xi[1]: 0, xi[2]: 0}),\n", - " P.subs({xi[1]: 1, xi[2]: 0}),\n", - " P.subs({xi[1]: 0, xi[2]: 1}),\n", - " P.subs({xi[1]: Rational(1,2), xi[2]: 0}),\n", - " P.subs({xi[1]: Rational(1,2), xi[2]: Rational(1,2)}),\n", - " P.subs({xi[1]: 0, xi[2]: Rational(1,2)}),\n", - " ])\n", - "A" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(Matrix([\n", - " [2*xi[1]**2 + 4*xi[1]*xi[2] - 3*xi[1] + 2*xi[2]**2 - 3*xi[2] + 1],\n", - " [ 2*xi[1]**2 - xi[1]],\n", - " [ 2*xi[2]**2 - xi[2]],\n", - " [ -4*xi[1]**2 - 4*xi[1]*xi[2] + 4*xi[1]],\n", - " [ 4*xi[1]*xi[2]],\n", - " [ -4*xi[1]*xi[2] - 4*xi[2]**2 + 4*xi[2]]]), Matrix([\n", - " [ 4*xi[1] + 4*xi[2] - 3, 4*xi[1] + 4*xi[2] - 3],\n", - " [ 4*xi[1] - 1, 0],\n", - " [ 0, 4*xi[2] - 1],\n", - " [-8*xi[1] - 4*xi[2] + 4, -4*xi[1]],\n", - " [ 4*xi[2], 4*xi[1]],\n", - " [ -4*xi[2], -4*xi[1] - 8*xi[2] + 4]]))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "N = (P*A.inv()).T\n", - "dN = Matrix([N.diff(xi[1]).T, N.diff(xi[2]).T]).T\n", - "N, dN" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3D shape functions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Linear tetrahedra, **tet4**\n", - "\n", - "| | $\\xi_1$ | $\\xi_2$ | $\\xi_2$ |\n", - "| ----- | -------:| -------:| -------:|\n", - "| $N_1$ | 0 | 0 | 0 |\n", - "| $N_2$ | 1 | 0 | 0 |\n", - "| $N_3$ | 0 | 1 | 0 |\n", - "| $N_4$ | 0 | 0 | 1 |" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Matrix([\n", - "[1, 0, 0, 0],\n", - "[1, 1, 0, 0],\n", - "[1, 0, 1, 0],\n", - "[1, 0, 0, 1]])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "P = Matrix([1, xi[1], xi[2], xi[3]]).T\n", - "A = Matrix([\n", - " P.subs({xi[1]: 0, xi[2]: 0, xi[3]: 0}),\n", - " P.subs({xi[1]: 1, xi[2]: 0, xi[3]: 0}),\n", - " P.subs({xi[1]: 0, xi[2]: 1, xi[3]: 0}),\n", - " P.subs({xi[1]: 0, xi[2]: 0, xi[3]: 1}),\n", - " ])\n", - "A" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(Matrix([\n", - " [-xi[1] - xi[2] - xi[3] + 1],\n", - " [ xi[1]],\n", - " [ xi[2]],\n", - " [ xi[3]]]), Matrix([\n", - " [-1, -1, -1],\n", - " [ 1, 0, 0],\n", - " [ 0, 1, 0],\n", - " [ 0, 0, 1]]))" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "N = (P*A.inv()).T\n", - "dN = Matrix([N.diff(xi[1]).T, N.diff(xi[2]).T, N.diff(xi[3]).T]).T\n", - "N, dN" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Quadratic Lagrange tetrahedral element, 10 nodes, **tet10**\n", - "\n", - "| | $\\xi_1$ | $\\xi_2$ | $\\xi_2$ |\n", - "| ----- | -------:| -------:| -------:|\n", - "| $N_1$ | 0 | 0 | 0 |\n", - "| $N_2$ | 1 | 0 | 0 |\n", - "| $N_3$ | 0 | 1 | 0 |\n", - "| $N_4$ | 0 | 0 | 1 |\n", - "| $N_5$ | 1/2 | 0 | 0 |\n", - "| $N_6$ | 1/2 | 1/2 | 0 |\n", - "| $N_7$ | 0 | 1/2 | 0 |\n", - "| $N_8$ | 0 | 0 | 1/2 |\n", - "| $N_9$ | 1/2 | 0 | 1/2 |\n", - "| $N_{10}$ | 0 | 1/2 | 1/2 |" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Matrix([\n", - "[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - "[1, 1, 0, 0, 1, 0, 0, 0, 0, 0],\n", - "[1, 0, 1, 0, 0, 0, 1, 0, 0, 0],\n", - "[1, 0, 0, 1, 0, 0, 0, 0, 1, 0],\n", - "[1, 1/2, 0, 0, 1/4, 0, 0, 0, 0, 0],\n", - "[1, 1/2, 1/2, 0, 1/4, 1/4, 1/4, 0, 0, 0],\n", - "[1, 0, 1/2, 0, 0, 0, 1/4, 0, 0, 0],\n", - "[1, 0, 0, 1/2, 0, 0, 0, 0, 1/4, 0],\n", - "[1, 1/2, 0, 1/2, 1/4, 0, 0, 0, 1/4, 1/4],\n", - "[1, 0, 1/2, 1/2, 0, 0, 1/4, 1/4, 1/4, 0]])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "P = Matrix([1, xi[1], xi[2], xi[3], xi[1]**2, xi[1]*xi[2], xi[2]**2, xi[2]*xi[3], xi[3]**2, xi[1]*xi[3]]).T\n", - "A = Matrix([\n", - " P.subs({xi[1]: 0, xi[2]: 0, xi[3]: 0}),\n", - " P.subs({xi[1]: 1, xi[2]: 0, xi[3]: 0}),\n", - " P.subs({xi[1]: 0, xi[2]: 1, xi[3]: 0}),\n", - " P.subs({xi[1]: 0, xi[2]: 0, xi[3]: 1}),\n", - "\n", - " P.subs({xi[1]: Rational(1,2), xi[2]: 0, xi[3]: 0}),\n", - " P.subs({xi[1]: Rational(1,2), xi[2]: Rational(1,2), xi[3]: 0}),\n", - " P.subs({xi[1]: 0, xi[2]: Rational(1,2), xi[3]: 0}),\n", - "\n", - " P.subs({xi[1]: 0, xi[2]: 0, xi[3]: Rational(1,2)}),\n", - " P.subs({xi[1]: Rational(1,2), xi[2]: 0, xi[3]: Rational(1,2)}),\n", - " P.subs({xi[1]: 0, xi[2]: Rational(1,2), xi[3]: Rational(1,2)}),\n", - " ])\n", - "A" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Matrix([\n", - "[(xi[1] + xi[2] + xi[3] - 1)*(2*xi[1] + 2*xi[2] + 2*xi[3] - 1)],\n", - "[ xi[1]*(2*xi[1] - 1)],\n", - "[ xi[2]*(2*xi[2] - 1)],\n", - "[ xi[3]*(2*xi[3] - 1)],\n", - "[ -4*xi[1]*(xi[1] + xi[2] + xi[3] - 1)],\n", - "[ 4*xi[1]*xi[2]],\n", - "[ -4*xi[2]*(xi[1] + xi[2] + xi[3] - 1)],\n", - "[ -4*xi[3]*(xi[1] + xi[2] + xi[3] - 1)],\n", - "[ 4*xi[1]*xi[3]],\n", - "[ 4*xi[2]*xi[3]]])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "N = (P*A.inv()).T\n", - "dN = Matrix([N.diff(xi[1]).T, N.diff(xi[2]).T, N.diff(xi[3]).T]).T\n", - "factor(N)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Matrix([\n", - "[ 4*xi[1] + 4*xi[2] + 4*xi[3] - 3, 4*xi[1] + 4*xi[2] + 4*xi[3] - 3, 4*xi[1] + 4*xi[2] + 4*xi[3] - 3],\n", - "[ 4*xi[1] - 1, 0, 0],\n", - "[ 0, 4*xi[2] - 1, 0],\n", - "[ 0, 0, 4*xi[3] - 1],\n", - "[-4*(2*xi[1] + xi[2] + xi[3] - 1), -4*xi[1], -4*xi[1]],\n", - "[ 4*xi[2], 4*xi[1], 0],\n", - "[ -4*xi[2], -4*(xi[1] + 2*xi[2] + xi[3] - 1), -4*xi[2]],\n", - "[ -4*xi[3], -4*xi[3], -4*(xi[1] + xi[2] + 2*xi[3] - 1)],\n", - "[ 4*xi[3], 0, 4*xi[1]],\n", - "[ 0, 4*xi[3], 4*xi[2]]])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "factor(dN)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.10" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-06-30-parallel-solution-using-substructuring.ipynb b/notebooks/2015-06-30-parallel-solution-using-substructuring.ipynb deleted file mode 100644 index b22db81..0000000 --- a/notebooks/2015-06-30-parallel-solution-using-substructuring.ipynb +++ /dev/null @@ -1,601 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Parallel solution of problem using substructuring and static condensation of internal nodes\n", - "\n", - "Author(s): Jukka Aho \n", - "\n", - "**Abstract**: First ideas of going towards parallel solution" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Substructuring and static condensation\n", - "\n", - "Let us again consider something as simple as possible to give idea of algorithm, e.g. 1d poisson equation with homogeneous Dirichlet boundary condition and Neumann boundary condition in other end.\n", - "\n", - "\\begin{equation}\n", - "u'' = 0 \\quad u(0)=0 \\quad u'(2)=1\n", - "\\end{equation}\n", - "\n", - "Accurate solution is $u(x) = x$.\n", - "\n", - "We discretize this to to elements and have three nodes therefore. Discretized solution is" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "3-element Array{Float64,1}:\n", - " 0.0\n", - " 1.0\n", - " 2.0" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A = [1 -1 0; -1 2 -1; 0 -1 1]\n", - "f = [0, 0, 1]\n", - "free_dofs = [2, 3]\n", - "u = zeros(3)\n", - "u[free_dofs] = A[free_dofs, free_dofs]\\f[free_dofs]\n", - "u" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We call middle to node to interior node and left and right node to boundary nodes, i.e." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "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" - ], - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "using PyPlot\n", - "figure(figsize=(5, 1))\n", - "plot([0, 1, 2], [0, 0, 0], \"k\")\n", - "plot([0, 2], [0, 0], \"ro\", label=\"Boundary nodes\")\n", - "plot([1], [0], \"bo\", label=\"Interior nodes\")\n", - "legend(loc=5, prop=Dict(\"size\" => 10))\n", - "xlim(-0.2, 5.2)\n", - "axis(\"off\");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Static condensation. We define two sets of nodes, $I$ for interior nodes and $B$ for boundary nodes, so the equation in block-matrix form is now\n", - "\n", - "\\begin{equation}\n", - "\\mathbf{A}=\\left[\\begin{array}{cc}\n", - "\\mathbf{A}_{\\mathrm{II}} & \\mathbf{A}_{\\mathrm{IB}}\\\\\n", - "\\mathbf{A}_{\\mathrm{BI}} & \\mathbf{A}_{\\mathrm{BB}}\n", - "\\end{array}\\right]\\quad\\mathbf{u}=\\left[\\begin{array}{c}\n", - "\\mathbf{u}_{\\mathrm{I}}\\\\\n", - "\\mathbf{u}_{\\mathrm{B}}\n", - "\\end{array}\\right]\\quad\\mathbf{f}=\\left[\\begin{array}{c}\n", - "\\mathbf{f}_{\\mathbf{I}}\\\\\n", - "\\mathbf{f}_{\\mathbf{B}}\n", - "\\end{array}\\right]\n", - "\\end{equation}\n", - "\n", - "After matrix algebra we end up to\n", - "\n", - "\\begin{eqnarray}\n", - "\\mathbf{A}_{\\mathrm{II}}\\mathbf{u}_{\\mathrm{I}}+\\mathbf{A}_{\\mathrm{IB}}\\mathbf{u}_{\\mathrm{B}} & = & \\mathbf{f}_{\\mathbf{I}}\\\\\n", - "\\mathbf{A}_{\\mathrm{BI}}\\mathbf{u}_{\\mathrm{I}}+\\mathbf{A}_{\\mathrm{BB}}\\mathbf{u}_{\\mathrm{B}} & = & \\mathbf{f}_{\\mathbf{B}}\n", - "\\end{eqnarray}\n", - "\n", - "\\begin{equation}\n", - "\\mathbf{u}_{\\mathrm{I}}=\\mathbf{A}_{\\mathrm{II}}^{-1}\\left(\\mathbf{f}_{\\mathbf{I}}-\\mathbf{A}_{\\mathrm{IB}}\\mathbf{u}_{\\mathrm{B}}\\right)\n", - "\\end{equation}\n", - "\n", - "\\begin{equation}\n", - "\\mathbf{A}_{\\mathrm{BI}}\\mathbf{u}_{\\mathrm{I}}+\\mathbf{A}_{\\mathrm{BB}}\\mathbf{u}_{\\mathrm{B}}=\\mathbf{A}_{\\mathrm{BI}}\\left(\\mathbf{A}_{\\mathrm{II}}^{-1}\\left(\\mathbf{f}_{\\mathbf{I}}-\\mathbf{A}_{\\mathrm{IB}}\\mathbf{u}_{\\mathrm{B}}\\right)\\right)+\\mathbf{A}_{\\mathrm{BB}}\\mathbf{u}_{\\mathrm{B}}=\\mathbf{f}_{\\mathbf{B}}\n", - "\\end{equation}\n", - "\n", - "\\begin{equation}\n", - "\\mathbf{A}_{\\mathrm{BI}}\\left(\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{f}_{\\mathbf{I}}-\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{A}_{\\mathrm{IB}}\\mathbf{u}_{\\mathrm{B}}\\right)+\\mathbf{A}_{\\mathrm{BB}}\\mathbf{u}_{\\mathrm{B}}=\\mathbf{f}_{\\mathbf{B}}\n", - "\\end{equation}\n", - "\n", - "\\begin{equation}\n", - "\\mathbf{A}_{\\mathrm{BI}}\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{f}_{\\mathbf{I}}-\\mathbf{A}_{\\mathrm{BI}}\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{A}_{\\mathrm{IB}}\\mathbf{u}_{\\mathrm{B}}+\\mathbf{A}_{\\mathrm{BB}}\\mathbf{u}_{\\mathrm{B}}=\\mathbf{f}_{\\mathbf{B}}\n", - "\\end{equation}\n", - "\n", - "\\begin{equation}\n", - "\\mathbf{A}_{\\mathrm{BB}}\\mathbf{u}_{\\mathrm{B}}-\\mathbf{A}_{\\mathrm{BI}}\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{A}_{\\mathrm{IB}}\\mathbf{u}_{\\mathrm{B}}=\\mathbf{f}_{\\mathbf{B}}-\\mathbf{A}_{\\mathrm{BI}}\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{f}_{\\mathbf{I}}\n", - "\\end{equation}\n", - "\n", - "\\begin{equation}\n", - "\\left(\\mathbf{A}_{\\mathrm{BB}}-\\mathbf{A}_{\\mathrm{BI}}\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{A}_{\\mathrm{IB}}\\right)\\mathbf{u}_{\\mathrm{B}}=\\mathbf{f}_{\\mathbf{B}}-\\mathbf{A}_{\\mathrm{BI}}\\mathbf{A}_{\\mathrm{II}}^{-1}\\mathbf{f}_{\\mathbf{I}}\n", - "\\end{equation}\n", - "\n", - "\\begin{equation}\n", - "\\mathbf{A}_{\\mathrm{C}}=\\mathbf{f}_{\\mathrm{C}}\n", - "\\end{equation}\n", - "\n", - "where interior nodes has been succesfully eliminated. So we first form condensated matrix $\\mathbf{A}_{\\mathrm{C}}$ and vector $\\mathbf{f}_{\\mathrm{C}}$" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x2 Array{Float64,2}:\n", - " 0.5 -0.5\n", - " -0.5 0.5" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "B = [1, 3]\n", - "I = [2]\n", - "Ac = A[B,B] - A[B,I]*inv(A[I,I])*A[I,B]\n", - "Ac" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2-element Array{Float64,1}:\n", - " 0.0\n", - " 1.0" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fc = f[B] - A[B,I]*inv(A[I,I])*f[I]\n", - "fc" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we solve the condensed system with interior node removed" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "3-element Array{Float64,1}:\n", - " 0.0\n", - " 0.0\n", - " 2.0" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "free_dofsc = [2] # free degrees of freedom in condensed system\n", - "u = zeros(3)\n", - "u[B[free_dofsc]] = Ac[free_dofsc, free_dofsc]\\fc[free_dofsc]\n", - "u" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we want to calculate field variable in interior node:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "3-element Array{Float64,1}:\n", - " 0.0\n", - " 1.0\n", - " 2.0" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "u[I] = inv(A[I,I])*(f[I] - A[I,B]*u[B])\n", - "u" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Of course we cannot take inverse of interior node matrix in real life applications, it's costs way too much.." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Parallel solution\n", - "\n", - "We can use exactly same concept as described earlier. We first remove interior nodes in subdomains and after that solve boundary system. Boundaries must be \"tied\" together with Lagrange multipliers, penalty method or something similar. This time we discretize the system to 4 elements and split it to two domains:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "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" - ], - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAc0AAACECAYAAADyZXANAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAFUhJREFUeJzt3X1UVHX+B/D3vWI8xIOEoFIqMhvCEIqAo+CmSOuSpYbmwZ/ZkcFyWU0zdxN7sNbHcmlzt87paJsnydhV08W1B7fEElcQ5CCGrMCCiIK7KWxntSMWj5/fH+BdLw9ylcHRfL/OmVMz33u/D7eJ98yd7/1eRUQERERE1C3V3h0gIiK6XTA0iYiIDGJoEhERGcTQJCIiMoihSUREZBBDk4iIyCCGJhERkUEMTSIiIoMYmkRERAYxNImIiAxiaBIRERnE0CQiIjKIoUlERGQQQ5OIiMgghiYREZFBDE0iIiKDGJpEREQGMTSJiIgMYmgSEREZxNAkIiIyiKFJRERkEEOTiIjIIIYmERGRQQxNIiIigxiaREREBjE0iYiIDGJoEhERGcTQJCIiMoihSUREZBBDk4iIyCCGJhERkUEMTSIiIoMYmkRERAY52LsDRPTjdvnyZZSWltq7G0QAgMDAQLi4uNzw/gxNIupVpaWlCA8Pt3c3iAAAR48eRVhY2A3vz9AkopsiLS0NQUFB9u4G3aFKSkrw5JNP9rgehiYR3RRBQUE9+oRPdCvgRCAiIiKDGJpEREQGMTSJiIgMYmgSEREZxNAkIroNnT59Gqqq4vjx4/buik2pqoqPP/7Y3t3oEkOTiOymtrYWyxIT8WhwMKYNH45Hg4OxLDERtbW1dq/ParVCVVXt0b9/f0yePBlFRUU31Df6ceAlJ0RkFzU1Nfi/qCi8VlGBFAAKgBYAecXFmHXoEHbk5MDb29tu9SmKgsmTJ2PLli0AgG+++QYrVqzAlClTcObMmesY6a2roaEBd911l727cVvhN00isos3li/HaxUVGIvWgANa/yCNBbCuogIpycl2rU9E4OjoCB8fH/j4+GDkyJFYvnw5qqur8e2332rbFRUVISYmBi4uLujfvz+SkpJQV1enlUdHR2Pp0qW6uuPi4pCYmKg99/Pzw+uvv4558+bB3d0dQ4cOxXvvvafbJy8vD6NGjYKzszNGjx6NY8eO6cpbWlrw1FNPwd/fHy4uLggMDMTbb7+t28ZqtWL69OlYt24d7r33XgQGBmLNmjUICQnpMP7Q0FD85je/6fTYZGZmQlVVfPXVV4iIiMDdd9+NcePGoaysTLfdxo0bYTKZ4OjoiMDAQKSlpenKy8vLMX78eDg7OyM4OBgZGRkd2qqurkZ8fDw8PT3h5eWFuLg43YeWzMxMWCwWuLq6wtPTEz/96U9RVVXVab9tgaFJRHZRnJeHMV2UjWkrt2d9QGtwXnHp0iWkpaXh/vvvh5eXFwCgrq4OsbGx8PLyQn5+Pnbu3In9+/dj0aJF2n6KokBRFF29nb325ptvwmKx4Ouvv8bChQuxYMECLYQuXbqEKVOm4IEHHkBBQQFWrlyJ559/Xrd/S0sLBg8ejF27dqGkpASvvvoqXnrpJezcuVO33Zdffony8nLs378fn332GebNm4eSkhLk5+dr2xw7dgxFRUW6YO/MihUr8Pvf/x75+flwcHDAvHnztLLdu3fjueeew7Jly3DixAkkJSUhMTERmZmZWn9nzJgBJycn5OXlYdOmTVi+fLmu/sbGRsTGxsLDwwNZWVk4fPgwXF1d8fDDD6OpqQlNTU2Ii4vDxIkTUVRUhNzcXCQlJXU4tjYlRES96OjRowJAjh49qnt9akCACNDlY2pAwHW1Y+v6EhISxMHBQVxdXcXV1VUURRFfX18pKCjQtvnjH/8o99xzj1y+fFl7be/evdKnTx+pqakREZHo6GhZunSpru64uDixWq3acz8/P5k7d65umwEDBsi7774rIiLvvvuu9O/fX+rr67XyTZs2iaIoUlhY2OUYnnnmGZk5c6ZuTIMGDZLGxkbddo888ogsXLhQe7548WKJiYnpst4DBw6Ioijy1Vdf6catKIrWx6ioKElKStLtFx8fL48++qiIiHzxxRfSt29f+eabb7Tyzz//XBRFkT179oiIyIcffiiBgYG6Ourr68XFxUUyMjLk22+/FUVR5ODBg1329Yqu3ofXi980icgumh0cIF2UtbSV27M+AIiJiUFhYSEKCwuRl5eH2NhYTJ48WTv9V1JSgtDQUDg7O2v7REVFoaWlBf/85z+vq60RI0bong8cOBA1NTVaOyNHjtT9/jh27NgOdbzzzjsIDw+Hj48P3Nzc8N5776G6ulq3TUhICBzaHYv58+dj27ZtaGhoQENDA7Zt26b71mikzwMHDgQArc+lpaUYN26cbvuoqCiUlJRoYxo8eLC2X2djKiwsxMmTJ+Hm5qY9vLy8UF9fj4qKCtxzzz2wWq2IjY3FtGnT8Pbbb+PcuXPd9rsnGJpEZBdmiwVHuig70lZuz/oAwMXFBf7+/vD390dERAQ2b96Muro6bN68WdtGpKuobqWqaodtGhoaOpxC7Nu3r+65oihoaWkx3M727duxbNkyzJ8/HxkZGSgsLERiYiLq6+s7jKm9KVOmwNHREenp6fjkk0/Q2NiImTNnXrO99n2+Mp6r+9xTly5dQnh4uPbB5cqjrKwMs2fPBgC8//77yMnJQVRUFHbs2IGAgAAcOdLVO6HnGJpEZBfJKSl4yWRCDlq/CaLtnzkAXjaZkJySYtf6AHT529j3338PADCbzSgsLMTly5e1suzsbKiqiuHDhwMAvL298e9//1srb25uxj/+8Y/r6ofZbMbx48d1AZibm6vbJjs7G1FRUfjlL3+JkSNHwt/fHydPnjT0+56DgwMSEhKwZcsWpKamYvbs2XB0dLyuPrYXFBSErKysDn0MDg7Wyqurq3XfDNuPKTw8HOXl5fD29tY+vFx5uLu7a9uFhobihRdeQHZ2Nh544AH8+c9/7lHfr4WhSUR24e3tjR05OUi3WjHVbMa0gABMNZuRbrVe9+UhvVEfAPzwww84f/48zp07h5KSEixevBjff/89pk6dCgCYM2cOnJyckJCQgBMnTuDAgQNYvHgx5s6dq7UXExODzz77DHv37kVpaSkWLFiAixcvdtv21d8sn3jiCSiKgvnz56O4uBh79+7F7373O932AQEByM/Px759+1BWVoZXXnkF+fn53X5DveLpp5/Gl19+ic8//9zQqdnuLFu2DKmpqdi0aRPKy8uxYcMG7N69W5vANGnSJAQEBCAhIQHHjx/HoUOH8PLLL+vqmDNnDvr374/HHnsMWVlZqKysRGZmJpYsWYJ//etfOH36NF588UXk5ubizJkz2LdvH8rLy2E2m3vc/y716BdRIqJu2GoCxs1mtVpFURTt4e7uLmPGjJH09HTddkVFRRITEyPOzs7i5eUlSUlJUldXp5U3NjbKwoULxcvLSwYOHCi//e1vJS4uThITE7Vt/Pz85K233tLVGxoaKqtWrdKe5+bmSmhoqDg6OkpYWJikp6eLqqraRKD6+npJTEyUfv36iaenpzzzzDPy4osvyqhRo3Rjmj59epdjfvDBByUkJKTbY3PgwAFRVVUuXryovXbs2DFRVVXOnDmjvbZx40YxmUxy1113SWBgoKSlpenqKSsrkwcffFAcHR0lMDBQvvjiC1FVVZsIJCJy7tw5SUhIEG9vb3FychKTySRJSUny3Xffyfnz52X69Oni6+srjo6O4ufnJytXrpSWlpYOfbbV+1ARMfgxhIjoBhQUFCA8PBxHjx7l/TRvYSKC+++/H4sWLcJzzz1n7+7YnK3eh1wR6Cq1tbVISU5GcV4e+jQ1odnBAWaLBckpKTd0asdom8nJKcjLK0ZTUx84ODTDYjEjJSW5V9u82eO0V7t30vElulG1tbXYvn07ampqur02847Xo++pPyLnz5+XiSaT5ADS0nZdVzMgOYBMNJm0a65s3abJNFGAHAFa2i4naxYgR0ymib3W5s0ep73avZOO763sdj09eydRFEV8fHxk27Zt9u5Kr7HV+5Ch2eZ5q1Vyurgo+jAgz191IbKtWK3Pt/1B76zZw2K1Pm/zNu0xTnu1eycd31sZQ5NuBbZ6H/L0bJvivDx0NSF9DIAVBw+ioKDApm0ePFgAXKPVgwdX2LzNgoMHrznOtTew1JgRPL69e3yJ6OZgaLbp09SErq5mUgGcraxEeHi4jVsNAK7RamXlWZu3ee0WW49Db+Dx7d3jS0Q3B0OzzZUluDr7g9cC4L5hw7Bt1y6btjlz5jJUVnbd6rBh92HXrm02bXPZzJmQysoux3kjS40ZwePbu8eXiG4O/h/cxmyx4EhxMTqu5ti6BFfYhAk2ny4/YUIYKiuPAF20OmFCmM3bDJswAUcqK7sc540sNWYEj2/vHl8iukls9Bvrba+mpkYmmkxyuG2245VZj4d7cdZjTU1N2+zOw22zOq/M7jzca7M77TFOe7V7Jx3fWxknAtGtgIsb9AJeR8jrNG3VJq/T/B8ubnBjMjMzERMTgwsXLujWWb2VrVy5Env27Olwg+xbga3ehwxNIupVt2toWq1WXLx4Ebt37za8j6qq+Otf/4pp06b1uP3Gxkb897//hY+PT4/rulnuhNDkb5pEZDe2PhNgy/oURTF0h5D2bPE9pKmpCX379u1xYDY2Nna45Rj1DO9yQkR2UVNTg8jIWUhNfRzFxZ+irOxjFBd/gtTUxxEZOQu1tbV2rU9aF3/RnkdHR2PJkiVITk6Gl5cXBg0ahFWrVmnlfn5+AIDp06dDVVX4+/trZXv27EFYWBicnZ1hMpmwevVqNDc3a+WqqmLTpk2YNm0aXF1d8dprryEzMxOqquK7777TtvvLX/6C4OBgODk5YdiwYdiwYYOuz35+fli7di3mzp0LDw8PJCUldTq27sYCAFVVVXjsscfg5uYGDw8PzJo1S7vB9BXr16/HgAED4O7ujqeffho//PBDh7Y2b96MoKAgODs7IygoCBs3btTKGhoasGjRIvj6+sLZ2Rl+fn5Yv359p32+ZfT0x1UiomvpagKGrVdssnV9CQkJEhcXpz2fMGGCeHh4yOrVq+XkyZOydetWUVVVMjIyRESktrZWFEWRDz74QM6fPy//+c9/RETk73//u3h4eMjWrVulsrJSMjIyZNiwYbo7mCiKIgMGDJDU1FSprKyUqqoqOXDggCiKot1JJD8/X/r06SNr166V8vJySU1NFRcXF0lNTdXqGTp0qHh4eMiGDRvk1KlTcurUqU7H1t1YmpubJTQ0VMaPHy8FBQVy5MgRiYiIkOjoaK2OHTt2iJOTk7z//vtSVlYmK1asEHd3d91dVdLS0sTX11d2794tp0+flvT0dPHy8pIPPvhARETeeOMNGTJkiGRlZUlVVZVkZWXJ9u3br+u/k1FcRo+Ibgtd/bEymx+5ak3g9o9mMZsfua52bF1fZ6E5fvx43TYWi0VeeOEF7bmiKLrbWomIPPTQQ7J+/Xrdax9++KH4+vrq9vvVr36l26Z9aD7xxBMSGxur2yY5OVmCg4O150OHDpUZM2Z0O7buxrJv3z5xcHCQs2fPauXFxcWiKIrk5+eLiEhkZKQsWrRIV8fYsWN1oWkymTqE4Jo1ayQqKkpERJ599ll56KGHuu2vLdgqNHl6lojsoqmpD661flJruf3qa09RFIwYMUL32qBBgzqcsmyvsLAQq1atgpubm/b4xS9+gXPnzulOZ0ZERFyzntLSUowbN073WlRUFMrLy7XTyIqidFvPtcZy5RR2SUkJBg8ejHvvvVcrDwoKQr9+/VBSUqL1Z8yYMbo6IiMjtb7U1dXh1KlTmDdvnm7s69atw6lTpwC0Trb6+uuvMXz4cCxZsgQZGRnd9t3eOBGIiOzCwaEZuMY6Ua3l9quvM+0n1SiKgpaWlmvuU1dXh9WrV2PGjBkdyhwdHbV/v/vuu7ttXwxMMjJSD9BxLAC6HUt3ru7fpUuXALT+ptk+XPv0af0AM2rUKFRWVuJvf/sb9u/fj/j4ePzsZz/Dzp07e9SP3sTQJCK7sFjMKC7uesUmi8Vs1/qMunqGbd++fXUTfAAgLCwMpaWluolBNyIoKAjZ2dm617KzszF8+PAbmuXb3tV1BAUFobq6GmfPnsV9990HACguLsaFCxdgNpu1bXJzc/Hkk09q++Xm5mr1DBgwAL6+vqioqMDs2bO7bNfNzQ3x8fGIj4/HzJkz8fDDD+PChQvo169fj8fUGxiaRGQXKSnJOHRoFioq1qH1HjAqWlfoPQKT6WWkpOywa33tSbvZtJ295ufnh/379yMyMhKOjo7w9PTEq6++iilTpmDIkCF4/PHHoaoqCgsLceLECaxZs8Zw+7/+9a8xevRorF27FvHx8cjJycE777yjm41qq7FMmjQJISEhmDNnDv7whz+gsbERCxcuRHR0tHaN45IlS2C1WhEREYGoqCj86U9/QnFxMUwmk1bnqlWr8Oyzz8LDwwOxsbGor69Hfn4+Lly4gKVLl2LDhg3w9fVFaGgoVFXFRx99hEGDBt2ygQnwkhMishNvb2/k5OyA1ZoOs3kqAgKmwWyeCqs1HTk5O677ukpb19f+Os3Ortts/9qbb76JjIwMDBkyRLuDzs9//nN8+umn2LdvHywWCyIjI/HWW29pl6h014crRo0ahY8++gjbt29HSEgIVq5ciTVr1mDu3LnXNS6jY9mzZw88PT0xfvx4TJo0CT/5yU+wY8f/PnjEx8fjlVdeQXJyMiIiIlBdXY0FCxbo6nzqqaewefNmbNmyBSNGjEB0dDS2bt2qfet2d3dHSkoKRo8eDYvFgqqqKuzdu/e6x3MzcUUgIupVt+uKQPTjYqv3Ib9pEhERGcTQJCIiMoihSUREZBBDk4iIyCCGJhERkUEMTSIiIoO4uAER3RRX1iwlsgdbvf8YmkR0U1y93BrR7YqLGxBRr7p8+TJKS0vt3Q0iAEBgYCBcXFxueH+GJhERkUGcCERERGQQQ5OIiMgghiYREZFBDE0iIiKDGJpEREQGMTSJiIgMYmgSEREZxNAkIiIyiKFJRERkEEOTiIjIIIYmERGRQQxNIiIigxiaREREBjE0iYiIDGJoEhERGcTQJCIiMoihSUREZBBDk4iIyCCGJhERkUEMTSIiIoMYmkRERAYxNImIiAxiaBIRERnE0CQiIjKIoUlERGQQQ5OIiMgghiYREZFBDE0iIiKDGJpEREQGMTSJiIgMYmgSEREZxNAkIiIyiKFJRERkEEOTiIjIIIYmERGRQQxNIiIigxiaREREBjE0iYiIDGJoEhERGcTQJCIiMoihSUREZBBDk4iIyCCGJhERkUEMTSIiIoMYmkRERAYxNImIiAxiaBIRERnE0CQiIjLo/wGHXvl0EBHY4gAAAABJRU5ErkJggg==" - ], - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "figure(figsize=(5, 1))\n", - "plot([0, 1, 2, 3, 4], [0, 0, 0, 0, 0], \"k\")\n", - "plot([0, 2, 4], [0, 0, 0], \"ro\", label=\"Boundary nodes\")\n", - "plot([1, 3], [0, 0], \"bo\", label=\"Interior nodes\")\n", - "legend(loc=5, prop=Dict(\"size\" => 10))\n", - "xlim(-0.2, 13)\n", - "axis(\"off\")\n", - "figure(figsize=(5, 1))\n", - "plot([0, 1, 2], [0, 0, 0], \"k\")\n", - "plot([3, 4, 5], [0, 0, 0], \"k\")\n", - "\n", - "plot([0, 2, 3, 5], [0, 0, 0, 0], \"ro\", label=\"Boundary nodes\")\n", - "plot([1, 4], [0, 0], \"bo\", label=\"Interior nodes\")\n", - "legend(loc=5, prop=Dict(\"size\" => 10))\n", - "xlim(-0.2, 13)\n", - "axis(\"off\");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here the third node in now shared between boundaries. Now we can make static condensation in parallel, because domains do not share information yet" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(\n", - "2x2 Array{Float64,2}:\n", - " 1.0 -1.0\n", - " -1.0 1.0,\n", - "\n", - "[0.0,1.0])" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - "Condensate system A = f, i.e. remove interior nodes from system.\n", - "\"\"\"\n", - "function condensate(A, f, B, I)\n", - " # in real life application we obviously make integration\n", - " # and assembly of system here before condensation\n", - " Ac = A[B,B] - A[B,I]*inv(A[I,I])*A[I,B]\n", - " fc = f[B] - A[B,I]*inv(A[I,I])*f[I]\n", - " return Ac, fc\n", - "end\n", - "A1 = 2*copy(A)\n", - "f1 = zeros(3)\n", - "A2 = 2*copy(A)\n", - "f2 = copy(f)\n", - "\n", - "# PARALLEL solution starts here\n", - "Ac1, fc1 = condensate(A1, f1, B, I) # worker 1: assembly domain 1 matrices and make static condensation\n", - "Ac2, fc2 = condensate(A2, f2, B, I) # worker 2: assembly domain 2 matrices and make static condensation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we have two 2x2 systems describing the boundaries. In condensated system\n", - "\n", - "\\begin{eqnarray}\n", - "u_{1} & = & 0\\\\\n", - "u_{2} & = & u_{3}\n", - "\\end{eqnarray}\n", - "\n", - "So our Lagrange multipliers (\"restriction operator\"?) are" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x4 Array{Int64,2}:\n", - " 1 0 0 0\n", - " 0 1 -1 0" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "R = [1 0 0 0; 0 1 -1 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Assembly of boundary systems + Lagrange multipliers" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "4-element Array{Float64,1}:\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 1.0" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Z22 = zeros(2, 2)\n", - "Z2 = zeros(2)\n", - "A_ass = [Ac1 Z22; Z22 Ac2]\n", - "f_ass = [fc1; fc2]" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "6-element Array{Float64,1}:\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 0.0" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A_ass_w_lag = [A_ass R'; R Z22]\n", - "f_ass_w_lag = [f_ass; Z2]" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "6-element Array{Float64,1}:\n", - " 0.0\n", - " 1.0\n", - " 1.0\n", - " 2.0\n", - " 1.0\n", - " -1.0" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sol = A_ass_w_lag \\ f_ass_w_lag" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we have our shared boundary node solution defined twice + Lagrange multipliers. I think we can go even further and condensate this remaining system. If we again are interested of interior solution in domains, we can" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1-element Array{Float64,1}:\n", - " 0.5" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inv(A1[I,I])*(f1[I] - A1[I,B]*sol[[1, 2]])" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1-element Array{Float64,1}:\n", - " 1.5" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inv(A2[I,I])*(f2[I] - A2[I,B]*sol[[3, 4]])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.4.0-dev", - "language": "julia", - "name": "julia-0.4" - }, - "language_info": { - "name": "julia", - "version": "0.4.0" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-08-15-interpolation-integration-and-linearization-strategies.ipynb b/notebooks/2015-08-15-interpolation-integration-and-linearization-strategies.ipynb deleted file mode 100644 index bf1c07f..0000000 --- a/notebooks/2015-08-15-interpolation-integration-and-linearization-strategies.ipynb +++ /dev/null @@ -1,548 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Interpolation and integration algorithms\n", - "\n", - "Author(s): Jukka Aho\n", - "\n", - "**Abstract**: Some strategies to implement automatic differentiation. The number of different choises is caused by a fact that the linearization of function can be done before integration or vice versa, and functions can return values or do in-place modifications. There is probably performance differences between different strategies, but all of them should work." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "using JuliaFEM\n", - "using ForwardDiff" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\"Old good\" elasticity force equilibrium equation $R = T - F$" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "calc_residual_vector_integrand (generic function with 1 method)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function calc_residual_vector_integrand(el::JuliaFEM.Element, xi)\n", - " # Calculate dN/dX and interpolate material parameters\n", - " dbasisdX = JuliaFEM.get_dbasisdX(el, xi)\n", - " u = el.attributes[\"displacement\"]\n", - " lambda = JuliaFEM.interpolate(el, \"lambda\", xi)\n", - " mu = JuliaFEM.interpolate(el, \"mu\", xi)\n", - "\n", - " # Calculate residual force vector R = T - F\n", - " gradu = u*dbasisdX\n", - " F = I + gradu\n", - " E = 1/2*(gradu' + gradu + gradu'*gradu)\n", - " S = lambda*trace(E)*I + 2*mu*E\n", - " P = F*S\n", - " T = P*dbasisdX'\n", - " return T\n", - "end" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Test case, already well known 2d elasticity in [0,10] x [0,1] grid." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "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", - "dbasis(xi) = [-(1-xi[2])/4.0 -(1-xi[1])/4.0\n", - " (1-xi[2])/4.0 -(1+xi[1])/4.0\n", - " (1+xi[2])/4.0 (1+xi[1])/4.0\n", - " -(1+xi[2])/4.0 (1-xi[1])/4.0]\n", - "ipoints = 1/sqrt(3)*[-1 -1; 1 -1; 1 1; -1 1]'\n", - "iweights = [1, 1, 1, 1]\n", - "attributes = Dict()\n", - "e = JuliaFEM.Element(1, [1, 2, 3, 4], basis, dbasis, attributes, ipoints, iweights)\n", - "\n", - "E = 90\n", - "nu = 0.25\n", - "mu = E/(2*(1+nu))\n", - "la = E*nu/((1+nu)*(1-2*nu))\n", - "la = 2*la*mu/(la + 2*mu)\n", - "\n", - "e.attributes[\"coordinates\"] = [0.0 0.0; 10.0 0.0; 10.0 1.0; 0.0 1.0]'\n", - "e.attributes[\"lambda\"] = la\n", - "e.attributes[\"mu\"] = mu\n", - "e.attributes[\"displacement\"] = [0.0 0.0; 0.0 0.0; 0.5 0.0; 0.0 0.0]'\n", - "e.attributes[\"displacement nodal force\"] = zeros(2, 4)\n", - "e.attributes[\"displacement tangent stiffness\"] = zeros(8, 8);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Integration\n", - "\n", - "1. take element and function and return value\n", - "2. take function and return function which can be integrated by passing element as a function\n", - "3. do in-place integration, save values to target" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "integrate! (generic function with 1 method)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function integrate(f::Function, el::JuliaFEM.Element)\n", - " target = []\n", - " for m = 1:length(el.iweights)\n", - " w = el.iweights[m]\n", - " xi = el.ipoints[:, m]\n", - " J = JuliaFEM.interpolate(el, \"coordinates\", xi; derivative=true)\n", - " push!(target, w*f(el, xi)*det(J))\n", - " end\n", - " return sum(target)\n", - "end\n", - "\n", - "function integrate(f::Function)\n", - " function integrate(el::JuliaFEM.Element)\n", - " target = []\n", - " for m = 1:length(el.iweights)\n", - " w = el.iweights[m]\n", - " xi = el.ipoints[:, m]\n", - " J = JuliaFEM.interpolate(el, \"coordinates\", xi; derivative=true)\n", - " push!(target, w*f(el, xi)*det(J))\n", - " end\n", - " return sum(target)\n", - " end\n", - " return integrate\n", - "end\n", - "\n", - "function integrate!(f::Function, el::JuliaFEM.Element, target)\n", - " # set target to zero\n", - " el.attributes[target][:] = 0.0\n", - " for m = 1:length(el.iweights)\n", - " w = el.iweights[m]\n", - " xi = el.ipoints[:, m]\n", - " J = JuliaFEM.interpolate(el, \"coordinates\", xi; derivative=true)\n", - " el.attributes[target][:,:] += w*f(el, xi)*det(J)\n", - " end\n", - "end\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x4 Array{Float64,2}:\n", - " -38.2303 -72.8697 79.4912 31.6088\n", - " -17.625 -28.475 37.7 8.4 " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "integrate(calc_residual_vector_integrand, e)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x4 Array{Float64,2}:\n", - " -38.2303 -72.8697 79.4912 31.6088\n", - " -17.625 -28.475 37.7 8.4 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "calc_residual_vector = integrate(calc_residual_vector_integrand)\n", - "calc_residual_vector(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x4 Array{Float64,2}:\n", - " -38.2303 -72.8697 79.4912 31.6088\n", - " -17.625 -28.475 37.7 8.4 " - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "integrate!(calc_residual_vector_integrand, e, \"displacement nodal force\")\n", - "e.attributes[\"displacement nodal force\"]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Linearization\n", - "\n", - "1. take function, element and field, and return partial derivative\n", - "2. take function and field, return function which takes element as argument\n", - "3. do in-place linearization to target, requires function which takes element as argument\n", - "\n", - "In general linearization can be done before integration and vice versa, i.e.\n", - "\n", - " integrate(linearize(f, \"u\"))(e) <-> linearize(integrate(f), \"u\")(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "linearize! (generic function with 1 method)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function linearize(f::Function, el::JuliaFEM.Element, field::ASCIIString)\n", - " dim, nnodes = size(el.attributes[field])\n", - " function helper!(x, y)\n", - " orig = copy(el.attributes[field])\n", - " el.attributes[field] = reshape(x, dim, nnodes)\n", - " y[:] = f(el)\n", - " el.attributes[field] = copy(orig)\n", - " end\n", - " jac = ForwardDiff.forwarddiff_jacobian(helper!, Float64, fadtype=:dual, n=dim*nnodes, m=dim*nnodes)\n", - " return jac(el.attributes[field][:])\n", - "end\n", - "\n", - "function linearize(f::Function, field::ASCIIString)\n", - " function jacobian(el::JuliaFEM.Element, args...)\n", - " dim, nnodes = size(el.attributes[field])\n", - " function helper!(x, y)\n", - " orig = copy(el.attributes[field])\n", - " el.attributes[field] = reshape(x, dim, nnodes)\n", - " y[:] = f(el, args...)\n", - " el.attributes[field] = copy(orig)\n", - " end\n", - " jac = ForwardDiff.forwarddiff_jacobian(helper!, Float64, fadtype=:dual, n=dim*nnodes, m=dim*nnodes)\n", - " return jac(el.attributes[field][:])\n", - " end\n", - " return jacobian\n", - "end\n", - "\n", - "function linearize!(f::Function, el::JuliaFEM.Element, field::ASCIIString, target::ASCIIString)\n", - " el.attributes[target][:] = 0.0\n", - " dim, nnodes = size(el.attributes[field])\n", - " function helper!(x, y)\n", - " orig = copy(el.attributes[field])\n", - " el.attributes[field] = reshape(x, dim, nnodes)\n", - " y[:] = f(el)\n", - " el.attributes[field] = copy(orig)\n", - " end\n", - " jac! = ForwardDiff.forwarddiff_jacobian!(helper!, Float64, fadtype=:dual, n=dim*nnodes, m=dim*nnodes)\n", - " jac!(el.attributes[field][:], el.attributes[target])\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "8x8 Array{Float64,2}:\n", - " 149.721 55.55 84.679 36.65 … -55.55 -136.278 -36.65 \n", - " 55.55 329.69 42.75 167.935 -172.941 -42.8 -324.684\n", - " 84.679 42.75 185.321 105.05 -123.05 -73.522 -24.75 \n", - " 36.65 167.935 105.05 340.54 -344.759 -24.8 -163.716\n", - " -98.122 -55.5 -196.478 -116.9 135.8 76.233 36.6 \n", - " -55.55 -172.941 -123.05 -344.759 … 352.922 42.8 164.778\n", - " -136.278 -42.8 -73.522 -24.8 42.8 133.567 24.8 \n", - " -36.65 -324.684 -24.75 -163.716 164.778 24.8 323.622" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "integrate(linearize(calc_residual_vector_integrand, \"displacement\"))(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "8x8 Array{Float64,2}:\n", - " 149.721 55.55 84.679 36.65 … -55.55 -136.278 -36.65 \n", - " 55.55 329.69 42.75 167.935 -172.941 -42.8 -324.684\n", - " 84.679 42.75 185.321 105.05 -123.05 -73.522 -24.75 \n", - " 36.65 167.935 105.05 340.54 -344.759 -24.8 -163.716\n", - " -98.122 -55.5 -196.478 -116.9 135.8 76.233 36.6 \n", - " -55.55 -172.941 -123.05 -344.759 … 352.922 42.8 164.778\n", - " -136.278 -42.8 -73.522 -24.8 42.8 133.567 24.8 \n", - " -36.65 -324.684 -24.75 -163.716 164.778 24.8 323.622" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "linearize(integrate(calc_residual_vector_integrand), \"displacement\")(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "8x8 Array{Float64,2}:\n", - " 149.721 55.55 84.679 36.65 … -55.55 -136.278 -36.65 \n", - " 55.55 329.69 42.75 167.935 -172.941 -42.8 -324.684\n", - " 84.679 42.75 185.321 105.05 -123.05 -73.522 -24.75 \n", - " 36.65 167.935 105.05 340.54 -344.759 -24.8 -163.716\n", - " -98.122 -55.5 -196.478 -116.9 135.8 76.233 36.6 \n", - " -55.55 -172.941 -123.05 -344.759 … 352.922 42.8 164.778\n", - " -136.278 -42.8 -73.522 -24.8 42.8 133.567 24.8 \n", - " -36.65 -324.684 -24.75 -163.716 164.778 24.8 323.622" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "linearize(integrate(calc_residual_vector_integrand), e, \"displacement\")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "8x8 Array{Float64,2}:\n", - " 149.721 55.55 84.679 36.65 … -55.55 -136.278 -36.65 \n", - " 55.55 329.69 42.75 167.935 -172.941 -42.8 -324.684\n", - " 84.679 42.75 185.321 105.05 -123.05 -73.522 -24.75 \n", - " 36.65 167.935 105.05 340.54 -344.759 -24.8 -163.716\n", - " -98.122 -55.5 -196.478 -116.9 135.8 76.233 36.6 \n", - " -55.55 -172.941 -123.05 -344.759 … 352.922 42.8 164.778\n", - " -136.278 -42.8 -73.522 -24.8 42.8 133.567 24.8 \n", - " -36.65 -324.684 -24.75 -163.716 164.778 24.8 323.622" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "linearize!(integrate(calc_residual_vector_integrand), e, \"displacement\", \"displacement tangent stiffness\")\n", - "e.attributes[\"displacement tangent stiffness\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "8x8 Array{Float64,2}:\n", - " 149.721 55.55 84.679 36.65 … -55.55 -136.278 -36.65 \n", - " 55.55 329.69 42.75 167.935 -172.941 -42.8 -324.684\n", - " 84.679 42.75 185.321 105.05 -123.05 -73.522 -24.75 \n", - " 36.65 167.935 105.05 340.54 -344.759 -24.8 -163.716\n", - " -98.122 -55.5 -196.478 -116.9 135.8 76.233 36.6 \n", - " -55.55 -172.941 -123.05 -344.759 … 352.922 42.8 164.778\n", - " -136.278 -42.8 -73.522 -24.8 42.8 133.567 24.8 \n", - " -36.65 -324.684 -24.75 -163.716 164.778 24.8 323.622" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "integrate!(linearize(calc_residual_vector_integrand, \"displacement\"), e, \"displacement tangent stiffness\")\n", - "e.attributes[\"displacement tangent stiffness\"]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Validations" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converged in 6 iterations.\n" - ] - }, - { - "data": { - "text/plain": [ - "2x4 Array{Float64,2}:\n", - " 0.0 -0.399145 -0.0722858 0.0\n", - " 0.0 -2.17799 -2.22224 0.0" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "free_dofs = [3, 4, 5, 6]\n", - "u = zeros(2, 4)\n", - "du = zeros(2, 4)\n", - "F = [0 0; 0 0; 0 -2; 0 0]'\n", - "for i=1:10\n", - " e.attributes[\"displacement\"] = u\n", - " K = linearize(integrate(calc_residual_vector_integrand), \"displacement\")(e)\n", - " R = integrate(calc_residual_vector_integrand)(e)\n", - " du[free_dofs] = K[free_dofs, free_dofs] \\ -(R - F)[free_dofs]\n", - " u += du\n", - " if norm(du) < 1.0e-9\n", - " println(\"Converged in $i iterations.\")\n", - " break\n", - " end\n", - "end\n", - "u # -2.222244754401764" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.4.0-dev", - "language": "julia", - "name": "julia-0.4" - }, - "language_info": { - "name": "julia", - "version": "0.4.0" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-08-25-interpolation-of-field-variables.ipynb b/notebooks/2015-08-25-interpolation-of-field-variables.ipynb deleted file mode 100644 index 61be7cd..0000000 --- a/notebooks/2015-08-25-interpolation-of-field-variables.ipynb +++ /dev/null @@ -1,362 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Interpolation of field variables\n", - "\n", - "Author(s): Jukka Aho\n", - "\n", - "Abstract: Let's interpolate and visualize a scalar field from 4 element model." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "using JuliaFEM: Element, Quad4, get_basis, set_field, get_field, get_dbasisdxi" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "coordinates = [0.0 2.0; 1.0 2.0; 2.0 2.0; 0.0 1.0; 1.0 1.0; 2.0 1.0; 0.0 0.0; 1.0 0.0; 2.0 0.0]'\n", - "temperature = [0.0 140.0 190.0 0.0 155.0 310.0 0.0 170.0 430.0]\n", - "\n", - "elements = Element[\n", - " Quad4([4, 5, 2, 1]),\n", - " Quad4([5, 6, 3, 2]),\n", - " Quad4([7, 8, 5, 4]),\n", - " Quad4([8, 9, 6, 5])]\n", - "\n", - "for el in elements\n", - " set_field(el, \"coordinates\", coordinates[:, el.node_ids])\n", - " set_field(el, \"temperature\", temperature[:, el.node_ids])\n", - "end" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Basic interpolation wrt local coordinates $\\xi$:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "([430.0],[0.5,1.5])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - "Evaluate field in point xi using basis functions.\n", - "\"\"\"\n", - "function interpolate(el::Element, field::ASCIIString, xi::Array{Float64,1})\n", - " f = get_field(el, field)\n", - " basis = get_basis(el, xi)\n", - " dim, nnodes = size(f)\n", - " result = zeros(dim)\n", - " for i=1:nnodes\n", - " result += basis[i]*f[:,i]\n", - " end\n", - " return result\n", - "end\n", - "\n", - "interpolate(elements[4], \"temperature\", [1.0, -1.0]), interpolate(elements[1], \"coordinates\", [0.0, 0.0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Find local coordinate $\\xi$ where field equals to some given value:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1.0,-1.0]\n" - ] - }, - { - "data": { - "text/plain": [ - "2-element Array{Float64,1}:\n", - " 1.0\n", - " 1.0" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function get_xi(el::Element, field::ASCIIString, value::Vector)\n", - " fld = get_field(el, field)\n", - " dbasisdxi(xi) = get_dbasisdxi(el, xi)\n", - " rhs(xi) = interpolate(el, field, xi) - value\n", - " lhs(xi) = fld*dbasisdxi(xi)\n", - " xi = zeros(length(value))\n", - " for i=1:5\n", - " A = rhs(xi)\n", - " b = lhs(xi)\n", - " #println(\"$A, $b\")\n", - " dxi = lhs(xi) \\ rhs(xi)\n", - " xi -= dxi\n", - " if norm(dxi) < 1.0e-9\n", - " break\n", - " end\n", - " end\n", - " return xi[:]\n", - "end\n", - "\n", - "xi0 = get_xi(elements[4], \"coordinates\", [2.0, 0.0])\n", - "println(\"$xi0\")\n", - "interpolate(elements[1], \"coordinates\", xi0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Test if point is inside element:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "point_inside_element (generic function with 1 method)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function point_inside_element(el::Quad4, pnt)\n", - " all(-1 .<= get_xi(el, \"coordinates\", pnt) .<= 1)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(false,true)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "point_inside_element(elements[1], [0.8, 2.01]), point_inside_element(elements[4], [2.0, 0.0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Interpolate field variable from set of elements" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "interpolate (generic function with 3 methods)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function interpolate(elements::Array{Element,1}, field::ASCIIString, pnt::Array{Float64,1}, nullval=0.0)\n", - " elements = filter((el) -> point_inside_element(el, pnt), elements)\n", - " if length(elements) == 0\n", - " # outside of region\n", - " return nullval\n", - " end\n", - " xi = get_xi(elements[1], \"coordinates\", pnt)\n", - " return interpolate(elements[1], field, xi)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1-element Array{Float64,1}:\n", - " 430.0" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "interpolate(elements, \"temperature\", [2.0, 0.0])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "y = linspace(0,2,100)\n", - "x = y'\n", - "T = zeros(length(x), length(y))\n", - "for i=1:length(x)\n", - " for j=1:length(y)\n", - " T[i,j] = interpolate(elements, \"temperature\", [x[i], y[j]])[1]\n", - " end\n", - "end\n", - "T = T';" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "using PyPlot" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-0.1,2.1,-0.1,2.1)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "figure(figsize=(6, 6))\n", - "levels = [10, 50, 100, 140, 155, 170, 190, 250, 310, 350]\n", - "cs = contour(x, y, T, levels, colors=\"k\")\n", - "clabel(cs, fontsize=9, inline=1)\n", - "for el in elements\n", - " p1 = interpolate(el, \"coordinates\", [-1.0, -1.0])\n", - " p2 = interpolate(el, \"coordinates\", [ 1.0, -1.0])\n", - " p3 = interpolate(el, \"coordinates\", [ 1.0, 1.0])\n", - " p4 = interpolate(el, \"coordinates\", [-1.0, 1.0])\n", - " pts = [p1 p2 p3 p4 p1]\n", - " plot(pts[1,:]', pts[2,:]', \"-ko\")\n", - "end\n", - "xlim(-0.1, 2.1)\n", - "ylim(-0.1, 2.1)\n", - "axis(\"off\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.4.0-dev", - "language": "julia", - "name": "julia-0.4" - }, - "language_info": { - "name": "julia", - "version": "0.4.0" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/2015-09-10-surface-normals.ipynb b/notebooks/2015-09-10-surface-normals.ipynb deleted file mode 100644 index a9221a6..0000000 --- a/notebooks/2015-09-10-surface-normals.ipynb +++ /dev/null @@ -1,627 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Surface normals\n", - "\n", - "Author(s): Jukka Aho\n", - "\n", - "**Abstract**: Testing different strategies to calculate surface normals. These are important when calculating mortar projections." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: could not import Base.help into PyCall\n" - ] - } - ], - "source": [ - "using JuliaFEM\n", - "using JuliaFEM: Element, get_connectivity, get_field, set_field\n", - "using JuliaFEM: get_number_of_basis_functions, get_detJ, get_basis\n", - "using JuliaFEM: interpolate, dinterpolate, get_dbasisdxi, new_field!, push_field!, PSeg\n", - "using JuliaFEM: set_degree, get_number_of_basis_functions, dinterpolate\n", - "using ForwardDiff\n", - "using PyPlot" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "3-element Array{Any,1}:\n", - " JuliaFEM.PSeg([1,2],Dict{Any,Any}(:Geometry=>Array{T,1}[[-10.0,1.2246467991473533e-15],[-4.999999999999998,8.660254037844387]]),1) \n", - " JuliaFEM.PSeg([2,3],Dict{Any,Any}(:Geometry=>Array{T,1}[[-4.999999999999998,8.660254037844387],[5.000000000000001,8.660254037844386]]),1)\n", - " JuliaFEM.PSeg([3,4],Dict{Any,Any}(:Geometry=>Array{T,1}[[5.000000000000001,8.660254037844386],[10.0,0.0]]),1) " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "phi = linspace(pi, 0, 4)\n", - "nelements = length(phi)-1\n", - "nnodes = length(phi)\n", - "elements = []\n", - "R = 10.0\n", - "for i=1:nelements\n", - " con = [i, mod(i, nnodes)+1]\n", - " seg = PSeg(con)\n", - " # create vector field :geometry for elements\n", - " pnts = Vector[]\n", - " for deg in phi[con]\n", - " X = R*[cos(deg), sin(deg)]\n", - " push!(pnts, X)\n", - " end\n", - " set_field(seg, :Geometry, pnts)\n", - " push!(elements, seg)\n", - "end\n", - "elements" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# calculate \"local\" normals in elements, in a way that\n", - "# n = Nᵢnᵢ gives some reasonable results for ξ ∈ [-1, 1]\n", - "\n", - "function calculate_normals!(el::Element, field_name=:Normals)\n", - " new_field!(el, field_name, Vector)\n", - " for xi in Vector[[-1.0], [1.0]]\n", - " t = dinterpolate(el, :Geometry, xi)\n", - " n = [0 -1; 1 0]*t\n", - " n /= norm(n)\n", - " push_field!(el, field_name, n)\n", - " end\n", - "end\n", - "\n", - "for el in elements\n", - " calculate_normals!(el)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "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" - ], - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-15.0,15.0,-2.0,14.0)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function plot_stuff(elements)\n", - " phi2 = linspace(0, pi, 100)\n", - " phi3 = linspace(0, pi, 10)\n", - " phi4 = linspace(0, pi, 4)\n", - " figure(figsize=(8, 4))\n", - " plot(R*cos(phi2), R*sin(phi2))\n", - " for fi in phi3\n", - " p0 = R*[cos(fi), sin(fi)]\n", - " p1 = (R+3)*[cos(fi), sin(fi)]\n", - " plot([p0[1], p1[1]], [p0[2], p1[2]], \"-b\")\n", - " end\n", - "\n", - " # create a array of vectors\n", - " xis = Vector[[xi] for xi in linspace(-1, 1)]\n", - " for el in elements\n", - " coords = interpolate(el, :Geometry, xis)\n", - " # extract 1 and 2 components from array of coordinates\n", - " xs = [X[1] for X in coords]\n", - " ys = [X[2] for X in coords]\n", - " plot(xs, ys, \"-\")\n", - " end\n", - "\n", - " xis = Vector[[xi] for xi in linspace(-1, 1, 4)]\n", - " for el in elements\n", - " coords = interpolate(el, :Geometry, xis)\n", - " normals = interpolate(el, :Normals, xis)\n", - " for i=1:length(normals)\n", - " p0 = coords[i]\n", - " p1 = coords[i] + normals[i]/norm(normals[i])*3\n", - " plot([p0[1], p1[1]], [p0[2], p1[2]], \"-k\")\n", - " end\n", - " end\n", - " plot(R*cos(phi4), R*sin(phi4), \"ko\")\n", - "\n", - " xlim(-1.5*R, 1.5*R)\n", - " ylim(-0.5*R, 1.5*R)\n", - "\n", - " axis(\"equal\")\n", - " axis(\"off\")\n", - "end\n", - "\n", - "plot_stuff(elements)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Blue lines \"accurate\" normal direction, other lines are approximations. Notice the discontinuity in the nodes." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Strategy 1\n", - "\n", - "average normals of adjacent elements in common nodes, maybe by weighting it with areas / lenghts ..." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "\"\"\"\n", - "Alter normal field such that normals of adjacent elements are averaged.\n", - "\"\"\"\n", - "function average_normals!(elements, normal_field=:Normals)\n", - " d = Dict()\n", - " for el in elements\n", - " c = get_connectivity(el)\n", - " n = get_field(el, normal_field)\n", - " for (ci, ni) in zip(c, n)\n", - " d[ci] = haskey(d, ci) ? d[ci] + ni : ni\n", - " end\n", - " end\n", - " for (ci, ni) in d\n", - " d[ci] /= norm(d[ci])\n", - " end\n", - " for el in elements\n", - " c = get_connectivity(el)\n", - " new_normals = [d[ci] for ci in c]\n", - " set_field(el, normal_field, new_normals)\n", - " end\n", - "end\n", - "average_normals!(elements)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAqAAAAFrCAYAAAAO+zsvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3Xd8zdcfx/FXhpHYitgZ9goJYu+qPWPvUlRbas9apfZsdVBqr1bVqtbeK0ZIiBUrVogRQWTf3x+nKX41Mu79fu+9+TwfjzxC3fs9H6ncvO/3nPM5NgaDwYAQQgghhBAasdW7ACGEEEIIkbJIABVCCCGEEJqSACqEEEIIITQlAVQIIYQQQmhKAqgQQgghhNCUBFAhhBBCCKEpCaBCCCGEEEJTEkCFEEIIIYSmJIAKIYQQQghNSQAVQgghhBCakgAqhBBCCCE0JQFUCCGEEEJoSgKoEEIIIYTQlARQIYQQQgihKQmgQgghhBBCUxJAhRBCCCGEpiSACiGEEEIITUkAFUIIIYQQmpIAKoQQQgghNCUBVAghhBBCaEoCqBBCCCGE0JQEUCGEEEIIoSkJoEIIIYQQQlMSQIUQQgghhKYkgAohhBBCCE1JABVCCCGEEJqSACqEEEIIITQlAVQIYbbGj4dWrfSuImU5cgRKlICbN/WuRAhhzSSACiHMlo0N7N0LBoPelaQcp0/DpUvg5KR3JUIIayYBVAhhttzd4eFDCA7Wu5KUw98fihSB1Kn1rkQIYc0kgAohzFapUuqzv7++daQk/v4q+AshhClJABVCmC1XV0iXDvz89K4kZTAYVACND/5CCGEqEkCFEGbL1lZtiJE7oNq4eROePJEAKoQwPQmgQgizVqqUBFCtxH+dJYAKIUxNAqgQwqyVKgUBARATo3cl1s/fHzJmhPz59a5ECGHtJIAKIcxaqVIQGQmBgXpXYv38/aFkSdX+SgghTEkCqBDCrMlOeO3IBiQhhFYkgAohzFr27JAzpwRQU4uKggsXJIAKIbQhAVQIYfZKlZJWTKZ28SJER0sPUCGENiSACiHMnuyEN734r2/JkvrWIYRIGSSACiHMXqlScPUqPHumdyXWy98f8uaFLFn0rkQIkRJIABVCmL34dYnnzulbhzWTDUhCCC1JABVCmL3ixdWpSDINbzoSQIUQWpIAKoQwew4OUKiQBFBTefIEgoIkgAohtCMBVAhhEWQjkumcPas+SwAVQmhFAqgQwiLEt2IyGPSuxPr4+YGdHRQtqnclQoiUQgKoEMIilCoFDx9CcLDelVgff38VPtOk0bsSIURKIQFUCGER5EhO05ENSEIIrUkAFUJYBDc3cHSUAGpsBoMEUCGE9iSACiEsgq0tlCghAdTYbt1Su+AlgAohtCQBVAhhMWQnvPHFfz0lgAohtCQBVAhhtgwGA7du3SI8PBwAd3cICICYGJ0LsyL+/pAhAzg7q98HBQXx4sULfYsSQlg9CaBCCLN148YN8uXLx969ewF1ly4iAgID9a3Lmvj5QcmSYGOjft+uXTs++eQTfYsSQlg9CaBCCLPl7OxM5syZ8fX1BWQnvCm8ugEpNjaWM2fO4OnpqW9RQgirJwFUCGG2bGxs8PDw+DeAZs8OTk4SQI0lOhouXFBLGwAuX75MeHg4Hh4e+hYmhLB6EkCFEGbNw8ODU6dO/ft72YhkPBcvqhAafwc0/utcpkwZHasSQqQEEkCFEGbNw8ODa9euERoaCkgANab/3wHv6+uLs7MzWbNm1a8oIUSKIAFUCGHW4qeDT58+DaiwdPUqPH+uZ1XWwd8f8uSBLFnU7319fWX9pxBCExJAhUimoKAHepdg1YoUKYKDg8O/60Dd3dXpPefO6VyYFXh1A5LBYMDX11fWf5pYcHAoUVHSR0wICaBCJEPPntNwds7Bpk3H9C7Fatnb2+Pu7v7v+sTixdWpSH5+OhdmBfz8XgbQoKAgHj16JAHUxEqXrkO6dDmIjY3TuxQhdCUBVIhkGDiwA2BD+/Zt9S7Fqr26E97BAQoWlHWgyfXkCQQFvb7+E5AAakLz52/l/v1TuLiUx85OfvyKlE2+A4RIhmLF8lKlShfCw28wePCPepdjtTw9PTl//vy/JyLJRqTkO3tWfX41gObIkYPcuXPrV5SV69evG2DPgQNr9S5FCN1JABUimXbv/hlbW0dmzx4sa7tMxMPDg7i4OPz/SZ3xAdRg0LkwC+bvD3Z2UKyY+v2pU6fw8PDAJv5IJGFUHTuOJyoqhObNB5IzZ2a9yxFCdxJAhUim1KntGTBgBnFx4dSp00vvcqxSyZIlsbOze+1EpAcP4N49nQuzYP7+UKQIpEmjfi8bkEzn0aNnrFr1Dfb2WVi3brLe5QhhFiSACmEEM2b0wdHRmYMHl3L+/C29y7E6adOmpXjx4nIkpxG9ugM+JCSE27dvSwA1kRo1OgHRTJ36s6z9FOIf8p0ghJGsXr0WiKNOnVZ6l2KVPD09/w2gbm7g6CgBNKkMhtcDaPzXVXqAGt/+/ec4e3YjWbKUYOBAb73LEcJsSAAVwkiaNq2Ai0tN7t49xrJlu/Qux+p4eHjg5+dHdHQ0dnZQooS0YkqqW7cgNPT1IzgzZMiAm5ubvoVZoWbNWgE2bN36u96lCGFWJIAKYUT79v0G2NGrVye9S7E6Hh4eREZGcuHCBUB2wifHm47gLFOmDLa28iPBmKZOXUto6AXc3VtQsWIRvcsRwqzIq40QRpQ/fzbq1/+cyMhgevSYonc5VqVMmTIAr60DDQiA2Fg9q7JM/v6QPj04O6vfyxGcxhcbG8eoUb2B1Ozfv1zvcoQwOxJAhTCyLVtmY2eXkcWLx/HsWYTe5ViNjBkzUrBgwdcCaEQEBAbqXJgFil//aWsLYWFhXL58WTYgGVnz5kOIjX1C165jyJTJUe9yhDA7EkCFMDI7O1vGjfsBgyGS6tW76F2OVfHw8Pj3SE7ZCZ90r25AOnPmDCAnIBnT7duP2LJlLqlT52DJklF6lyOEWZIAKoQJfPVVRzJmLIyv7zp8fC7rXY7V8PDw4PTp08TFxZEjB+TIIQE0saKj4fz519d/pkmThmLxHelFslWv3gaI5YcfluldihBmSwKoECaycePvgIGGDaX1irF4eHgQFhbGtWvXAHB3lwCaWJcuqRD6agAtVaoUqVKl0rcwK7Fly3GuXt2Fk1M5evSop3c5QpgtCaBCmEjNmiUpWrQRDx/6M2fOH3qXYxXip4lfnYaXVkyJE//1erUFk0y/G0+7dm0AG3bulLZLQryLBFAhTOjQoTVAKoYM+YTY2Di9y7F4Tk5O5M6d+7WNSFevwvPnOhdmQfz9IXduyJoVIiMjCQgIkABqJMOGLeD58+tUqtSZkiXz612OEGZNAqgQJpQ1a3ratBlGTMwj2rUbrXc5VsHDw+O1AGowwLlzOhdlQV7dgHT27FliYmIkgBpBVFQMM2YMxMbGgV27fta7HCHMngRQIUxs1arxpEr1AevWTSMkJEzvcixe/E54g8FA8eJgYyPrQBPj/4/gtLW1xd3dXd+irEDdun2Ii3tOv37TcHBIrXc5Qpg9CaBCmJidnS2zZv0CxFCtWju9y7F4np6e3L9/n7t37+LoCAULSgBNqLAwuHFDbd4Ctf6zaNGiODpKn8rkuHTpDvv3/4KDQz7mzPlC73KEsAgSQIXQwBdfNCVbttJcvPgXu3fLrpnkiJ8ufnUaXgJowpw9qz6/egdUpt+Tr1YtbyCOlSvX6l2KEBZDAqgQGtmx4w/AhhYtWuldikVzdnYmS5Ys/wZQd3e1s9tg0LkwC+DvD3Z2UKwYxMbG4ufnJ0dwJtOqVXu5c+co+fNXp0WLSnqXI4TFkAAqhEbKlHGlbNm2hIVdZvx4aVCdVDY2NpQpU+a1O6APHsC9ezoXZgH8/KBwYUiTBi5dukR4eLjcAU2m7t07AHbs3fub3qUIYVEkgAqhob17F2Njk4avv/5C2jIlg6enpxzJmQSvbkCK//qVKVNGx4osW69e04mMvMtHH/XB1TWH3uUIYVEkgAqhofTp0/LJJxOIi3tKw4Zf6l2OxfLw8OD69es8fvwYNzdwcJAA+j4Gw393wLu4uJAlSxZ9C7NQz55FsHDhaOzsMrB161y9yxHC4kgAFUJjCxYMIU2aXGzf/iPXrt3XuxyLFD9tfPr0aezsoEQJCaDvc/s2hIa+HkBl/WfS1az5MQZDJGPH/oCdnfwoFSKx5LtGCB388ssqIJaaNVvrXYpFKlKkCA4ODq9Nw0sAfbf4r49q3m+QIziT4eTJK5w8uZaMGQsxenQnvcsRwiLZ612AEClRhw41GTq0EkFB+/n990N4e1fRuySLYmdnR+nSpV/biLR6NcTGql3eSRUbCyEhcPcu3L8Pjx+ru4ahoa//+vlziIiAFy/U5/iPyMh31Qxp0/73w8EBMmWCzJlffmTJoj5/8AHkzAm5ckH69En/e4EKoOnTg4sL3Lhxg9DQUAmgSVS/vjdg4I8/1uldihAWSwKoEDrZvXsdRYrko3Pn9nh7B+ldjsXx8PBg3759gGrFFBEBV66oXd5vYjBAcDBcuwbXr6vP167BnTsqcAYHq9AZ9397w2xtXw+GmTJBhgyQLdt/w2SaNOpkpjeJiXk9rMZ/hIerul8NuuHh/31+unQqiObMqT6cncHVVX24uKiPd/WT9/eHkiXV3yc+uEsATbx58zbx4MEZihRpQO3acoKUEEklAVQInRQunJvq1buzf/9C+vefJyeoJJKHhwfz588nPDycUqVU8vLzUyHt/Hm4cEF9Pn8eLl5UoTMi4uXzs2ZV4S1vXqhY8eWdxviA5+SkHpM+/dtDpalERcGTJ+pu7L17LwNy/Oc7d8DXF4KCIDr65fOcnKBAAShaVPX6jP9wcVFfmwoV1ON8fX1xcnIiV65c2v7FLFxsbBwDB3YH7DlwYI3e5Qhh0WwMBmnfLIReoqJicHDIjMEQx/PnoXKGdCL4+JygQoXyTJhwhOfPKzJrlroD+fTpy8fkz6/CWNGi4Oamglj8HcOMGfWq3HhiY1UYjb+be/06XL6swveFC2qpAKivS1QUlCsHHTvC2rWNSZculh07/tK1fkvTrt0Y1q6dgLf3CNatm6R3OUJYNAmgQuhs2LAFTJvWm0qVunD48FK9yzFLBgPcvAmHD8PRo3DqFPj6RvDsWQbgW/Lm7YOjo7rb16qV+lykSPLXTVqyuDi4dUvdAT51CpYtU9PvV65AZGQeoCsFC07Cw0MF08qVoWxZtSZV/NejR8/44IOs2NtnICIiRHa+C5FMEkCFMAPp07vx/Pl1/P2vU7Jkfr3L0V1UlJpiPnxYfRw5otoIgZpiLlsWPDxgwYLSVK1agWXLFuhbsAW5ffs+efM68cUXv2Fn1wpfXzh5Ut0tTZUKPD2hUiUVSCtXhjx59K7YPBQr1pgLF/5k9uz19O/fQu9yhLB4EkCFMANbt56gUaPyODmVIzj4uN7laC42Fk6fht27YdcuOHBAbcRJmxbKl38ZhipWhByvHDjTrVs3zp07x/HjKe9rllTbtm2jfv36BAYGUqBAAUBtkPL3V0E/PvRfu6YeX6gQ1KkDtWtDzZqQPbt+tetl796z1KpVig8+KMWDB356lyOEVZAAKoSZKFDgQ65e3cXChX/To0c9vcsxuWvX4K+/YOdO2LtX7f52dITq1VXYqVEDypSB1O9YFjt37lyGDh3Ks2fPSJUqlWa1W7LJkyczZcoUHj9+jK3t26eRg4Ph4EHYs0e9MbhwQf330qXV/5969dT/o7RpNSpcR5kyFSEs7DInTlymbNkCepcjhFWQACqEmbh9+xF58+YgdeoPiIy8p3c5RhcdDYcOwZ9/qo/z59WUb6VKKtDUqQNeXu8OnP/vwIEDVK9enTNnzuDuLi1xEqJNmzbcu3fv3xZWCXX7tgqju3apj5s31RuGDz+ERo2gYUPVUcDaTJy4ktGjO1GmTCt8fX/TuxwhrIYEUCHMSJMmg9iyZRZdukxg6dKv9C4n2Z4+VWHzjz9g2zbVWsjJSQWWRo2gbl3VUzOpwsLCyJQpE0uWLKFr167GK9yKFSpUiMaNGzN79uwkX8NggIAA2LJF/f89fFgtoyhdGpo0URvB3N21b19lbLGxcaRJk4W4uEjCwkJJnz4F3O4VQiMSQIUwI+oHXlZiY18QGvqYTJne0VncTD15ooLJb7/B33+r04E8PaFpUxU6PT3VbmxjKVSoEA0bNmTu3LnGu6iVevLkCZkzZ2bp0qV06dLFaNd99Ei9wYi/ux0aCgULqiDaurXaMGaJYbRBgy/5++9v+eSTqfz881C9yxHCqkgAFcLMTJ26luHD2+Hu3pIzZ37Xu5wEef4cNmyANWtg+3a1i71iRRVAvL1V301TadOmDcHBwezfv990g1iJ/fv3U6NGDfz8/ChVqpRJxoiKUmtG161Td74fPVK9V1u3Vj1ILWWlRFDQA5ydc5ImTXYiIu7qXY4QVkcamQlhZoYNa0vmzEXx8/uDo0cv6l3OW8XGqg1EXbuqafVOnVTYmDZNndBz5AgMGmTa8Ang6enJ6dOnifv/MzTFf/j6+pImTRqKFi1qsjFSp4b69WHhQrWRaccO+Ogj+OUXNUVfujTMmKEa6JuzGjVaA7EsWLBC71KEsEpyB1QIM3To0HmqVi1OliwlePTorN7lvCYgAJYuhZUr1caUQoWgc2cVQF1dta8nvq3Q5cuXKViwoPYFWJBu3boREBCAj4+P5mNHR6slGcuXw6ZN6vcffqj+7Xh7m1cD/E2bjtGsWUVy5fLizp1jepcjhFWSO6BCmKEqVYpRsmQzHj8+x8yZ6/QuhxcvVHCoVg1KlIBFi6B5c3Uq0cWLMHq0PuET1JnwAKdOndKnAAty6tSpf79eWkuVSm1Q+vVXdWf0p5/Uv6vOnSF3bvjySzh3TpfS/qN9+7aALbt2WcYSGCEskQRQIczUvn0rgNQMH96T2Fh9ppcDAqB/f3UaTpcu6kzxtWvV9Om8eVChgv6bS3LkyEGePHnw9fXVtxAzFxERQUBAgG4B9FWZM0PPnrB/PwQGwqefqvXDJUtC1arq2NAXL/SpbeDAHwgPv0HVql0pVswK+0oJYSYkgAphprJmTU+nTqOIiQnF23u4ZuPGxqrNIzVqqLudq1apsHDpklrz2aZN4np1asHDw0MC6HucPXuW2NhYPD099S7lNQUKwOTJqq/ob7+pqfiuXdVd0SFD4MYN7WqJiophzpzB2No6smuXHO8qhClJABXCjC1fPobUqbOzceNsgoNDTTrWkycwe7Zqn9OyJcTFqbtSN2/C1Klqrae58vDw4NSpU8iS9rfz9fXFzs7OZLvfkyt1atU1YccOdVe0Z0+1kcnNTe2gP3RI9R81pdq1e2IwvGDQoFmkTm1v2sGESOEkgAph5r79dgkQQ7VqbU1y/StX1Pq7vHlh6FA1BXr8uDqPvW1bNe1u7jw8PAgJCeGOuW+t1tGpU6coWrQoDua02+ctChRQ3RRu3VJLPfz81L9LLy+1+S062vhjnj9/i0OHluHo6My0ab2NP4AQ4jUSQIUwc717NyRHDk8CA7ezbZvxNtr4+UH79lC4sJpm799fTXcuXw7lyhltGE3ETyvLNPzb+fr6msX6z8RIlw769FHHtm7dClmzqm4LBQvC998bd51onTreQByrV6813kWFEG8lAVQIC7Bjx3rAhlatWif7WkeOqN3IpUurX3/3nerbOWGCWndnifLnz0+WLFkkgL5FTEwMfn5+Zrf+M6FsbaFBA3XaUvzd0H79VI/ZKVPU8pHkWLJkB3fv+uDiUoumTSsYpWYhxLtJABXCAri7O+Pl1YFnz64yatSiRD/fYIBdu6BWLahcWa2xW7oULl+Gzz4zrx6MSWFjY/PvOlDxXxcvXuTFixcWdwf0TUqVUtPwly6pVmBjx4KzM3z1lToIISk+/bQLYMe+fb8atVYhxNtJABXCQuzd+ws2NmmZMuVLoqJiEvy8gwdV8PzwQ3j6FNavV/0Wu3RRvRmtheyEf7v4r0uZMmV0rsR4ChSA+fPh2jX45BO1gc7VFcaPh7CwhF+nR48pREYG07BhX/Lnz2a6goUQr5EAKoSFcHBIzWefTSYu7jkNGvR97+NPnFDTltWqQWioOn3m+HFo0UJNaVobT09Pbty4waOk3gazYr6+vri6upI5c2a9SzG63LnV0Z7xQXTyZBVEp06F58/f/dxnzyJYvHgcdnYZ2bRppjYFCyEACaBCWJR58/qTJk1Odu/+iUKFilCkSBFKlCjBxx9/TEhICKDubjZvDuXLw/Xr6uSZU6fUuk+9m8abUvz08unTp3WuxPz4+vpa7PrPhMqRA2bOVF0d2rVTp3O5ucHcuRAZqR4TEhLCxx9/TIkSJShSpAjZsuXAYIhkyJAp2NnJj0MhtCRnwQthQe7fv4+7uwf37v233ZCLSwGqVj3CqlXZcXGBceOgQwews9O8TF3ExsaSMWNGxo8fz+DBg/Uux2wYDAayZs3K4MGDGTVqlN7laOb6dbWxbskStVlp5Mj7TJ5cmStXrvznsQUKFODIkSNkz55d6zKFSLHkLZ8QFmTYsGFvDJ8A169f4ddfhzJzpmpb07lzygmfAHZ2dri7u8s60P9z/fp1QkNDrWIDUmK4uMCiReDvD0WLwiefDHtj+AS4cuUKQ4cO1bZAIVI4OepBCAvi4+Pzzj93y7WP/tVPwVmNCjIznvnysefIEbXmQADgu3s3AJ729iny61Ic+HMCuJ3ax7Xgtz/ufd9bQgjjkgAqhAWJiXn37ve4G9egbFmNqjE/HsBPwPOyZUmndzFmwhfICeSsV0/vUnT1voYP7/veEkIYlwRQISyIjc27v2XtXV1h3TqNqjE/LZ88oVZYGI5581r3jqtEGBYeTvvgYLUjJwWzb9VKbZV/25/by49DIbQk33FCWIC4OLWe7do1LyDgrY/zqlEDrHy387tk/edDvJQeNQ2d0nnVqEHAOwLokydeXLmi+osKIUxPdsELYeb8/KBnT/DxgbZtQzh4pBy3g4L+8zjZySvE24WEhFCpUqU3bkTKmbMAdnZHePAgOyNHwvDhkDq1DkUKkYLILnghzFREhDpesGxZ1VD74EFYsyY7RUcUIr1XeooWK0rhwoUpXrw43bp1k/ApxDtkz56dI0eO0K1bN4oXL07hwoXJXagQ1K/Pzwe3celSdgYMgK+/VpMIR4/qXbEQ1k3ugIr3evZMnRWeklr66O3AAXXX8+pVFULj78hsvbyVRqsa8Xub32lZrKXeZQph0eIMBrxOngTAp2xZbG1sOHMGevRQDQP69YOJEyF9ep0LTUHCwiBjRr2rEFqQO6DinQwG8PaGli1VEBWmFRYGffpA9eqQNSucPg1jxqjwGRUbxcBtA6nlUosWRVvoXaoQFs/WxoY5BQty8tkzlgarHk2lS6u7nzNmwIIFULIkbNumc6EpxN9/q/6te/boXYnQggRQ8U42NuouwO7dULUqvGHpoTCSvXvB3R1WrIDvvlNT7sVf2T3yvc/3XH50mTn152AjO7yFMIqqmTPTLkcORly9Stg/rZjs7WHgQDh7Fv6Zpad3b3kTbioGg3rNa9QIKleGcuX0rkhoQQKoeK9GjeDwYQgNBS8vOHZM74qsS0SE+mFXqxY4O6tNR198AbavfHeGPA9h/L7x9PLshbuTu37FCmGFprm5ERYby6QbN177725usH07/PijemNYujQcOqRTkVYqOho+/1zd6OjfHzZuhAwZ9K5KaEECqEiQUqXULmw3N6hRA9as0bsi63DypNpk9P33aspvzx5wdf3v40bvGY2NjQ0Tak/QvkghrFy+tGkZlj8/s2/d4sqLF6/9mY0NfPopnDkDTk5qecyIERAZqVOxVuTxY2jYEH7+WX3MnCl7DVISCaAiwXLkUFPxrVpB+/YwdqyaOhGJFxurNjdUrAhp0qggOmjQ63c9450OPs2CkwsYX3M82RyzaV+sECnAkHz5cEqdmsFvOS++YEG1OfCbb1RQ8vJSU/QiaS5fhkqV1Gvf9u3wySd6VyS0JgFUJEratLB8uXoR/vpraNcO/u+GQbJFR0cTEPD2ZuuW7s4dqFtXbS4aNkxteChZ8s2PNRgM9P+7P0WzFaVPuT7aFipECuJoZ8f0AgXY8OABOx89euNj7OxUR4rjx9WbyPLl1Z07a30jHhsby7lz54x+3b17oUIF9XU7dkwtPxIpjwRQkWg2NjBypDrxcfNmNSV/967xrj9u3DiqVq3K5cuXjXdRM/HXX2od2cWL6m7yxInvbnj9+/nf2XdjH7PrzSaV3ftOsxZCJEeb7NmpmikT/QMDiYmLe+vjSpdWS5K6dIFevdSM0JMnGhaqkSFDhlChQgVCQkKMds2FC9Ub8LJl1ZvvQoWMdmlhYSSAiiTz9lZTUrdvq+koX1/jXHfw4MFkz56dJk2aEBoaapyL6iwqCoYMUeudvLxUe6WaNd/9nBfRLxi8fTCNCzemXsF6mtQpREpm809bpoDwcOa/5121oyPMnw9r16o3lh4eKpRai59//pnZs2czZcoUoxxwERurlhn17Kk+tm6FLFmMUKiwWBJARbKULatedJ2cVJumDRuSf80sWbKwZcsW7t+/T5s2bYj5pzWKpQoKgmrVYO5ctXZs82ZIyOv5rCOzuPP0DjM/mmn6IoUQAJTNkIHuOXMy+to1HkVHv/fxbdqoN9/ZskGVKjBnjuVPye/du5fPPvuMPn368Pnnnyf7emFh0KyZ+tp8+63adJlKJnRSPAmgItny5IH9+9XdvRYtYMqU5L8AFypUiHXr1rFnzx4GDBhgnEJ1sHOnOtbv3j3V13PgwDdvNPp/t8NuM+ngJPpV6EfhDwqbvlAhxL++cXMjxmBg3PXrCXq8m5v6/u7XDwYMUFPyltozNDAwEG9vb2rUqMHcuXOT3XP4+nUVzA8cgD//hL591TIuIezGjRs3Tu8ihOVLlUrtjo+LU7vjr11TgdTePunXdHV1xcnJiTFjxpAjRw7Kly9vvIJNzGCAadPg44/VneHt2xO31unzrZ8T9CSIdW3WkdY+rekKFUL8R3o7O1LZ2DA5KAjPwO5lAAAgAElEQVTv7NnJ8a6F2v+ws4N69aBECZg+Xa2Rr1sXPvhAg4KNJDQ0lDp16uDg4MD27dtJly5dsq53+DDUqaPedO/apXa9CxFP7oAKo7G1hQkTVMPmtWvVC09y16737t2bfv360a9fP3bu3GmcQk0sLEyF8eHD1cfWrYn7IXT01lFW+K1gUp1JZEqbyXSFCiHeql/evLg6ODAgMBBDIqZ0WrdWy5Kio9WJPps3m7BII4qJiaFt27YEBwezefNmsiRzgeaKFWp3e9Giaqf7q6e6CQFgY0jMd5YQCXTkCDRvrhbqb9mi7gokVUxMDE2aNOHo0aMcPXqUIkWKGK9QI7t0Sa11un1btatq1ixxz48zxFFpUSWiYqM40fMEdrbSlVkIvWx+8ICmZ8+yoWRJmmVLXA/eJ0+gWze1Ln7MGDUzlJDlN3rp168fP/zwA9u2baNOnTpJvk5cHIweDZMmqb//Tz+pXsdC/D8z/nYQlqxSJXUXIEMG9eu//kr6tezt7VmzZg25cuWiSZMmPHpLjz697d6tGsuD6hOY2PAJsMJvBT63fZhbf66ETyF01viDD/goSxYGBQYS+Y62TG+SKRP8/rvqmTxhArRtC+HhJio0mX788Ue+++475s2bl6zw+fy52pQ1ebJagvTLLxI+xdtJABUm4+yszk2uUQMaN1a7wJN6vz1Tpkxs3ryZR48e0bp1a6ITsDtVSwsWqPVf5curu79JuUn7LOoZw3cOp02JNlR3rm78IoUQiWJjY8PsggW5HhHB3Fu3Ev18W1vVM3n9erUUp0YNdRCFOdm5cyd9+/alb9++fPrpp0m+zu3b6pjSv/+GP/5Qbedks5F4FwmgwqQyZFBTUAMGQP/+0KePWhuVFAUKFGD9+vUcOHCAvn37JmpdlqnExKi/V+/e6uPPPyFz5qRda/KByTyOeMy0D6cZt0ghRJIVT5eOz/PkYeKNGwQn8QD45s3VLvngYPUm9dQpIxeZRJcuXaJ169bUqVOHWbNmJfk6J0+q/sYhIervmZTZH5HySAAVJmdnBzNmqBMwFi2CBg3g8eOkXat69er8+OOPzJ8/n++++864hSZSWBg0bQrz5r38SOqu/6uPrzLzyEwGVxqMc2Zn4xYqhEiWcS4upLKxYeS1a0m+Rnyj+jx5VGeM9euNWGASPH78mMaNG5MzZ07Wrl2LfRJfvNatU32O8+ZVf78yZYxcqLBaEkCFZnr0gB07VNPmihUhqSdt9ujRg0GDBjFgwAD+/vtv4xaZQMHBajrt0CE1tZbcXs1Ddgwhm2M2hlcdbpwChRBGkyVVKia4urIkOJgTYWFJvk6uXOoc9MaNVaeMefOMV2NiREdH07p1ax4+fMjmzZvJnIRpG4NBrW9t3Vrd8dy7F3LmNH6twnpJABWaqllTteSwtYUKFdTGnaSYOnUqDRo0oG3btgQEBBi1xve5dEltrLp/XzVX/uij5F1v97XdrD+/nml1p5EudfL67gkhTKNXrlyUSJeOLxPZlun/OTrCmjVqWVLfvjBihLYnJxkMBvr168e+ffv4/fffKViwYKKvEREBnTvDV1/B+PGwahU4OJigWGHVpA2T0EVoqNotuWePOpatV6/EXyMsLIwqVaoQHh7OsWPHyJbINilJcewYNGoEOXKoxfb58yfvejFxMXjO9yRDmgwc/Phgsk8dEUKYzq7Hj/nwzBlWFitGByenZF9v5kwYPBi6dFFLlLQ4nnLevHn07duXhQsX0qNHj0Q//949deKdry8sXapex4VICrkDKnSRObOauu7VS23e6d8fYmMTd42MGTOyefNmnj59ire3N1FRUaYp9h9btqjGykWKqIX2yQ2fAD+f/Bn/+/7MqTdHwqcQZq5Oliy0yJaNYVev8jyxL1hvMGgQrFwJq1erafmnT41Q5Dts376dL7/8koEDByYpfPr5qc1G167Bvn0SPkXySAAVurG3V3c/4zfwNGmiNvYkhouLC+vXr+fo0aP06dPHZDvjV6xQO1nr1VPnu2fNmvxrPn7xmNF7RvNxmY8pn8dyjhkVIiWbUaAA96OimB4UZJTrdeig+iQfOaJOjzNVm+Pz58/Tpk0b6tevz7Rpie+0sXmzOtM9a1bV59jLywRFihRFAqjQ3eefq7uhhw5B5crq3XViVK1alQULFvDLL78we/Zso9e3YIGaIuvSRe34NNZap/H7xhMZG8mkOpOMc0EhhMm5OTgwMF8+pt68SVBEhFGuWaeO2sRz9apaJ3/vnlEu+6+HDx/SpEkT8ubNy+rVq7GzS/ghFwaDWirQrBl8+KGa/cmb17j1iZRJAqgwCx99BEePwosX6p31oUOJe37Xrl0ZNmwYgwcPZsuWLUara/ZstUTgiy/UGq1EvG6/0/mQ88zzmcdX1b4iZ3rZOiqEJRmZPz+Z7e0ZeuWK0a7p6ammtR88UA3dk9D3/o2ioqLw9vbmyZMnbN68mYwZMybiudCzp1qnOmyYOtkpneyTFEYim5CEWXnwALy9VRhduFDttEyouLg4WrZsya5duzhy5AglS5ZMch0GA0ycqM5wHjFCtRsx1hJNg8FA/ZX1CXwUSMBnAaSxl7PqhLA0S4OD6XbhAvvLlKFaUk+feIPAQHVH1NYWdu0CN7ekX8tgMNCrVy+WLl3K7t27qVq1aoKf+/Chei0+fBh+/hm6dk16HUK8idwBFWYlWzbVK7RjRzXlPXIkJPQIZltbW1asWEGBAgVo0qQJ9+/fT1INBoMKnWPGqOA5aZJxj5T78/KfbL+ynVkfzZLwKYSF6uzkRPkMGfgyMJBYI97HKVhQtXdLlUo1eL9wIenXmjNnDgsXLmTBggWJCp8XLqg2eefOqVZ5Ej6FKUgAFWYndWp1YtL06TBlimrY/Px5wp6bPn16Nm3aRHh4OC1btiQykUfnxYfPqVPV9PvIkUn4C7xDVGwUA7cN5EO3D2lapKlxLy6E0IytjQ1zCxbE99kzFt+9a9Rr588P+/dDlixQu7bqPZxYf/75J4MHD2bo0KF069Ytwc/bsUMdFJI2rTrZKBG5VYhEkQAqzJKNjVp3tGEDbN+u7gQkdE1U/vz52bBhAydOnKBXr14J3hlvMMDo0S/DZ//+yfgLvMW3x77l6uOrzK43W9ouCWHhKmXKRMccORh17RpPYmKMeu2cOdUUfObMqv1bYGDCn3v27Fnat29P48aNmTQp4Zscf/hBHZVcubKaend1TULhQiSQBFBh1po2VRuSHjxQm5OOH0/Y8ypVqsSiRYtYtmwZ06dPT9Bzxo9XU+7Tp5smfN57do+v931Nn3J9KJkj6etThRDmY4qbG89iY5l444bRr+3kpKbAM2RQIfTq1fc/JyQkhCZNmuDq6sqKFSsStOM9JkadyvT55+rzpk2QiL1KQiSJBFBh9kqXVlNBzs5qd+hvvyXseR07dmTUqFEMHz6cjRs3vvOxEyaoADp5srrzagpf7f4Ke1t7xtUcZ5oBhBCay5s2LcPz52furVtcDg83+vVz5lQh1MFBhdDr19/+2MjISFq2bEl4eDibNm0iQ4YM773+kyeqCf5PP6mP2bNVj2YhTE0CqLAIOXOqYztbtFCnb0yYkLDzk7/++mtatGhBx44dOXPmzBsfM3262nA0YQIMH27kwv9x6u4pFvku4utaX/OB4wemGUQIoYvB+fKRK3VqBhqxLdOrcudWIdTeXq0JvX37v48xGAx8+umn+Pj4sGHDBpydnd973StXoFIldcTwtm2q5ZwQWpE2TMKivNoeqX17tVnpfY3hnz9/TrVq1Xjw4AE+Pj7kzPmy7+bCharP3ciRavrdNDUbqL6kOo9ePOLMp2ewt5XbC0JYm9/u36dNQAB/u7tTzxhHpb1BUJDaFJQxo9qk9Oow06dPZ+jQoSxfvpxOnTq991r790PLluoaW7ZA4cImKVmIt5I7oMKi2NiojUJr18Iff6gpqeDgdz8nXbp0bNq0iejoaFq0aEHEP6eXrF+v3vF/+qkKtaby67lfORh0kLn150r4FMJKtcqeneqZMjEgMJDohPaOS6T8+dWmzOBgaNToZXeQTZs2MWzYMEaOHJmg8Ll4sTrVqHRp1XNZwqfQg9wBFRbr+HF1PJy9vTqnuHTpdz/ex8eHGjVq4O3tTbduy2nUyIYWLWDlSuOdcPT/wqPDKTqvKJ65PNnQboNpBhFCmIXTT5/iefIkcwoWpJ8Jz6s8cUK9+a5cGSZN8qNGjcp89NFHrFu3Dlvbt99Xio1Vy4xmzIBevWDePNVvVAg9SAAVFu3WLbVT/tIlWLVK/fpd1q5dS7t27Uid+htq1RrJpk2q76ipjN87nm8OfEPA5wEUzFrQdAMJIcxC74sX+TUkhMteXmQz4YvL7t1Qv/49UqXyonDhrBw8eJB07zgn89kzdcDHli3qbPcvvzTuARtCJJZMwQuLljevOjWkXj1o3lxtKHrXW6qyZdvi4DCWqKhRdOmy3qTh8+aTm0w9NJWBlQZK+BQihZjo6orBYGDsu7arG0HlyhG4ubUgPDyK0qU34ej49vAZFARVqqiNnJs3qzZzEj6F3iSACouXLp1qzTRiBAwdCj16QFTUfx/38CE0bAj58o2hefM29OzZmVOnTpmsrmE7h5ExTUZGVRtlsjGEEOYle+rUjHFx4ac7d/B/9swkYxgMBnr27MmNG74MG7aRpUvzMXfumx979KjqoRwWBkeOqNdAIcyBBFBhFWxt1S72ZcvUms66dVXz+ngREeoOaWgo/PWXLStXLqZ48eI0bdqUO3fuGL2ewzcPs/rsaibXmUyGNO/vxSeEsB5f5MlDQQcHvgwMTPBJbIkxZcoUVqxYweLFi5kyxYuhQ2HgQHVy3KtWr4aaNdX58j4+UKKE0UsRIslkDaiwOocOqX6hGTKo9U5Fiqi1Txs2qCmoihXV4+7cuUP58uXJnTs3+/btw9HR0Sjjxxni8PrZCwCfnj7Y2sj7PCFSmq0PH9LI35/1JUrQInt2o113/fr1eHt7M2bMGMaPHw9AXBy0a6de7/buhXLl1MEaX38NXbrAggWQJo3RShDCKCSACqt0/bo63ePWLahfH379VU3Te3u//riTJ09SrVo1mjRpwpo1a4xyPvti38V039SdQ90PUTlf5WRfTwhhmRr6+XEhPJyA8uVJa4RWG76+vlStWpVGjRqxZs2a13a8v3ihWitdvqym3P/8U53sNmyYrPcU5kkCqLBaYWFQrRr4+anpqZkz3/y4devW0bp1a8aNG8fYsWOTN2ZkGIW/K0xt19qs8l6VrGsJISzbhefPKXXiBF+7uDAiAScTvcvdu3fx8vLCycmJ/fv3v3HG5sEDcHVV/UGXL1czP0KYK5kbFFbr/Hn1Ubu22h3/Nq1atWLChAmMGzeOtWvXJmvMb/Z/Q1hkGFM/nJqs6wghLF/RdOnomycP39y4wZ3IyCRf58WLFzRv3py4uDg2btz41uVC2bKpmR5HRzXrY6J++EIYhQRQYZXu3FHrQMuXh61b1Saldxk1ahQdOnSgW7duHD9+PEljBj4KZM6xOQyrMox8mfIl6RpCCOsyxtkZBzs7Rl69mqTnGwwGunfvjr+/Pxs3biRPnjzvfHz8kqPNm2HcuCQNKYQmJIAKqxMRoc44trWF339P2OJ7GxsbFi1aROnSpWnWrBm3bt1K9LiDtw/GKZ0TQ6oMSULVQghrlDlVKia6urL03j18wsIS/fyJEyeyZs0ali5dSrly5RL0nIYNYdIkmDAB1q1L9JBCaEICqLAqBoM62/30aXVWfM6cCX9u2rRp2bBhA/b29jRr1ozn8QctJ8COKzvYeHEj0+tOxzGVcXbTCyGswye5cuGeLh39Ll8mLhHbLn777TfGjBnD119/TevWrRM15rBh0LYtdO2q1sELYW5kE5KwKvPmQd++qh9o585Ju8aZM2eoUqUK9evX59dff33n2coAMXExlPmpDFkcsrC/236j7KQXQliXvY8fU+vMGZYVLUrnBLwzPnHiBNWrV6dZs2asWrUqSa8r4eFQtSo8fgynTkGWLEmpXAjTkDugwmr4+Kjd7v36JT18ApQuXZoVK1awfv36BO2K/+nETwSEBDC3/lwJn0KIN6qZJQutsmdn+NWrPIuJeedjb9++TbNmzShVqhS//PJLkl9XHB3VTNCTJ9Ct27uPKRZCa3bjxskyZWH5Hj1SPfAKFVKnfyS35V7RokVJmzYtY8aMoXDhwpQqVeqNj3sY/pCWa1vSsVRHepfrnbxBhRBWzStDBqbfvInBxobab7kdGR4eTr169QgPD2fXrl1kSeZty8yZoWRJGDtWHVtcpUqyLieE0cgdUGHx4uLUOqenT9Xuz9SpjXPdoUOH0qVLF7p3787Ro0ff+Jixe8cSa4hlYu2JxhlUCGG1XBwcGJI/P9ODgrj+4sV//jwuLo6uXbty/vx5Nm3aRK5cuYwybqNGMHw4jBgBBw4Y5ZJCJJsEUGHxpk9XR9CtWAH58xvvujY2NixYsIBy5crRvHlzgoKCXvvzs/fP8tOJnxhdfTRO6Z2MN7AQwmoNz5+fD1KlYugb2jKNHz+edevWsWLFCjw8PIw67oQJ6u5nu3Zw/75RLy1EksgmJGHRDh6EmjXVjs9vvjHNGPfv38fLy4vMmTNz8OBB0qdPj8FgoO7yugQ9CeLsZ2dJbWek265CCKu3IjiYzhcusLdMGWpkzgzA6tWr6dChA5MmTWLEiBEmGffuXShTBtzdYdu29/dHFsKUJIAKixUaCqVLg7Mz7N4N9vamG8vf35/KlStTp04d1q9fz+ZLm2m+tjmb22+mceHGphtYCGF14gwGKp86RURcHCfLleOEjw81atSgdevWLFu2zKSbGXfuhLp11czR4MEmG0aI95IAKiySwQAdOsBff6ked8acen+bLVu20LRpUwYNGcQfef6gYNaC/NXxL9n5LoRItGNhYVQ8dYrJ6dIxt2lTXF1d2b17N2nTpjX52EOGwNy5cOwYGHmmX4gEkwAqLNLy5dClC6xZo5ota2XmzJkMHjwYmxY2nJ1/luLZi2s3uBDCqnQ4eZLf2rcnZ2QkJ3x8cHLSZi15ZCRUqgQvXsDJk6pdkxBakxUgwuJcvQqff64CqJbhE6BDrw7Yl7XHPcZdwqcQIll629sTGxFBre+/1yx8gjqeeNUquHEDBg3SbFghXiN3QIVFiYmB6tUhOFgdt5kxo7bjd9/YnY3nN3K532WyOmbVdnAhhNX55upVxt28ydny5Smi8a3I+fPV0cUbN0LTppoOLYTcARWWZcYMtW5pxQrtw+eJOydYfHoxE+tMlPAphDCKQc7O5EuThgGBgZqP3auXCp49e8KDB5oPL1I4uQMqLEZAgFow378/TJ2q7dgGg4Gqi6vyNPIpp3qfwt7WhFvuhRApyvqQELzPnWNrqVI0+OADTccODobixaF+fTUtL4RWJIAKixATA5Urq9OOfH1Bg42ir1ntv5oO6zuwq8suarvW1nZwIYRVMxgM1DlzhjuRkfiXL08qjRt0rlwJnTrB+vXQooWmQ4sUTKbghUWYOVPt1ly8WPvw+TzqOUN3DqVlsZYSPoUQRmdjY8OcggW5/OIF827f1nz8Dh2gWTO1HvThQ82HFymUBFBh9gICYMwYtVuzYkXtx592aBohz0OYXne69oMLIVIE9/Tp6Z07N+OvXyckKkrTsW1s4McfIToa+vXTdGiRgkkAFWYtNhZ69ABXVxg/Xvvxb4TeYNrhaQysNBC3LG7aFyCESDG+dnHBxsaG0deuaT52rlzw7bdqHeimTZoPL1IgCaDCrC1YAEePwsKF4OCg/fjDdg4jS9osjKhqmrOZhRAiXrbUqRnn4sKCu3c5/fSp5uN37AgNGsAXX8CzZ5oPL1IYCaDCbAUHw4gR8MknULWq9uMfuHGAtefWMuXDKWRIk0H7AoQQKc5nuXNTxNGR/oGBaL1H2MYGvv8eQkJg3DhNhxYpkOyCF2arfXvYuRMuXACNO5MQGxdL+Z/LY29rz9FPjmJrI+/VhBDa2PboEfX9/PiteHFa5cih+fiTJ8Po0WrjZ+nSmg8vUgj5qSrM0vbt6pz3mTO1D58AS04vwTfYl7n150r4FEJoql7WrDTKmpUhV6/yIjZW8/EHDYIiRaB3b4iL03x4kULIT1Zhdl68gM8+g1q1oHNn7cd/EvGEkbtH0sm9E5XyVdK+ACFEijerYEFuRUYy69YtzcdOnVod03nsmFqHL4QpSAAVZmfmTAgKgh9+UGuStDZx/0SeRT1jSp0p2g8uhBBAYUdHvsyTh0k3bnA7MlLz8atWhe7dYeRI6Q0qTEMCqDArt26p9Uf9+0PRotqPf+nhJeYem8uIqiPIkzGP9gUIIcQ/Rru4kM7OjuFXr+oy/uTJqhXe2LG6DC+snARQYVaGD4f06eGrr/QZf9D2QeTOkJtBlQbpU4AQQvwjk709k1xdWXHvHkeePNF8/Bw51CEgP/4I/v6aDy+snOyCF2bj8GGoUkX1/OzRQ/vxtwVuo/7K+vzW+jdaFW+lfQFCCPF/Yg0Gyp88ib2NDUc9PbHVeF1SVBSULAn588OOHfosixLWSQKoMAtxcVChgvrs4wN2dtqOHx0bTemfSpM9XXb2dt2LjbzKCiHMxIHQUKqfPs3SokXpkjOn5uNv2QJNmsCGDerMeCGMQabghVlYvhxOnIC5c7UPnwA/nviRCw8uMLf+XAmfQgizUi1zZtpkz87wq1d5GhOj+fiNGkG9ejBwIOiwH0pYKQmgKcj48eOZNWuW5qdrvM+LF2rNZ6tW+px49CD8AWP3jqWnZ0/K5CyjfQFCCPEe0woU4HFMDJODgjQf28YGZs2C69dVeyZzc/PmTRo0aECQDl8bkXQSQFMIg8FAREQEgwYNomfPnkRFReld0r++/x7u3oVvvtFn/DF7xmAwGJhYe6I+BQghxHs4p03L0Hz5mHnzJldfvNB8/OLFoVs3mDgRdDim/q2OHTtG+fLlCQgI4Kk5FSbeSwJoCmFjY8PkyZNZsmQJy5cvp27dujx48EDvsggNhUmToGdPKFxY+/H97vkx/+R8xtQYQ/Z02bUvQAghEmho/vzkSJ2awVeu6DL+uHEQFqZ6NZuD1atXU6NGDQoUKICPjw8lSpTQuySRCBJAU5iuXbuye/duzp8/T4UKFQgICNC1nmnT1JqiMWO0H9tgMND/7/4UylqIL7y+0L4AIYRIhHR2dkx1c+OPBw/Y/fix5uPnywd9+8KMGXDvnubD/ysuLo6xY8fSoUMH2rRpw65du3ByctKvIJEkEkBToCpVquDj44OjoyOVKlXi77//1qWOO3dgzhzVdD5XLu3H/+PCH+y5vofZ9WaT2i619gUIIUQitc+Rg8oZM9I/MJAYHQ5qHzEC7O3VVLwewsPDadu2LV9//TWTJ09m6dKlpE2bVp9iRLJIAE2hXFxcOHToENWqVaNRo0Z8++23mm9OmjgRHBxg6FBNhwUgIiaCwdsH06BgAxoUaqB9AUIIkQQ2NjbMLVgQ/+fP+fnuXc3Hz5pVHRgyfz5cu6bt2Ldv36Z69eps3bqV9evXM3z4cOlaYsEkgKZgGTNmZOPGjQwYMIAvv/ySPn36EB0drcnYN2+qhvNDhkCmTJoM+ZrZR2ZzM+wms+rN0n5wIYRIhnIZM9ItZ05GX7vGY41es1/Vrx9kyaKO6tTKiRMnKF++PPfu3ePgwYO0aNFCu8GFSUgA1UhoKNy4oXcV/2VnZ8eMGTNYtGgRv/zyC/Xr1+fRo0cmH3fKFMiQAT7/3ORD/cedp3f45sA39PXqS9FsOhw4L4QQyTTJ1ZVIg4Hx169rPrajIwweDIsXa/Nz7bfffqN69erkz5+f48eP4+HhYfpBEykmBnTeUmFxJIBqZPlycHGBmjXhl1/UTkJz0r17d3bs2MGZM2eoWLEiFy9eNNlYt26pu5+DBqkQqrURu0bgkMqBMTV02PkkhBBGkCtNGr5ydmbe7dsEPH+u+fiffQaZM5v2LqjBYGDChAm0adOG5s2bs2fPHnLqcBLU2xgMcPKk2seQJw9Ur66OLhUJIwFUI926wdKlkCoVfPIJODlBu3bw55+gwwzKG9WoUYNjx45hb29PxYoV2bFjh0nGmToV0qWDL3TYeH7s1jGWnVnGxFoTyZw2s/YFCCGEkfTPmxeXtGkZEBio+Rr+dOnUXdBffgFT9H9/8eIFHTp0YMyYMUyYMIGVK1fi4OBg/IGSIChIBe8SJaBcOVizBjp2hB071M94kTByFrwObt2CVavUXdGzZyF7dmjfHjp3hrJl1akTenry5Alt27Zl586dfPvtt3z22WdGu/adO+Dmpk4++uoro102QeIMcVReVJmImAhO9jqJna0OZ34KIYQRbXzwgOZnz7K5ZEkaZ8um6djPnqmZvTZt4IcfjHfdu3fv0qxZM86ePcuyZcto1aqV8S6eRGFh8Pvv6uf23r2QNi00bw5dusCHH6rOACJxJIDqyGCAM2fUP+hVqyA4GIoVU0G0Y0fIn1+/2mJiYhg8eDBz587l888/Z86cOdgb4Tts4EC1buj6de03Hy0/s5wuG7qwt+tearjU0HZwIYQwAYPBwEd+ftyIiOBs+fKkttV2YnPyZNWg/to1yJ07+dfz9fWladOmxMXFsWnTJsqWLZv8iyZRTIy6q7lsGWzcCBERUKuW+hndsiVkzKhbaVZBAqiZiImBnTtVGP3jD/UPvUYN9Q+9VSv9/qHPnz+fL774glq1avHrr7+SOXPSp60fP1aNjPv3176H3LOoZxSZV4TK+SrzW+vftB1cCCFM6OyzZ5Q+cYKpbm4M1vjOxZMn6nX9s8/U5tLk+OOPP+jUqRPFixdn48aN5DZGok0kgwF8fdXP4tWrVcP94sXVnc4OHdTfVRiHrAE1E/b2UL8+rFyp/sEvXgx2di/Xi7ZvD1u3qqCqpd69eyvCVcYAACAASURBVLNt2zZOnDhBxYoVCQwMTPK1fvpJ1d+3rxELTKApB6fwMPwh0+tO135wIYQwoZLp09Mnd24m3LjBPY13wWTKBL17q9f3pB7FbjAYmDx5Mi1btqRRo0bs27dP8/B586YK0CVLqqVwq1apn7snT6qlcsOGSfg0NrkDauZu3VKhdPlyOHcOcuRQ3xRduoCHh3brRS9fvkzjxo0JCQnh999/p1atWol6fmSkWivUpAksWGCaGt/m2uNrFPu+GEMqD2FC7QnaDi6EEBp4GB1NoWPH8M6enZ+LFNF07Fu3wNVVHa08YEDinhsREUHPnj1ZsWIFY8eOZcyYMdhqtIzg6dOX6zr37IE0aV6u66xbV9Z1mpoEUAthMMDp0y/Xi8ZPC8SvF9Xindnjx49p06YNe/fu5fvvv6dXr14Jfu6iRdCzJ5w/Dxq/NtLq11YcvXWUi19cJF3qdNoOLoQQGpl36xb9AgM5UbYsnhr3uOvaVYW4K1cSvhP83r17tGjRAl9fXxYvXky7du1MWyQv13UuXw4bNqjlbjVrqp+l3t6yrlNLEkAtUPx60WXLtP8GiomJoX///nz//fd8+eWXzJgx472bk+Li1LRG4cKqXi3tvb6XWktrsbzFcjq5d9J2cCGE0FBMXBxlTpwgS6pU7C9TRtNjKv39wd1dzdh16PD+x/v5+dGkSROioqLYuHEjXl5eJqvtTTdwihVTdzq1uoEj/ksCqIULC4P1619OIcS3hujc2bRTCPEB9KOPPmL16tVkeseW9q1boVEjOHAAqlY1TT1vEhsXi+cCTxxTOXK4+2E5M1gIYfV2PnpEXT8/1hQvTtscOTQdu0EDuH8fTpx49/KwTZs20aFDBwoXLsymTZvImzevSep52xK2zp3B01P/locpnQRQK3Lz5stvtoCAl5uXOnc2zXrRHTt20Lp1a/LkycPmzZtxc3N74+MaNlQvSsePa/sNP//EfD7981OOfXIMrzyme3cthBDmpLm/P77PnnHeywtHO+36Hf/1l3q9P3wYKlX6758bDAZmzJjBsGHDaNGiBcuWLSNdOuMui3r69OVNmd27X67rjL8pI43izYcEUCv0ahuJVatU+CtR4uV6UWO+2bxw4QJNmjTh8ePHrF+/nurVq7/251euQKFCag3oxx8bb9z3CY0IpdB3hWhUqBFLmi/RbmAhhNBZYHg4xY8fZ5SzM2NdXDQbNy5OLbWqWBFWrHj9zyIjI/n0009ZsmQJI0eOZMKECUbbbPT/bQxfvHh9WZrWPadFwkgAtXKvNtLdsEHtRo9vpOvtbZyz2B89ekSrVq04ePAgP/30E927d//3zwYPVi2lbt0CLU9RG7htIAtOLuBS30vkzqB9LzkhhNDTsCtX+O72bS56eZEvbVrNxp01C0aMUMdVOjmp/xYSEkLLli05fvw4CxcupFOn5K/HN+eDXETCSB9QK2dvr9blxDfUXbRIfeN2765eHDp2hL//Tl5/0axZs7Jt2zY+/vhjevTowZAhQ4iNjSU8XI3Xo4e24fPCgwt85/Mdo6qNkvAphEiRRjk7k9HOjmFXr2o67scfqx7WCxeq3589exYvLy8uXbrEnj17kh0+b99W7Z7c3dXSsuXL1VGgx4+rdZ4jRkj4tBRyBzSFil8vumyZao3k5KR2LnbuDGXKJG2tpsFg4LvvvmPAgAE0bNiQ+vVX0bdvBq5cUT3itNJwZUMuPLhAwOcBpLXX7p2/EEKYk8V379L94kUOlClD1WScYpdYn3wC27bBDz9spWPHdri6urJp0yacnZ2TdL1nz16u69y1S63rbNZM/bz66CNZ12mpJICmcAYDnDr18tix+/dVy6TOnVUgTcp60b///pu2bdsSFZWfSpU2s3u3i9Hrfputl7fSaFUj1rdZT4tiLTQbVwghzE2cwYDXyZMYgONly2Kr0S7QU6cMlC07B1vbwTRu3JiVK1eSPn36RF0jNvb1dZ3h4a8fTy3rOi2fBFDxr+ho2L5dfcNv3KjWi9aurb7hW7ZM3HrR9esD8PZuQqZMT/nzzz+oUqWK6Qr/R1RsFKV+LEWeDHnY1WWXtF0SQqR4h588oYqvL4uKFKF7rlwmHy8qKoovvviCn3/+mQIFhnLx4iTsErETP35d58qVal1n0aIv13Um8QaqMFOyBlT8K1Uq1a9zzRr1jb9woXoX2q0b5MypXgC2bUvYetH9+4uTPfsx3N2LUbt2bZYtW2by+r/3+Z7AR4HMrT9XwqcQQgCVM2WifY4cjLx6lbDkLPZPgIcPH/LRRx+xZMkSunRZwvXrUwkJeX/4vH0bpk9X6zrLlIGlS6F1a7WuMyAARo6U8GmNJICKN8qUSW1U2rMHrl+HUaPUVH39+urUiEGD1MkSb7p/HhmpWnB065aNnTt30KlTJ7p27cqIESOIi4szSb33n99n/L7x9C7bm1JOpUwyhhBCWKKpbm6ExcbyzY0bJhvj/PnzVKhQgXPnzrF7927mzu1KqlTqbub/2rvzsKrKvY3j92aDiCJOWA44wlbQsJxwKEVLw7LUPGlqedLLU5Z1RE15o9KjpnnUVOhUaplZNvjaoGl6RLOMNBXyhCmEgDig8gpq5gAy7vePnQ0nB4a1F9P38w9d7L1+z+/yor3uvdZ6nudqLl50vNavn+OcMm2aYxb7hg3SyZPSK69InTuzWHxlxi14FJndLu3d+9vzopmZjudF//pXx/OiTZo43vfxx45vrwkJjg8Uu92uxYsXa8qUKRo0aJBWrVpV7OeBbmTchnFak7BGyX9PlncNb0NrA0BFN+vIEc0+elTxXbrIVqOGobWjoqI0bNgwNW3aVBs2bFDLX2adjhzpWJM6IcERJAsKHJOIVq1yTCrKypJ69frtuU4T50mhHCCAokR+/7zounVSbq50112OD5L33nPsRrFr1x+P+fzzzzVixAj5+vpq/fr1ambQWhlx/xenjss6KqJ/hCZ0nWBITQCoTLIKChQQE6PbPD31WaAxd4nsdrteffVVTZw4Uffcc48++OADeXl5/fr6F184rnC++670ww+O5zrT06U2bX57rtPEdfJRzhBAUWo//+y46rlqlfT1147fTZ4sLVz45/ceOHBA999/v7Kzs7Vu3Tp169atVGPb7Xb1fqe3Mi9lat8T++RmZT0OALiaNRkZeighQVvbt1ffevVKVSsvL0+hoaFasmSJnnnmGc2bN+9Pk40KCyVPT8fORN7e0vDhjjtm3FqHRACFwaZPl156ybEF57UeGs/IyNCQIUP03XffacWKFRo5cmSJx/s44WMN/WioNj+8WSF+ISWuAwCVnd1uV3BcnM7m5Smuc2e5lnArzLNnz2rYsGH6+uuvtXTpUo0dO/aa733gAcdufKdOSQZv+44KjklIMFRUlHTffdefsXjTTTdp27Zteuihh/Twww9r2rRpJZqclJ2XrSlbpui+1vcRPgHgBiwWiyL9/JSQlaVl6eklqpGUlKRu3brp+++/1xdffHHd8ClJs2ZJly45JrQCv0cAhWEOHZJiYqQRI278Xnd3d61cuVLz5s3TnDlzNGzYMF26dKlY4y3ctVAnL5zUorsXlbBjAKhaOtSqpbGNGmna4cM6k5dXrGO3bdumrl27ymq1KiYmRsHBwTc8JjBQatfOMXEV+D0CKAzzv/8r1ajhuAJaFBaLRWFhYVq7dq02b96sXr166cSJE0U69vj545q7Y65Cu4bKVt9Wiq4BoGqZ3bKl8u12zThypMjHLF26VCEhIeratat2794tX1/fIh87fLhjc5OsrBI0i0qLAArDfPihY3/e4j7nM2jQIO3cuVOZmZnq0qWLvvvuuxse8+wXz8qzmqde6PVCCbsFgKrp5mrVNL15cy05cULxN7jzlJ+frwkTJujJJ5/U008/rc8//1y1i7kP5vDhjtvwn39emq5R2RBAYYj4eOnAAccHTUnceuutiomJUfPmzdWzZ0+tWbPmmu/dlbZL7+9/X3PunKPa1dkQGACKa4KPj1p5eGhSSoquNRf53LlzGjBggJYsWaKlS5cqIiJCrq6uxR7Lz88x853b8Pg9AigM8emnjr3iQ0oxF6hhw4b66quv9Je//EUPPfSQZs6c+acPxkJ7oUI3h6pjo44ac9uYUnYNAFVTNRcXLfL11dafftKGM2f+9HpKSoq6d++u2NhYRUVFady4caUab9gwxyRVbsPjCgIoDLFunXTvvZK7e+nqVK9eXatWrdKcOXM0Y8YMjRgxQtnZ2b++vmrfKsWejFVk/0hZXW68xzAA4OoG1K+vkLp1NTklRTm/W4lk+/bt6tq1qwoLC7Vnzx7deeedpR5r8GDHeqBbtpS6FCoJAihKLS3NsU/84MHG1LNYLHruuef0ySefaMOGDQoODlZ6erou5FzQs9ue1UPtHtIdze4wZjAAqKIsFosW+/npyOXLijh+XJK0fPly9evXTx07dtTu3btlsxkzydNmk9q2dUxGAiQCKAzw2WeSm5t0zz3G1h0yZIi++eYbnTx5Ul26dNGEtyfo3OVzmt9vvrEDAUAVFVCzpp5q0kQvpqZqXGioHnvsMT3++OPatGmT6tata+hYgwZJGzZI+fmGlkUFxU5IKLV+/SQXF8fzPc6Qnp6u/gP664cDP2jMwjFa8fcVzhkIAKqgn/Ly1PDuu5X3zTf6V2SknnrqKaeMExMjde3q2LK5Vy+nDIEKhCugKJWffpK2bzfu9vvVNGrUSC0mtVCt4FqaN2qe8wYCgCqorpubHh05Uva5c9V11CinjdO5s9S4sWPOAEAARals2eK4nXL//c4bY1vqNq1PXa9li5apQZ0GzhsIAKqo18eO1S29eyv0OssylZaLi+NcwXqgkAigKKUtWxzbrPn4OKd+fmG+JkZN1O1Nb9fwW0q4yCgA4LpcXVwU4eenb8+f1+qMDKeNExIiJSdLhw87bQhUEARQlJjd7njuszRrf97Im3vfVHxGvCL7R8pisThvIACo4u6qW1cPeHsrLDVVlwoKnDLGnXdKVivLMYEAilJISJBOnHBeAD2bfVbTvpqmMbeNUafGnZwzCADgVy/7+iojN1fzjh1zSv3ataXu3Z03aRUVBwEUJRYVJVWvLvXs6Zz6M7fPVG5BrubcNcc5AwAA/qCVh4eeadpUC9LSdPTyZaeMcffd0rZtUl6eU8qjgiCAosSiohxLaXh4GF87ITNBr8W+phd6vaCGng2NHwAAcFXhzZqprqurwg4dckr9kBDp/Hlpzx6nlEcFQQBFieTkSNHRjm+yRrPb7ZocNVkt6rRQaNdQ4wcAAFxTLVdXzW3VSmsyMxV97pzh9Tt1kurVk7ZuNbw0KhACKEokNla6fFnq08f42huTNyrqUJQW3r1Q7q6l3FweAFBso26+WV1q1dLElBQVGLwsk9XquHsWHW1oWVQwBFCUSHS0VKuWdOutxtbNLcjVpKhJ6tuqrwa2GWhscQBAkbhYLIr089P3Fy/q7fR0w+v36iXt3u24m4aqiQCKEomOlu64w/FN1kiv7HlFh386rMUhi1l2CQDKUPfatfXIzTfrucOH9bPBG7gHBzvuon33naFlUYEQQFFs+fnSzp3G7+V76uIpzfp6lp7s/KRuuekWY4sDAIrtn61a6VJBgWYdOWJo3VtvddxF4zZ81UUARbHFxUkXLxofQJ//8nm5urhqRu8ZxhYGAJRIE3d3Pde8uV45cUJJWVmG1bVaHXfRCKBVFwEUxRYd7Vj/s3Nn42r+J/0/WvH9Cr3Y50XVr1HfuMIAgFKZ7OMjH3d3PWPwsky9ekk7djjuqqHqIYCi2Hbvlrp0kapVM6ae3W5X6OZQtW3QVuM6jzOmKADAEB5Wqxa0aqXPz5xR1NmzhtXt0cNxN+3HHw0riQqEAIpii4mRgoKMq7cmfo12HNuhxSGL5erialxhAIAh/tKggYJr19aklBTlFRYaUrNjR8nFxXFOQdVDAEWxZGRIR48aF0Cz8rI0detUDWozSP18+xlTFABgKIvFogg/Px3MytKSkycNqenpKbVt61hXGlUPARTFcuWDoksXY+ot2LlApy6d0st3v2xMQQCAU9xWq5b+1qiR/nHkiE7n5hpSMyiIK6BVFQEUxRITI3l7Sy1alL5W2s9pmrdzniZ1myS/en6lLwgAcKrZLVvKbrdrmkHLMnXpIv3wg5SdbUg5VCAEUBRLbKzjG6sRa8SHfREmL3cvPdfzudIXAwA4XYNq1fSPFi30xsmT+uHixVLXCwqSCgocy/uhaiGAolj27jVm+aUdx3Zo9YHV+mfff8rL3av0BQEApniqSRPZPDw0MSVF9lLuEx8Y6FhRhR2Rqh4CKIrs1CnHJKT27UtXp9BeqNDNoercuLP+eutfjWkOAGCKai4uWuTnp6/OndO606dLVcvNTQoIkPbvN6g5VBgEUBTZlQ+IwMDS1VkZt1L/Sf+PIvtHysXCnyAAVDT31q+ve+rV0zOHDulyQUGpagUGEkCrIs7+KLL9+yUPD8nXt+Q1zuecV/i2cI24ZYR6NO1hXHMAAFMt8vVVWk6OFh8/Xqo6gYHSgQOSQcuLooIggKLI9u93rNlmtZa8xuzo2bqYe1Hz+803rjEAgOn8a9bU35s00ZyjR3UyJ6fEddq3d+yIdPSogc2h3COAosj27y/d7ffkM8mK2B2hZ29/Vj5ePsY1BgAoE9ObN5eH1arw1NQS17hyXvnhB4OaQoVAAEWRFBZK8fGlC6DPbHlGjWo10pQeU4xrDABQZuq4uWlOy5Z699Qp7Tl/vkQ1GjeW6tblOdCqhgBqkLy8PEVFRZV6SYry6vhxx0LB/v4lO37LoS3akLRBC/otkIebh7HNAQDKzNhGjXRrzZoKTU5WYQnOgRaL49ySlOSE5sqJM2fOaNeuXWXdRrlCADXIunXr1L9/f/Xv318JCQll3Y7hkpMdP2224h+bX5ivSVGT1LNZTw1tO9TYxgAAZcr6yz7xey5c0AenTpWohs3223mmMsnLy9O//vUv2Ww2jRkzRoXMtPoVAdQgDz74oD777DMdOnRI7du3V2hoqM6ePVvWbRkmOdkx+agkW3Au/W6pfsz8UZH9I2UxYgslAEC50rtuXT3YoIH+JzVVF/Pzi318ZQygW7du1W233abQ0FA9+OCDio6OlosLsesK/iUMYrFYNHDgQMXHx+ull17SihUrZLPZ9Prrryu/BP8zljfJyY7w6eZWvOPOZJ3R9K+ma2yHserQqINTegMAlL0FrVrpTF6e/nnsWLGP9fOTzpyRfvrJCY2ZLCUlRYMGDdLdd98tb29v7d27V2+88YZuuummsm6tXCGAGszd3V1hYWFKTk7W4MGD9fTTT6tDhw768ssvy7q1UklJKdnt939s/4cK7AWac9cc45sCAJQbLTw8NLVZM72clqbD2dnFOvbK+SUlxQmNmeT8+fMKCwtT27ZtFRcXpzVr1mj79u3q0IGLL1dDAHWShg0b6q233lJMTIy8vLx01113aciQIUotxVIVZSk5ufgBdP+p/Vry3RJN7zVdN9Xkmx8AVHbPNmsmbzc3TT10qFjHXTm/VMTb8IWFhb/e9Xz11Vc1bdo0JSYmaujQoTx2dh0EUCfr3LmzduzYoQ8++ECxsbEKCAhQeHi4Lly4UNatFZndLqWmFm8HJLvdrklRk+Rb11d/7/p35zUHACg3alqtmufrq09On9ZXxbif7uUleXtLxcytZW7nzp0KCgrS2LFj1bdvXx08eFDTpk2ThwervdwIAdQEFotFI0aMUGJiosLDwxUREaHWrVvrnXfeqRAz4k6flnJypGbNin7M+oPrte3wNi0KWaRq1mrOaw4AUK6MvOkmdfPy0sSUFBUUY1mmpk0dS/5VBMeOHdOIESN0xx13yGKxaOfOnXr//ffVtGnTsm6twiCAmqhmzZqaMWOGEhMTFRwcrNGjR6tbt27lfm2wtDTHT58ibl6Uk5+jyVsmK8Q3RANsA5zXGACg3LFYLIr089MPly5peXp6kY+rCAE0KytLM2fOlL+/v7Zv3663335be/bsUY8ePcq6tQqHAFoGmjdvrtWrVys6Olr5+fnq0aOHRo0apRMnTpR1a1d15QOhqF/sInZH6Oi5o1ocspjnXwCgCgry8tKjN9+s51NT9VNeXpGO8fH57YJHeWO327V69Wr5+/vrpZdeUmhoqJKSkjR69GiWVioh/tXKUM+ePRUbG6vly5dry5Ytat26tWbPnq3sYs4edLa0NMfyS0VZQSL9QrpmfzNbT3V5SgENApzfHACgXJrbqpVy7HbNPHKkSO8vr1dA9+7dq549e2rEiBHq1KmTEhISNHfuXNWqVausW6vQCKBlzGq1auzYsUpKStL48eM1a9YsBQQE6OOPPy4323oePy41aSIV5Uvec18+J3eru2b0nuH0vgAA5Vcjd3c936yZXjt5UomXLt3w/T4+jnVAi/BWU5w6dUp/+9vf1KVLF507d05bt27V2rVr5VucGbm4JgJoOVG7dm0tWLBABw4cUGBgoIYOHao+ffooLi6urFtTWlrRnv+MPRGrlXErNfvO2arrUdf5jQEAyrWJPj5q5u6uyUWY3n7lMa+yvgqak5OjBQsWyGazae3atXr11VcVFxenvn37lm1jlQwBtJxp3bq1NmzYoM2bNysjI0MdO3bUuHHjlJmZWWY9ZWRIDRte/z12u10Toyaq/c3t9VjHx8xpDABQrlW3WrXQ11f/PntWG8+cue57b77Z8TMjw4TGrsJut2vDhg265ZZbFB4ertGjRys5OVnjx4+Xq6tr2TRViRFAy6mQkBDt27dPERERWrNmjWw2mxYvXqzc3FzTezl92rE+2/V8eOBDfZv2rSJCImR1sZrTGACg3Bvk7a0769TR5JQU5V5n6cEGDRw/y+J6S0JCgvr376+BAweqZcuW2rdvn1555RXVq1fP/GaqCAJoOebm5qYJEyYoOTlZI0eO1JQpUxQYGKhNmzaZ2kdm5m8fDFdzKfeSwraGaUjAEPVp2ce8xgAA5Z7FYlGEn59SsrP12nVWe6lTxzHX4PRp83o7e/asJkyYoPbt2+vQoUP67LPPFBUVpXbt2pnXRBVFAK0AvL299frrrysuLk5NmjTRgAEDdO+99yoxMdHpY9vtN74COn/nfJ3OOq0F/RY4vR8AQMUT6OmpcY0ba+aRI8q8xp08q1WqV8+cK6D5+fl6/fXXZbPZtHLlSs2dO1fx8fEaOHAgyweahABagQQGBmrbtm369NNPlZiYqMDAQE2ePFnnzp1z2phZWdLly9cOoEfPHdX8b+frme7PqFXdVk7rAwBQsc1q0UIWi0UvHD58zfc0aOD8K6Dbtm1Thw4d9PTTT2vw4MFKSkrS1KlT5e7u7tyB8QcE0ArGYrHogQceUEJCgmbNmqU33nhDNptNy5YtU0FBgeHjXfkmeq0AGvZFmOpWr6vwnuGGjw0AqDy8q1XTzBYt9GZ6uuIuXLj6e7yddwU0NTVVQ4YMUd++feXl5aWYmBi99dZbanijWbZwCgJoBVW9enWFh4crKSlJAwYM0BNPPKFOnTpp+/btho5z9qzjZ/36f34t+mi01sSv0by+8+RZzdPQcQEAlc+TjRvLv0YNTUxJuepa1/Xr/3beMcqFCxcUHh6ugIAAxcbG6sMPP9SOHTvUuXNnYwdCsRBAK7jGjRtr5cqV2rNnjzw8PNSnTx8NHTpUR4q488SNXPmS+t8bPhQUFih0c6iCmgTp4fYPGzIWAKByc3Nx0WI/P33988/65CqXOmvVki5eNGaswsJCvfPOO2rdurUiIiIUHh6ugwcPavjw4TznWQ4QQCuJoKAg7dy5U++9956+/fZb+fv764UXXtDFUv6ffOVwz/+6wLni+xWK+784RfaPlIuFPyMAQNGE1Kun++rX15RDh5T9X4+OeXoaE0B37dqlbt26afTo0QoODtbBgwc1Y8YM1ahRo/TFYQiSQyXi4uKihx9+WAcPHtTUqVP18ssvq02bNnrvvfdUeJ21167nygfB76+A/nz5Zz3/5fMa1X6Uuvl0M6BzAEBVstDXVydzc7UwLe0Pv69V67c7byVx/PhxPfLII+rRo4fy8/MVHR2t1atXq1mzZqXsGEYjgFZCnp6eevHFF/Xjjz+qR48eGjVqlG6//XbFxMQUu9aVAPr7L40vRr+orLwszb1rrkEdAwCqktY1aijUx0dzjx3TiZycX39f0iug2dnZmj17ttq0aaOtW7dq+fLlio2NVc+ePQ3sGkYigFZiLVu21EcffaTt27crOztbXbt21aOPPqqTJ08WucaFC47waf1lc6OkM0mK3BOp8DvC1cSriZM6BwBUdi80b66aVqv+53f7xBc3gNrtdn300UcKCAjQrFmzNH78eCUlJWns2LGyWtmVrzwjgFYBwcHB2rt3r5YtW6ZNmzapdevWmjt3ri5fvnzDYy9e/OPzn5OjJsvHy0eTu092YscAgMqutqurXmrZUu9nZGjXzz9L+i2AFuWpsbi4OPXu3VvDhg1T+/btFR8frwULFqh27dpO7hxGIIBWEVarVY8//riSk5P1+OOPa/r06Wrbtq3Wrl171aUwrsjJkapXd/z3v5P/rY3JG/Vyv5fl4eZhUucAgMpqTKNG6uDpqdCUFBXa7b+eb/Lzr31MRkaGxo0bp44dOyozM1ObN2/W+vXrZbPZzGkahiCAVjF16tTRokWLtH//fgUEBPy6KO/+/fuv+v78fMnVVcoryNOkqEnq3aK3hgQMMblrAEBlZLVYFOnnp9gLF7Tq1Cm5ujp+f7UAmpubq0WLFslms2nNmjWKiIjQvn37FBISYm7TMAQBtIry9/fXxo0btXHjRp04cUK33Xabxo8fr9O/7IGWmZmpMWPG6M032yktrY2a2prq4FsHNb3TdNZPAwAYpmedOhpkteqJsWM1JaytpDbq1KmdxowZo8xfdOIszwAAA2tJREFU1grdtGmTAgMDNXXqVD3yyCNKTk7WhAkT5ObmVrbNo8Qs9uvdf0WVkJubq9dee00zZ86UxWLRlClTtGLFCqWmpv7pvb6+vtq1a5caNGhQBp0CACqbjIwMBXXvrqNXOec0bdpUNptNX375pfr06aPIyEgFBgaWQZcwGgEUv8rMzNS0adO0bNmy675v9OjRevvtt03qCgBQmY0ZM0YrV6685uuenp569913NXjwYO7AVSIE0CLKypISE8u6C3MMHOirEyf+/E30irZt2yo+Pt7EjgAAlVW7du2UkJBwzddbtPDXJ5/8aGJHZcff/4/rbldmrmXdQEWRmCh16lTWXZjl+n8W+debnggAQDHc6Jxy5EhhlTn/7t0rdexY1l2YgwBaRP7+jj+MquDBB111+PC1X3d15c8GAGCMG51TWrZ01ccfm9RMGfP3L+sOzEOSKKIaNarOt5Lg4CAdPnzt2yFBQUEmdgMAqMyCgoKuews+ODioypx/qxKeAcWfZGZmqnv37jr0u+3RrmAWPADASJxzqiYCKK4qMzNTYWFhiomJUX5+vlxdXRUUFKT58+fzQQAAMBTnnKqHAAoAAABTsRMSAAAATEUABQAAgKkIoAAAADAVARQAAACmIoACAADAVARQAAAAmIoACgAAAFMRQAEAAGAqAigAAABMRQAFAACAqQigAAAAMBUBFAAAAKYigAIAAMBUBFAAAACYigAKAAAAUxFAAQAAYCoCKAAAAExFAAUAAICpCKAAAAAwFQEUAAAApiKAAgAAwFQEUAAAAJiKAAoAAABTEUABAABgKgIoAAAATEUABQAAgKkIoAAAADAVARQAAACmIoACAADAVARQAAAAmIoACgAAAFMRQAEAAGAqAigAAABMRQAFAACAqQigAAAAMBUBFAAAAKYigAIAAMBUBFAAAACYigAKAAAAUxFAAQAAYCoCKAAAAExFAAUAAICpCKAAAAAwFQEUAAAApiKAAgAAwFQEUAAAAJiKAAoAAABTEUABAABgKgIoAAAATEUABQAAgKkIoAAAADAVARQAAACmIoACAADAVARQAAAAmIoACgAAAFMRQAEAAGAqAigAAABMRQAFAACAqQigAAAAMBUBFAAAAKYigAIAAMBUBFAAAACYigAKAAAAUxFAAQAAYKr/Bzqm/9HPJ0u0AAAAAElFTkSuQmCC" - ], - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-15.0,15.0,-2.0,14.0)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot_stuff(elements)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A little better, now the interpolant of normal field is continuous." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Strategy 2\n", - "\n", - "Fit field. Here we define normal function and fit field for that. This of course require us to know what is the normal field, in this case it's easily defined $f(x) = X_1^2 + X_2^2 - 10^2$." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "fit_field! (generic function with 2 methods)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - "Fit field s.t. || ∫ (Nᵢ(ξ)αᵢ - f(el, ξ)) dS || -> min!\n", - "\"\"\"\n", - "function fit_field!(el::Element, field, f, fixed_coeffs=Int[])\n", - " w = [\n", - " 128/225,\n", - " (332+13*sqrt(70))/900,\n", - " (332+13*sqrt(70))/900,\n", - " (332-13*sqrt(70))/900,\n", - " (332-13*sqrt(70))/900]\n", - " xi = Vector[\n", - " [0.0],\n", - " [ 1/3*sqrt(5 - 2*sqrt(10/7))],\n", - " [-1/3*sqrt(5 - 2*sqrt(10/7))], \n", - " [ 1/3*sqrt(5 + 2*sqrt(10/7))],\n", - " [-1/3*sqrt(5 + 2*sqrt(10/7))]]\n", - " n = get_number_of_basis_functions(el)\n", - " fld = get_field(el, field)\n", - " nfld = length(fld[1])\n", - " #Logging.debug(\"dim of field $field: $nfld\")\n", - "\n", - " M = zeros(n, n)\n", - " b = zeros(n, nfld)\n", - " for i=1:length(w)\n", - " detJ = get_detJ(el, xi[i])\n", - " N = get_basis(el, xi[i])\n", - " M += w[i]*N*N'*detJ\n", - " fi = f(el, xi[i])\n", - " for j=1:nfld\n", - " b[:, j] += w[i]*N*fi[j]*detJ\n", - " end\n", - " end\n", - "\n", - " coeffs = zeros(n)\n", - " for j=1:nfld\n", - " for k=1:n\n", - " coeffs[k] = fld[k][j]\n", - " end\n", - " if length(fixed_coeffs) != 0\n", - " # constrained problem, some coefficients are fixed\n", - " N = Int[] # rest of coeffs\n", - " S = Int[] # fixed coeffs\n", - " for i = 1:n\n", - " if i in fixed_coeffs\n", - " push!(S, i)\n", - " else\n", - " push!(N, i)\n", - " end\n", - " end\n", - " lhs = M[N,N]\n", - " rhs = b[N,j] - M[N,S]*coeffs[S]\n", - " coeffs[N] = lhs \\ rhs\n", - " else\n", - " coeffs[:] = M \\ b[:,j]\n", - " end\n", - " for k=1:n\n", - " fld[k][j] = coeffs[k]\n", - " end\n", - " end\n", - " set_field(el, field, fld)\n", - " return\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "f (generic function with 1 method)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - "Return accurate normal for element based on a known geometry.\n", - "\"\"\"\n", - "function f(el, xi)\n", - " geom_info(X) = X[1]^2 + X[2]^2 - 10^2\n", - " X = interpolate(el, :Geometry, xi)\n", - " n = ForwardDiff.gradient(geom_info, X)\n", - " n / norm(n)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "for el in elements\n", - " fit_field!(el, :Normals, f)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAqAAAAFrCAYAAAAO+zsvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3Xd4VNXWx/HvJKGFjoReQy8BpEpAQECKqIB0IqDYXlEQQVS8ggooCIJyFQt2EESagIB0UCkSQCAJARQIJfQeSkLaef/Y5sZCz8w5k+T3eZ55IpmZs1diMlmz915ruyzLshARERERsYmP0wGIiIiISOaiBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURERERGylBFREREREbKUEVERERERspQRURLzWG29A585OR5G5bNgA1arBoUNORyIiGZkSUBHxWi4XrFkDluV0JJnHtm3w++9QuLDTkYhIRqYEVES8Vo0acPo0HDvmdCSZR3g4VKoEWbM6HYmIZGRKQEXEawUFmY/h4c7GkZmEh5vEX0TEk5SAiojXKlsWcuaEsDCnI8kcLMskoCmJv4iIpygBFRGv5eNjCmI0A2qPQ4fg/HkloCLieUpARcSrBQUpAbVLyvdZCaiIeJoSUBHxakFBEBkJiYlOR5LxhYdDnjxQqpTTkYhIRqcEVES8WlAQXLkCe/Y4HUnGFx4O1aub9lciIp6kBFREvJoq4e2jAiQRsYsSUBHxagEBUKSIElBPi4+HXbuUgIqIPZSAiojXCwpSKyZP270bEhLUA1RE7KEEVES8nirhPS/l+1u9urNxiEjmoARURLxeUBDs2wcXLzodScYVHg4lSkD+/E5HIiKZgRJQEfF6KfsSd+xwNo6MTAVIImInJaAi4vWqVjWnImkZ3nOUgIqInZSAiojXy5EDKlRQAuop58/DwYNKQEXEPkpARSRdUCGS50REmI9KQEXELkpARSRdSGnFZFlOR5LxhIWBry9Urux0JCKSWSgBFZF0ISgITp+GY8ecjiTjCQ83yWe2bE5HIiKZhRJQEUkXdCSn56gASUTspgRURNKFwEDw91cC6m6WpQRUROynBFRE0gUfH6hWTQmou0VHmyp4JaAiYicloCKSbqgS3v1Svp9KQEXETkpARcSrxcbGsmjRIo4fP06NGhAZCYmJTkeVcYSHQ+7cULp06ucstRoQEQ9TAioiXu3y5cvcf//9rF69mqAgiIuDPXucjirjCAuD6tXB5Ur9XPv27enfv79zQYlIhqcEVES82h133EHRokUJDw9XJbwH/LMAybIs1q9fT8GCBZ0LSkQyPCWgIuL1goKCiIiIICAAChdWAuouCQmwaxfUqJH6uaioKE6fPk29evWcC0xEMjwloCLi9YKCggj/M+tUIZL77N5tktC/zoCGhoYCKAEVEY9SAioiXq969epERUVx4cIFJaBudLUK+E2bNlG2bFkCAgKcCUpEMgUloCLi9YL+zJB27NhBUBDs2weXLjkcVAYQHg7Fi0P+/KmfCw0NpX79+s4FJSKZghJQkTT66aeNdOjQwekwMrSqVavi4+NDeHg4NWqY03t27HA6qvTvnwVIiYmJbNmyRcvvHhQXB8nJTkch4jwloCJpsGIFtGkzg/nz5zN+/Hinw8mwcuTIQfny5YmIiKBqVXMqUliY01Glf2Fhf09Ad+zYQWxsrGZAPeiVV6BChdF88cWXToci4igloCJpUL8+5M49Hj+/nAwbNoxEdUj3mJRCpBw5oHx57QNNq/Pn4eDBf+//9PHxoXbt2s4FloHt2gUTJx4hKupVhg8f5nQ4Io5SAiqSBnnywJgxPiQmjiM2NpZnn33W6ZAyrJQE1LIsFSK5QUSE+fjPCvhq1aqRM2dOZ4LK4AYNAj+/9lhWMrNmzXI6HBFHKQEVSaNHHoE6dZ4mS5bifPbZZ5w5c8bpkDKk6tWrc+rUKY4fP/6/BFQnRt6+8HDw9YUqVVI/pwIkz1m8GH78cQHx8Ztp1aoVDRs2dDokEUcpARVJIx8fmDgREhK+JikpiR49ejgdUoaUUgmfciLSqVNw/LjDQaVj4eFQqRJky2b+ffnyZSIiIpSAekB8PDz3XDJ+fn3IkiWLZj9FUAIq4haNGkGPHi3w86vFsmXL2KESbbcrV64cOXLk0JGcbvLPCvitW7eSlJSkBNQDJk2CPXsGkph4jjfeeIM8efI4HZKI45SAirjJ22+Dr+9MwEW3bt2cDifD8fX1pWrVqkRERBAYCP7+SkBvl2X9OwENDQ0le/bsVKtWzbnAMqATJ+C1147gck2iePHiDB061OmQRLyCElARNylZEoYOrYDL1Y4dO3awcOFCp0PKcFIKkXx9oVo1tWK6XdHRcO7cvxPQ2rVrkyVLFucCy4CGDYPLl1V4JPJPSkBF3GjIEChWbBoulx+PP/640+FkOEFBQezYsYOkpCRVwqfBtY7g1PK7e23bBpMnLyApSYVHIv+kBFTEjfz9Yfz4PFhWP44fP86ECROcDilDCQoKIjY2ln379hEUBJGRkJTkdFTpT3g45MoFpUubf58+fZq9e/cqAXUjy4L+/ZPx8VHhkcjVKAEVcbOuXSE4+F1crpy8+uqrak7vRtWrVwdSK+Hj4mDPHoeDSodS9n/6/PkXYNOmTQA6gtON5syBtWsHkpx8jtdee02FRyL/oARUxM1cLnj/fR8sa6ya07tZkSJFuOOOO1QJn0ZXK0DKnz8/5cqVcy6oDCQ2FgYOPAKYwqP//Oc/Tock4nWUgIp4QO3a8Nhj/XC5ivHpp2pO7y4ul4ugoCAiIiIoVAgKFVICeqsSEmDnzqvv/3S5XM4FloGMHw+HD7cHVHgkci1KQEU85M03IXv2KSQnqzm9O6VUwgPUqKEE9Fb9/rtJQlMSUMuydAKSG0VHw8iRCwAVHolcjxJQEQ8pXBhGjGgBqDm9OwUFBfHHH38QGxtLUJBaMd2qlO9XSgJ68OBBTpw4of2fbvLii8kkJKjwSORGlICKeNCAAVC69EwAunXr7nA0GUNQUBDJycns3LmToCDYtw8uXXI6qvQjPByKFYMCBcy/Q0NDARUgucOGDfDttwOxLBUeidyIElARD8qaFd5/vwLQjh07Ili8eLHTIaV7KSf1pBQiWRZocvnm/bMAadOmTZQqVYoiRYo4F1QGkJwMTz9tCo+KFSumwiORG1ACKuJh998PzZp9A/jRt+9jToeT7uXOnZsyZcoQHh5O1aqm64D2gd68q1XAa/9n2k2dCtu3m8Kj2bNnOx2OiNdTAiriYS4XTJqUD3ia48eP8d577zkdUrqXUgnv7w/lyysBvVkxMXDggCneAkhKSmLz5s1afk+jCxdg4EBTeHTvvfeq8EjkJigBFbFB1arw7LPvATkZOvQVNadPo79WwutIzpsXEWE+psyA7ty5k0uXLmkGNI1GjUrm3Lk++Pll0eynyE1SAipikxEjfPD3H0tcXCz9+/d3Opx0LSgoiCNHjnDmzBlq1DCV3ZbldFTeLzwcfH2hShXz702bNuFyuahTp46zgaVj+/bBuHEDgXO8/roKj0RulhJQEZvkzw/vvNMPKMbkyZ+qOX0aBP05hZdSiHTqFBw/7nBQ6UBYGFSsCNmymX+HhoZStWpVcufO7Wxg6dgzzxzBsiZRtKgKj0RuhRJQERs98QSULv0VyclJ9OzZ0+lw0q2KFSuSJUsWHcl5i65WgKT9n7dv5UpYssQUHs2Zo6V3kVuhBFTERn5+8Pnn9wI1Wbp0KTt37nQ6pHQpS5YsVK5cmYiICAIDIUcOJaA3Yll/T0Dj4uIICwvT/s/blJgIffuawqOWLVV4JHKrlICK2KxFC2jZ8jsAOnfu6nA06VdKIZKvL1SrpgT0Rg4fhnPnUhPQbdu2kZiYqAT0Nn3ySTIHD5rCI81+itw6JaAiDvjkk0q4XO2IjFRz+tuV0orJsixVwt+ElO9PSgIaGhpK1qxZ/7efVm7emTMweLAKj0TSws/pAEQyo8BAGDjwG959N4A+fR7j5MmjToeU7gQFBRETE8PBgwcJCirNt99CUpKp8r5dSUlw8iQcPQonTsDZs2bW8Ny5v//3pUsQFwexseZjyu3KlWtf29cXsmf/9y1HDsibF/LlS73lz28+3nEHFCkCRYtCrly3/3WBSUBz5YIyZcy/Q0NDufPOO8maNWvaLpwJDRlyhCtXJlG4sAqPRG6XElARh7zxRj4+/vhpTp16n/fee4+BAwc6HVK68tdK+Bo1ShMXB3v3mirvq7EsOHYMoqJg/37zMSoKjhwxCeexYybpTE7++/N8fP6eGObNC7lzQ8GC/04ms2UzBw9cTWLi35PVlNvlyybuvya6ly//+/k5c5pEtEgRcytdGsqWNbcyZczN3//a36/wcKhe3Xw9YBLQNm3aXO9bLFcRGQlffGEKj77/XkvvIrfLZVnqnifilC+/TKZv3zxky2Zx8eJ5/Pz0nvBmWZZFvnz5ePnll3nssaEULgyzZkHr1rBzJ+zaZT7u3Am7d5ukMy4u9fkFCpjkrUSJ1MTurwle4cLmMblyXTup9JT4eDh/3szGHj+emiCnfDxyxJxodPAgJCSkPq9wYShXDipXNr0+U25lysCdd0KDBjB5Mpw9e5YCBQowdepUHn74YXu/uHTMsqB27QVs29aeFi3uZcWKZU6HJJJuKQEVcVByMpQt+wEHD/bn//7vaT766EOnQ0o3kpOhXr1G5MhRhrvvnsaECWYG8sKF1MeUKmWSscqVzbaHMmVSZwwzwra9pCSTjKbM5u7fD3/8YZLvXbvMVgEw35f4eKhbF0JCIDFxOS+80Ipdu3ZRqVIlR7+G9GTBgmTat78DX99LnDlzSns/RdJACaiIwzZsgODgYvj4nODkyRMUKFDA6ZC8jmXBoUOwfj38+iv89hts2wYXLvwfsJ4SJcLw9zezfZ07m4+VKqV932R6lpwM0dFmBvi332DKFLP8vncvXLnyJjCOcuXOULu2D3XrQnAw1Klj9qTKv8XHQ6FCAzh//n1GjRqlvZ8iaaQEVMQLtGixlFWr2tCiRWtWrFjidDiOi4+HrVtNwrl+vUnSDx8295UrZxKlO++E6OhJTJ78PJcuXSJLlizOBp1OJCRAq1btOXnyMi1bLmfrVtiyxcyWZskCtWtDw4YmIQ0OhuLFnY7YOwwbdoRRo0oSEFCEEycOOx2OSLqnBFTECxw+DCVL1sKythMZGUmVlMO6M4mkJDOjuWqVOV3ml19MIU727FCvXmoydNddUKhQ6vN+/vlnmjZtSnh4ONWrV3fuC0hHLMuiWLFi9O3blzfffBMwBVLh4SbRT0n6o6LM4ytUML1rmzeHZs0gIMC52J1y/DgUK1aP5OTNrF+/Xk3nRdxACaiIl3juud3897+VqVgxiN27w5wOx+OiouDHH2HFClizxlR/+/tDkyYm2WnaFGrVgut1CUopppk+fTo9evSwLfb0LDo6mpIlS/L999/ToUOHaz7u2DFYuxZWrzZvDHbtMp+vWdP8/2nd2vw/yp7dpsAddO+9C1ixoj3Nmt3L6tUqPBJxByWgIl4iNhYKFGhHXNxiFi9eTNu2bZ0Oya0SEmDdOli0yNx27jRLvg0bmoSmRQuoX//6CefVlChRgt69e/PWW295JvAMZu7cuXTq1InDhw9TrFixm37e4cMmGV250twOHTJvGFq2hHbt4L77TEeBjGbz5mTq1VPhkYi7qeeLiJfIkQM++mgajz5akJCQvpw5k/6b01+4YJLN77+HpUtNa6HChU3CMmoU3Huv6amZFiknIsnN2bRpE8WLF7+l5BPMXtCHHzY3yzL9MBcuNP9/+/Uz2yhq1oQHHjCFYDVq2N++yt0sCx588HngHMOHj1TyKeJGmgEV8SKWBSVK9OfIkQ8YP/49Bg16zumQbtn58yYxmTULliwxpwPVrg0PPmgSz9q1U5uhu8OQIUOYPXs2USmbFuW6WrRoQd68eZk7d67brnnmjHmDkTK7fe4clC9vEtEuXUzBWHpMRj/66Aj9+pWkQIHCnD59xOlwRDIUJaAiXmbz5kTq1ctHliwWly+nj+b0ly7BvHkwYwYsW2aq2O+6yyQgnTqlHv/oCVOmTKFPnz7ExMSQO63TqRlccnIy+fLlY+jQoQwdOtQjY8THmz2js2ebme8zZ0zv1S5dTA/SGjU8MqzbXb4M+fLVIyFhM2vXrqVRo0ZOhySSobhxHkJE3KFuXT+Cg8eQkHCZJ58c4HQ415SUZAqI+vQxy+oPP2ySjbFjzQk9GzbA4MGeTT4h9UhOLcPf2O7du7lw4QL169f32BhZs0KbNvDZZ6aQaflyaNUKvvjCLNHXrAnvvGMa6Huzxx5bQELCZoKDWyr5FPEAzYCKeKGTJ6Fw4WLACU6d8q7m9JGR8PXXMG2aKUypUAF69TIJaNmy9scTFxdHrly5+PDDD3nyySftDyAdSZktPnfuHHnz5rV17IQEsyVj6lRYsMD8u2VL87PTqZN3NcA/cCCZMmXuwMfnEmfPqvBIxBM0AyrihQIC4IknvsSyknjwwRCnwyE21iQOd98N1arB559Dhw7mVKLdu2HYMGeST4Ds2bNToUIFwsPDnQkgHQkNDaVy5cq2J59gOh488ADMnGlmRj/+2Pxc9eoFxYrBc8/Bjh22h3VVrVqZwqNXXhmu5FPEQzQDKuKl4uMhd+6axMeHsWNHJFWr2t+cPjISJk82xziePWtaJT35pEk+b7Vdkid17dqVkydPsnr1aqdD8Wr169encuXKTJkyxelQ/mfvXrNc/8UXcOIENGpkfsa6dHFmVnTevCN07FiSvHkLc+6cl+8TEEnHNAMq4qWyZoX3358JwH33dbNt3KQkUzzStKmZ7Zw+HZ54An7/3ez57NrVu5JPgOrVqxMeHo7eT1/blStX2LZtm0f3f96OcuVg9GjTV3TWLJN09uljZkWHDIEDB+yLJTkZQkLaA8ksXDjLvoFFMiEloCJe7MknK1GwYFsOHAhnwYIfPTrW+fPw7rumfc5DD5k/xjNmmMTg7bfNXk9vFRQUxOnTpzl27JjToXitsLAwEhISvC4BTZE1q+masHw57Nlj3vR89hkEBprZ0HXrTJsyTxo4cAGXL2+mbt2WNG6swiMRT1ICKuLlFi2aDvgSEtLXI9ffu9fsvytRAl58ERo3hk2bzHns3bpBtmweGdatUirhtQ/02kJDQ8mSJQs1a9Z0OpQbKlfOdFOIjoYPPoCwMPNzWb++KX5LSHD/mOfOJfPBB31wubKwcuUc9w8gIn+jBFTEy9Wvn4+aNZ/m4sVjjBgx0W3XDQuDHj2gYkWzzD5woFnunDoV6tZ12zC2CAwMxN/fXwnodYSGhlKzZk2ypYd3FH/KmROeftoc27p4MRQoYLotlC8PkyaZIiZ3adHieSzrHIMHq/BIxA4qQhJJB06dSiQgIB++vhZxcWlrTr9hA7z1ljmtqHRpM+v56KPe1QbndtSvX59q1arx5ZdfOh2KV6pSpQrNmzdn0qRJToeSJuHhMGaM2R5SsCA8/7xJUtNS2L927RHuvrskuXMXJiZGhUcidtAMqEg6ULCgH926jSYp6TLdu9/68ZyWBStXwj33QHCw2WP39dfwxx/mHO/0nnyCWYbXDOjVnT9/nt27d3vt/s9bERRkluF//910Y3jtNfNG6tVXzUEIt+OBBzoAyXz/vQqPROyiBFQknZg2rT9+fkWZM+cTzpw5d9PPW7vWJJ4tW8KFCzB3rum32Lu36c2YUVSvXp0dO3aQlJTkdCheZ8uWLViWlSES0BTlysEnn0BUFDz+uCmgK1sW3ngDYmJu/jojRizg3LlNBAW1pEULFR6J2EUJqEg64esLb775JZDEPff0vOHjN2+Gtm1N8/hz58zpM5s2QceO4JMBf/ODgoKIi4tj7969TofidUJDQ8mdOzeVKlVyOhS3K1bMHO2ZkoiOHm0S0bffhkuXrv/c+Phk3njDFB798osKj0TslAH/DIlkXC++2JpcuaoQFvYjgYHlqVSpEtWqVePRRx/l5MmTgJnd7NAB6tWD/fvNyTO//WZOoXG5nI3fk1QJf22hoaHUrVsXn4z4zuNPhQrB+PGmq0P37uZ0rsBAmDgRrlwxjzl58iSPPvoo1apVo1KlSuTPH0By8jn69BlM3rwqPBKxk4qQRNKREydOUKtWPY4ePfiv+8qUKUfjxhuYPj2AMmXg9dehZ08zc5pZFCpUiH79+vH66687HYpXKVmyJCEhIYwZM8bpUGyzfz+MHAlffQVlysArr5xg9Ojgq86QlytXjg0bNhAQEGB3mCKZVsZ9OyySAb300ktXTT4B9u/fy8yZLzJ+vGlb06tX5ko+wcyCRkREOB2GVzly5AjR0dHUq1fP6VBsVaYMfP65qZqvXBkef/yla27P2Lt3Ly+++KK9AYpkcrffy0VEbBcaGnrd+wOL/sTAJr9BJs3BggoX5sf1682eAwFg05o1ANTPkSNTfl+qAotGQuBvPxF1nYOybvS7JSLupQRUJB1JTEy87v3JB6KgTh2bovE+QcD7QGydOmSAzlJuEQoUAUq0a+d0KI66UcOHG/1uiYh7KQEVSUdcruv/yvqVLQuzZ9sUjffpeP48zWJiyFa8eMYs9b8Nr8TG0vPIEVzlyjkdiqP8Onc2pfLXuj8NhzuIyK3Tb5xIOpCcbPazRUXVByKv+bj6TZtC7dr2BeZlCvx5k1Q5gWpOB+EF6jdtSuR1EtDz5+uzd6/pLyoinqcqeBEvFxYGTzwBoaHQrdtJ1m6oy+GD/y5EUiWvyLWdPHmShg0bXrUQqUiRcvj6buDUqQBeeQVefhmyZnUgSJFMRGtUIl4qLs4cL1injmmovXYtzJgRQOWhFchVPxeVq1SmYsWKVK1alUceeUTJp8h1BAQEsGHDBh555BGqVq1KxYoVKVahArRpw6drl/L77wE8/zyMGGEWEX791emIRTI2zYDKDV28aM4Kz2wtfZz0yy9m1nPfPpOEpszILP5jMe2mt2NO1zk8VOUhp8MUSdeSLYv6W7YAEFqnDj4uF9u3w2OPmYYBAwbAqFGQK5fDgWYiMTGQR2cCZAqaAZXrsizo1AkeesgkouJZMTHw9NPQpAkUKADbtsHw4Sb5jE+KZ9DSQdxT5h46Vu7odKgi6Z6Py8V75cuz5eJFvj5mejTVrGlmP995ByZPhurVYelShwPNJJYsMf1bV692OhKxgxJQuS6Xy8wCrFoFjRvDVbYeipusWQM1asA338D775sl96pVU++fFDqJP878wXtt3sOVkc/UFLFR43z56F6oEEP37SPmz1ZMfn4waBBERMCfq/Q89ZTehHuKZZnXvHbtIDgY6tZ1OiKxgxJQuaF27WD9ejh3DurXh40bnY4oY4mLM3/s7rkHSpc2RUfPPvv3LkInL53kjZ/e4MnaT1KjcA3nghXJgMYGBhKTlMRbBw787fOBgbBsGXz0kXljWLMmrFvnUJAZVEICPPOMmegYOBDmz4fcuZ2OSuygBFRuSlCQqcIODISmTWHGDKcjyhi2bDFFRpMmmSW/1auhbNl/P27Y6mG4XC5GNh9pf5AiGVzJ7Nl5qVQp3o2OZm9s7N/uc7ng//4Ptm+HwoXN9pihQ+HKFYeCzUDOnoX77oNPPzW38eNVa5CZKAGVm1aokFmK79wZevSA114zSydy65KSTHHDXXdBtmwmER08+Oq907cd28bkLZN5o9kbFPQvaH+wIpnAkJIlKZw1Ky9c47z48uVNceCbb5pEqX59s0Qvt+ePP6BhQ/Pat2wZPP640xGJ3ZSAyi3Jnh2mTjUvwiNGQPfu8I8JA7mBI0fg3ntNcdFLL5mCh+rVr/5Yy7IYuGQglQtW5um6T9sbqEgm4u/ry7hy5Zh36hQrzpy56mN8fU1Hik2bzJvIevXMzJ3eiN+aNWugQQPzfdu40Ww/ksxHCajcMpcLXnnFnPj4ww9mSf7oUaejSh9+/NHsI9u928wmjxp1/YbXc3bO4acDP/Fu63fJ4nuj06xFJC26BgTQOG9eBu7ZQ2Jy8jUfV7Om2ZLUuzc8+aRZETp/3sZA07HPPjNvwOvUMW++K1RwOiJxihJQuW2dOpklqcOHzXLU1q1OR+S94uNhyBCz36l+fdNeqVmz6z8nNiGWF5a9wP0V76d1+da2xCmSmbn+bMsUefkyn9zgXbW/P3zyCXz3nXljeeedJimVq0tKMtuMnnjC3BYvhvz5nY5KnKQEVNKkTh3zolu4sGnTNG+e0xF5n4MH4e67YeJEs3fshx/gZg4smrBhAkcuHGF8q/GeD1JEAKiTOzd9ixRhWFQUZxISbvj4rl3Nm++CBaFRI3jvPS3J/1NMDLRvb743//2vKbrMogWdTE8JqKRZ8eLw889mdq9jRxgzRi/AKVasMMf6HT9u+noOGnT1QqN/OhxzmLfWvsWABgOoeEdFzwcqIv/zZmAgiZbF6/v339TjAwPN7/eAAfD882ZJXj1Djf37TWL+yy+waBH072+2cYkoARW38Pc3S1GvvmpalDzySOZuU2JZ8Pbb0Lq1mSXessUsvd+sl1e+TM4sORnWZJjnghSRqyqcNSvDS5fmw8OH2XHp0k09J2tWs8IxcyYsXGg6XPzxh4cD9XLr15vXvcuXYcMG09BfJIUSUHEbHx8YOdI0bP7uO2jRAk6evPbjL1y4YF9wNoqJMa2qXn7Z3BYvhjvuuPnn/xr9K9+EfcNbLd4ib/a8ngtURK5pQIkSlM2Rg+f37MG6hSWdLl3MtqSEBHOizw8/eDBIL/bNN6a6vXJlU+n+11PdREAJqHhASIhpqP7HH+bd744d/35MbGwsDRo0YPDgwSRfp9o0vfn9d9NeZPlysx/2zTdvrbFyspXMc0ueo1aRWjxa61G6JIfEAAAgAElEQVTPBSoi15XVx4cJ5cqx/OxZFpw+fUvPrVrVJKHNm8ODD5qeyRnoZe5/Ev88uvSvkpPhP/+BXr2gZ0/zWlhQ7YvlKpSAikc0bGhegHPnNv/9449/vz9Hjhz069ePd999l4cffpj4+HhnAnWjVavMshuYPoHt29/6Nb4J+4bQw6FMbDMRXx8dCSLipPvvuINW+fMzeM8ertxiBpk3L8yZY96EjhwJ3bqZpeiMYv/+/dSpU4eFCxf+73OXLpmirNGjYexY+OILc9CGyNUoARWPKV3anJvctCncf7+pAv/rStazzz7LzJkzmTNnDvfddx8xMTHOBZtGkyeb/Z716pm9TpUq3fo1LsZf5OUVL9O1WlealG7i/iBF5Ja4XC7eLV+e/XFxTIyOvuXn+/iYnslz55qtOE2bmoMo0ruNGzfSoEEDLly4QLly5QDTjq9JE1iyBL7/3rSdU7GRXI8SUPGo3LnNUvTzz8PAgfD002ZvVIrOnTuzbNkyNm/eTNOmTTmazjraJyaar+upp8xt0SLIl+/2rjX6l9GcjTvL2JZj3RukiNy2qjlz8kzx4ow6cIBjt1lZ2aGDqZI/dsy8Sf3tNzcHaaPZs2fTrFkzypUrx8aNG6lSpcr/iixPnjRf5+2s/kjmowRUPM7XF955x5yA8fnn0LYtnD2ben/Tpk355ZdfOHHiBMHBwfz+++/OBXsLYmLM/q4PPki9+fnd3rX2nd3H+A3jeaHhC5TOV9q9gYpImrxepgxZXC5eiYq67WukNKovXtz0TJ47140B2sCyLMaMGUOXLl3o0KEDq1atIiAggNmzTZ/jEiXM11erltORSnqhBFRs89hjZkP61q3/blESFBTEhg0byJEjB8HBwWzcuNG5QG/CsWNmOW3dOrO09swzabvekOVDKOhfkJcbv+yeAEXEbfJnycLIsmX56tgxNqdhq1DRouYc9PvvN50yPvjAfTF6Unx8PI8//jhDhw5l2LBhTJs2jWzZsvPmm6bqv31783UVKeJ0pJKeKAEVWzVrZlpy+PiYavFVq1LvK1WqFGvXrqVy5crcc889f9vc7k1+/90UVp04YZort2qVtuutilrF3J1zGXvvWHJmzemeIEXErZ4sWpRqOXPy3C22Zfonf3+YMcNsS+rf3/RN9uaDO86ePUubNm2YOnUqX3/9NSNGjCA+3odevUzf5zfegOnTIUcOpyOV9EYJqNiufHlTqFO3rincmTw59b4CBQqwfPlyWrduTYcOHfjiiy+cC/QqNm6E4GDzYrthA9SokbbrJSYnMnDJQIJLBtOjeg/3BCkibufn48N75cuzPiaGb0+cSNO1fHxM0/p33jEnxz3yyN/3xnuLvXv30rBhQ7Zv386KFSvo3bs3x4+b9lJz5ph+z8OHq9hIbo8SUHFEvnxm6frJJ03xzsCBkJRk7suRIwezZ8/miSee4LHHHmPUqFFpmnFwl4ULTWPlSpXMRvtSpdJ+zU+3fEr4iXDea/0eLr2Ki3i1Fvnz07FgQV7at49LKS9YaTB4MEybBt9+a5blvelsjnXr1nHXXXeRnJzMr7/+SpMmTQgLM8VGUVHw00+m5ZLI7VICKo7x84NJk1ILeB54wBT2APj6+vLhhx8ycuRIhg0bRr9+/Uhywwv+7frmG1PJ2rq1Od+9QIG0X/Ns7FmGrR7Go7UepV7xemm/oIh43DvlynEiPp5xBw+65Xo9e5o+yRs2mNPjzpxxy2XTZPr06TRv3pyqVauyYcMGKlSowA8/mDPdCxQwfY5v5WhhkatRAiqOe+YZMxu6bp1Z3k4pNHW5XLz66qt89tlnfPrpp3Tu3JnY2Fjb45s8GXr3NrfZs9231+mNn97gStIV3mrxlnsuKCIeF5gjB4NKluTtQ4c4GBfnlmu2aGGKePbtM/vkjx93y2VvmWVZjBgxgpCQELp3786yZcsoUOAOxo83hUYtW5rVnxIlnIlPMhhLxEtERlpWYKBlFSxoWWvX/v2+hQsXWjly5LAaNWpknT592raYJkywLLCs/v0tKynJfdeNPBFp+b7ha435ZYz7LioitohJSLCKrFtndYuIcOt1IyIsq2hRy6pY0bIOHXLrpW8oLi7Oevjhhy3AGjVqlJWcnGxduWJZjz1mXgNfftm9r4EiLsvygs11In86dQo6dYJffzV9Q3v1Sr1v48aNtGvXjkKFCrFkyRJKuWMT5jVYFowaZTbYDx1qjtNz1xZNy7JoM60Ne87sIbJfJNn8dFadSHrz9bFjPLJrFz/XqsXdt3v6xFXs2WNmRH18YOVKCAx026Wv6dSpU3Ts2JFNmzbx1Vdf0b17d06fNq/F69fDp59Cnz6ej0MyFy3Bi1cpWND0Cg0JMUver7wCKUcwN2jQgPXr1xMbG0twcDDh4eEeicGyTNI5fLhJPN96y71Vnov+WMSyvcuY0GqCkk+RdKpX4cLUy52b5/bsIcmN8zjly5v2blmymAbvu3a57dJXtXv3bu666y527drFqlWr6N69O7t2mTZ5O3aYVnlKPsUTlICK18ma1ZyYNG6caVHSuTNcumTuq1ixIuvXrycgIIC7776bn376ya1jpySfb78N775rEmB3ik+KZ9DSQbQMbMmDlR5078VFxDY+LhcTy5dn68WLfOnmI4RLlYKff4b8+U3LI08dDrdmzRoaNmxIlixZ2LhxI8HBwSxfbg4KyZ7dnGzUuLFnxhZRAipeyeWCF14w58gvW2ZmAqKjzX1Fixblp59+om7durRq1YpZs2a5ZUzLgmHDUpPPgQPdctm/+e/G/7Lv7D7ebf2u2i6JpHMN8+YlpFAh/hMVxfnERLdeu0gRswSfL59p/7Znj1svz1dffUWrVq2oXbs2GzZsIDAwkA8/NEclBwebpfeyZd07pshfKQEVr/bgg6Y6/tQp0/Zj0ybz+Tx58rB48WI6d+5Mt27deP/999M81htvmCX3ceM8k3wev3icET+N4Om6T1O9UHX3DyAithsTGMjFpCRGHTjg9msXLmyWwHPnNknovn1pv2ZycjL/+c9/ePTRR+nduzc//vgjuXLlo39/05Gkf39YsADy5En7WCLX5XARlMhNOXrUsu66y7KyZ7esmTNTP5+UlGQNHjzYAqyXX37ZSk5Ovq3rjxhhKj1Hj3ZTwFfx+PzHrfxj8lunLp3y3CAiYrsRUVFWljVrrN8vXfLI9Q8ftqwKFSyrVCnLioq6/etcvnzZ6tatmwVYY8eOtZKTk61z5yyrdWvL8vOzrI8/dlvIIjekBFTSjdhYy+rRwySKI0ZY1l9zzfHjx1uA1bt3bys+Pv6Wrjt2rLnmyJFuDvgvthzZYrled1nvb3zfc4OIiCMuJyZapdavt+4PC/PYGIcOmTZ1ZctaVnT0rT//+PHj1l133WXlyJHDmjNnjmVZlrVnj2VVqWJZ+fJZ1sqVbg5Y5AbUhknSlb+2R+rRwxQrpTSG//bbb+nTpw/Nmzdn9uzZ5MqV64bX++wzeOIJU2z05pueitmiyVdNOBN7hu3/tx0/Hz/PDCQijpl14gRdIyNZUqMGrd1xVNpVHDxoioLy5DFFSjc7TGRkJO3atSMuLo4FCxZQr149fv4ZHnrIXGPhQqhY0SMhi1yT9oBKuuJymUKh776D7783+6KOHTP39ejRgx9//JH169fTrFkzjt/gOJG5c8059P/3fyap9ZSZO2ay9uBaJraZqORTJIPqHBBAk7x5eX7PHhJSese5WalSpijz2DFo1y61O8j1LF++nIYNG5IrVy42btxIvXr1+PJLc6pRzZqm57KST3GCElBJl7p2NTMABw+a4qTt283nW7Rowc8//8zhw4dp1KgRe65ROrpypZlB7dLFnEPvqYL0ywmXGbJ8CO0rtadlYEvPDCIijnP92ZZp1+XLfHTkiMfGqVwZliyBiAgzgxkff+3Hfvrpp7Rt25bg4GDWrVtH8eKlGDIE+vaFRx811/HQZK3IDSkBlXSrXj3Tp65gQWjUyFRuAtSqVYsNGzbg5+dHcHAwmzdv/tvzNm2CDh3M7OmUKeDr67kYx60bx7GLx3in1TueG0REvEKt3Ll5omhRXtu/n1PXywzTqG5dmD/fnB/fuzckJf39/uTkZIYMGcKTTz7Jk08+yQ8//ICPTx4eeggmTDBt5j7+2DS7F3GKElBJ10qUMKeGtG5tkspx48w+0TJlyrB27VoCAwNp1qwZS5cuBUwvvfvug6AgmDPHNL33lEPnD/H2urcZ1HAQ5QuU99xAIuI1RpUti2VZvLZ/v0fHad4cZsyAWbNM27iUao5Lly7RqVMnxo8fz7vvvsukSZM4csSPRo1g9Wr44QfzeLUhFqf5vv766687HYRIWmTNapbSExJMcdLBg6aZcu7c/vTo0YMtW7YwYsQIChYsQ//+NcmZ0yzB583r2bieXvQ0Ry4cYVaXWTpyUySTyOnrS1YfH0YfPMhDBQtS2IPvcqtUMQ3rhw83DetLlz5Kq1atCA0NZfbs2fTp04eNG120aGGONF61yqwWiXgDVcFLhjJ1Kjz+uDlKbs4cszyfmJjIE0/8H1999Tk5c45m+/aXKFfOs2//1x9aT6MvGvHFg1/w6J2PenQsEfEu8cnJBG3aRPFs2VhZs6bHTz176SUYOzaMggXvJ2vWJBYuXMidd97Jt9+avZ5165qizYAAj4Yhcku0BC8ZSq9e5l3+zp3QoIH56OPjR2zsp/j6DufSpaG8994Akv65acqNkq1kBvw4gDpF69CnVh+PjSMi3imrjw/vli/P6nPnmHfqlMfHu/vuxfj5NeL06YJ88kkoNWveyWuvQc+e0K2bWfFR8ineRjOgkiHt3w/332/Oj2/TBmbONHulTp36hH79+vHQQw8xdepUsmfP7vaxv9z6JX0X9GVd33UElwx2+/VFJH24LyyMXZcvE1mvHtk9VO04adIkBgwYQJs27Th9ejr79uWifn1YtAhGjzazo9rvKd5ICahkWDExcPfdEBYGgwbB+PHm8/PmzaNHjx40aNCAefPmkS9fPveNeSWGiu9XpHnZ5kzvNN1t1xWR9GfXpUsEbd7MiDJlGFq6tFuvnZSUxKBBg/jvf//L888/z7hx4zh71peyZU1/0KlTISTErUOKuJWW4CXD2rnT3Jo3N9XxKTp06MCKFSsICwvj7rvv5vDhw24b882f3yTmSgxvt3zbbdcUkfSpcs6c9C9enDcPHODIlStuu+6FCxdo3749H3zwAR9++CETJkzA19eXggXNSo+/v1n18VA/fBG3UAIqGdKRI9Cxo+kVungx+PzjJ71Ro0asW7eOmJgYGjZsSGRkZJrH3HNmD+9tfI+XGr1Eybwl03w9EUn/hpcuTQ5fX17Zt88t14uOjubuu+/m559/ZtGiRTz99NN/uz9ly9EPP4B63Ig3UwIqGU5cnDkhxMfHVMJnu0YHpCpVqrB+/Xry5ctH48aNWbduXZrGfWHZCxTOWZghjYak6ToiknHky5KFUWXL8vXx44TGxKTpWlu2bKF+/fqcPXuWdevW0aZNm6s+7r774K23YORImD07TUOKeIwSUMlQLMuc7b5tm2k7UqTI9R9fvHhxfv75Z2rUqEHLli2ZN2/ebY27fO9y5u+ez7h7x+Gfxf+2riEiGdPjRYtSI2dOBvzxB8m3WXYxf/58mjRpQokSJdi4cSNBQUHXffxLL5kK+D59zD54EW+jBFQylEmT4Ouv4dNPzfL7zciXLx9LlizhgQceoFOnTnz88ce3NGZiciLPL32exqUa07Va19uIWkQyMt8/z4nfeOEC044fv6XnWpbFhAkT6NixI23btmXNmjUUudE7a0zl+xdfQKVK0L49nD17u9GLeIYSUMkwQkNNtfuAAaYf6K3Inj07M2bM4Nlnn+Xpp59m2LBh3GyDiI83f0zkyUgmtpno8YbTIpI+Ncufn84BAby8bx8XExNv6jmJiYn069ePwYMH8+KLLzJz5kz8/W9+hcXf36wEnT8PjzySelyniDfQUZySIZw5Ay1bQoUK8O23cDst91wuF23atMHf35/hw4dz6NAh2rVrh88/K5j+4vTl0zz03UOEBIXwVN2n0vAViEhGVz93bsYdOoTlctE8f/7rPvb8+fN07NiROXPm8Mknn/Diiy/e1hvcfPmgenV47TXImVNHcYr38HM6AJG0Sk42+5wuXICffzZnw98ul8vFiy++SNGiRenbty/Hjx/nu+++I2fOnFd9/GtrXiPJSmJU81G3P6iIZAplcuRgSKlSjDt4kMeKFKFMjhxXfdz+/fu5//77iY6OZsmSJbRo0SJN47ZrBy+/DEOHmmOK7747TZcTcQstwUu6N24cLFwI33wDpUq555q9evVi0aJFrFmzhhYtWnDqKsfpRZyI4OPNHzOsyTAK5yrsnoFFJEN7uVQp7siShRev0ZZp48aNNGjQgMuXL7Nhw4Y0J58pRo40s5/du8OJE265pEiaKAGVdG3tWvjPf+CVV6BtW/deu1WrVqxZs4aoqCgaNWpEVFTU/+6zLIuBSwYSmD+QAQ0GuHdgEcmwcvr68nZgILNOnuSnc+f+dt/s2bNp1qwZ5cqV49dff6VKlSpuG9fPD2bMgMREc0KSmtSL05SASrp17px5IQ0Ohjfe8MwYdevWZf369SQlJREcHMzWrVsBWLB7ASujVjKh9QSy+qZhzV9EMp2ehQvTIHdunvvjD5IsC8uyGDNmDF26dKFDhw6sWrWKQoUKuX3cokVh2jRYsQImTHD75UVuic6Cl3TJsqBnT/jxR9Pjzl1L79dy4sQJ2rVrx+7du5kxawYDdg+gfIHy/BjyoyrfReSWbYyJ4a7ffmNSmTJsGTmSL774gmHDhvH6669ft/DRHYYMgYkTYeNGuPNOjw4lck1KQCVdmjoVevc2S0rdutkz5sWLF+nSpQvLVywnuX0yER9FUDWgqj2Di0iG0/3XX5n7zDMQHs5nn31G7969bRn3yhVo2BBiY2HLFtOuScRuWoKXdGffPnjmGZOA2pV8AuTKlYvJ0yfjquGiRnwNJZ8ikiYD8uQh8eRJOn71lW3JJ5jjiadPhwMHYPBg24YV+RvNgEq6kpgITZrAsWPmuM08eewdv+/8vszfNZ/dz+ymYK6C9g4uIhnOm/v28fqhQ0TUq0clm6ciP/nEHF08fz48+KCtQ4toBlTSl3feMfuWvvnG/uRz85HNfLntS0Y1H6XkU0TcYnDp0pTMlo3n9+yxfewnnzSJ5xNPwFU6zYl4lGZAJd2IjDQb5gcOhLfftndsy7Jo/GVjLly5wG9P/Yafj85wEBH3mHvyJJ127GBxUBBt77jD1rGPHYOqVaFNG7MsL2IXJaCSLiQmmnZLFy7A1q2QPbu9438b/i095/ZkZe+VNC/b3N7BRSRDsyyLFtu3c+TKFcLr1SOLh6vg/2naNHj4YZg7Fzp2tHVoycS0BC/pwvjxplrzyy/tTz4vxV/ixRUv8lCVh5R8iojbuVwu3itfnj9iY/ng8GHbx+/ZE9q3N/tBT5+2fXjJpJSAiteLjIThw0215l132T/+2HVjOXnpJOPuHWf/4CKSKdTIlYunihXjjf37ORkfb+vYLhd89BEkJMAAHewmNlECKl4tKQkeewzKlvXcaUfXc+DcAcauH8ughoMIzB9ofwAikmmMKFMGl8vFsL8c+2uXokXhv/81+0AXLLB9eMmElICKV5s8GX79FT77DHLksH/8l1a8RP7s+RnaeKj9g4tIplIwa1ZeL1OGyUePsu3CBdvHDwmBtm3h2Wfh4kXbh5dMRgmoeK1jx2DoUHj8cWjc2P7xfznwC9/t+I4xLceQO1tu+wMQkUynX7FiVPL3Z+CePdhdI+xywaRJcPIkvP66rUNLJqQqePFaPXrAihWwaxfY3JmEpOQk6n1aDz8fP359/Fd8XHqvJiL2WHrmDG3CwphVtSqdCxWyffzRo2HYMFP4WbOm7cNLJqG/quKVli0z57yPH29/8gnw1bav2HpsKxPbTFTyKSK2al2gAO0KFGDIvn3EJiXZPv7gwVCpEjz1FCQn2z68ZBL6yypeJzYW+vWDe+6BXr3sH/983HleWfUKD9d4mIYlG9ofgIhkehPKlyf6yhUmREfbPnbWrOaYzo0bzT58EU9QAipeZ/x4OHgQPvzQ7Emy26ifR3Ex/iJjWoyxf3AREaCivz/PFS/OWwcOcPjKFdvHb9wY+vaFV15Rb1DxDCWg4lWio83+o4EDoXJl+8f//fTvTNw4kaGNh1I8T3H7AxAR+dOwMmXI6evLy/v2OTL+6NGmFd5rrzkyvGRwSkDFq7z8MuTKBa++6sz4g5cNpljuYgxuONiZAERE/pTXz4+3ypblm+PH2XD+vO3jFypkDgH56CMID7d9eMngVAUvXmP9emjUyPT8fOwx+8dfumcpbaa1YVaXWXSu2tn+AERE/iHJsqi3ZQt+Lhe/1q6Nj837kuLjoXp1KFUKli93ZluUZExKQMUrJCdDgwbmY2go+PraO35CUgI1P65JQM4A1vRZg0uvsiLiJX45d44m27bxdeXK9C5SxPbxFy6EBx6AefPMmfEi7qAlePEKU6fC5s0wcaL9ySfAR5s/YtepXUxsM1HJp4h4lbvz5aNrQAAv79vHhcRE28dv1w5at4ZBg8CBeijJoJSAiuNiY82ez86dnTnx6NTlU7y25jWeqP0EtYrUsj8AEZEbGFuuHGcTExl98KDtY7tcMGEC7N9v2jOJuIMSUHHcpElw9Ci8+aYz4w9fPRzLshjVfJQzAYiI3EDp7Nl5sWRJxh86xL7YWNvHr1oVHnkERo0CB46plwxICag46tw5eOsteOIJqFjR/vHDjofxyZZPGN50OAE5A+wPQETkJr1YqhSFsmblhb17HRn/9dchJsb0ahZJKyWg4qixY82eouHD7R/bsiwGLhlIhQIVeLb+s/YHICJyC3L6+vJ2YCDfnzrFqrNnbR+/ZEno3x/eeQeOH7d9eMlglICKY44cgffeM03nixa1f/zvd33P6v2rebf1u2T1zWp/ACIit6hHoUIE58nDwD17SHTgoPahQ8HPzyzFi6SFElBxzKhRkCMHvPii/WPHJcbxwrIXaFu+LW0rtLU/ABGR2+ByuZhYvjzhly7x6dGjto9foIA5MOSTTyAqyvbhJQNRAiqOOHTINJwfMgTy5rV//Hc3vMuhmENMaD3B/sFFRNKgbp48PFKkCMOiojibkGD7+AMGQP785qhOkdulBNQm587BgQNOR+E9xoyB3LnhmWfsH/vIhSO8+cub9K/fn8oFHThwXkQkjd4qW5YrlsUb+/fbPra/P7zwAnz5pf6upUhMhMhIp6NIX5SA2mTqVChTBpo1gy++MJWEmVV0tJn9HDzYJKF2G7pyKDmy5GB4Uwcqn0RE3KBotmy8Wro0Hxw+TOSlS7aP368f5MuXuWdBLQu2bDF1DMWLQ5Mm5uhSuTlKQG3yyCPw9deQJQs8/jgULgzdu8OiReDACoqj3n4bcuaEZx0oPN8YvZEp26cw6p5R5Muez/4ARETcZGCJEpTJnp3n9+zB7lO1c+Y0s6BffAEO9MZ31MGDJvGuVg3q1oUZMyAkBJYvN3/j5eboLHgHREfD9OlmVjQiAgICoEcP6NUL6tQxp05kVEeOQGCgOfno1VftHTvZSib482DiEuPY8uQWfH0cOPNTRMSN5p86RYeICH6oXp37Cxa0deyLF83KXteu8OGHtg5tu5gYmDPH/N1eswayZ4cOHaB3b2jZ0nQGkFujBNRBlgXbt5sf6OnT4dgxqFLFJKIhIVCqlNMRut+gQWbf0P799hcfTd0+ld7zerOmzxqalmlq7+AiIh5gWRatwsI4EBdHRL16ZPWxd2Fz9GjToD4qCooVs3Voj0tMNLOaU6bA/PkQFwf33GP+Rj/0EOTJ43SE6ZsSUC+RmAgrVphk9PvvzQ9606bmB71z54zxg372rGlkPHCg/T3kLsZfpNIHlQguGcysLrPsHVxExIMiLl6k5ubNvB0YyAs2z1ycP29e1/v1M8Wl6Z1lwdat5m/xt9+ahvtVq5qZzp49zdcq7qE9oF7Czw/atIFp08wP/Jdfgq9v6n7RHj1g8WKTqKZXH39s4u/f3/6xx6wdw+nLpxl37zj7BxcR8aDquXLxdLFijDxwgOM2V8HkzQtPPWVe39PzGfGHDpkEunp1sxVu+nTzd3fLFrNV7qWXlHy6m2ZAvVx0tElKp06FHTugUCHzS9G7N9x5Z/rZL3rlitkr9MADMHmyvWNHnY2iyqQqDAkewsjmI+0dXETEBqcTEqiwcSOdAgL4tFIlW8eOjoayZc3Rys8/b+vQaXLhQuq+ztWrIVu21H2d996rfZ2epgQ0nbAs2LYtdb9oyrJAyn5Rb39n9vnn8MQTsHMn2PzaSOeZnfk1+ld2P7ubnFlz2ju4iIhNPoiOZsCePWyuU4faNve469PHJHF793p3JXjKvs6pU2HePLPdrVkz87e0U6eMsd0tvVACmg6l7BedMiV9/AIlJ5tljYoVTbx2WrN/Dfd8fQ9TO07l4RoP2zu4iIiNEpOTqbV5M/mzZOHnWrVw2bhEFh4ONWqYFbuePW0b9qZcbQKnShUz05keJnAyKiWg6VxMDMydm7qEkNIaolcv71lCWLwY2rWDX36Bxo3tGzcpOYnak2vjn8Wf9X3X2/piLCLihBVnznBvWBgzqlalW6FCto7dti2cOAGbN3vH9rBrbWHr1Qtq1/aOGDMzJaDp3JkzZzh+/DhVqlTh0KHUX7bIyNTipV69nN0vet995kVp0yZ7Y/hk8yf836L/Y+PjG6lfvL59A4uIOKhDeDhbL15kZ/36+Pva1+/4xx/N6/369dCwoW3D/s2FC6mTMqtWpe7rTJmU8ebtAZmNquDTuW+++YaqVatSr1495s17n8ceO0lEhKnc69HDLDfUqQNBQeYEouhoe0KVLm4AABwvSURBVOPbuxeWLDFnvtuZfJ6LO8erq1+lT80+Sj5FJFN5p1w5jsbHM+7QIVvHbd0aypWDSZNsHZbERPN3JiTETLw88ggkJZkjn48dM+2U7rsPEhIu891339G9e3euXLlib5DyL0pA07mnnnqK2bNnU7x4cQYNGkSxYsVo3/5B9u6dxejRcRw+bJbAg4JMs+BSpaBFC/jqK3taZnz0EeTPb44dtdOIn0YQmxDLWy3esndgERGHlff35/kSJXj74EEOxcXZNq6Pj+kHOmuW2WfpSSn7OgcPNns427Y1/TuHDYMDB8yWtL59IWfORJYuXUrv3r0pXLgw3bt3Z//+/Rw9etSzAcoNaQk+Azl16hTfffcdU6ZMITQ0lLx589K1a1d69+5No0aNuHDB9a+jxDp2NEsTnjhK7PJlKF7cVL+PHevea1/PrlO7CPooiBHNRjD07qH2DSwi4iViEhOpuHEjzfPnZ3rVqraNe/ased3/z3/Mzd0OH07danato6wtyyI0NJRp06bx3XffceLECSpVqkRISAg9evSgfPny7g9MbpkS0Axq9+7dTJ06lW+++YYDBw4QGBjIww8/TK9evShfvvz/9otOmWJaIxUubCoXe/WCWrXcs1ye0npp717TI84u9027j12ndhH5TCTZ/bLbN7CIiBf58uhR+u7ezS+1atE4Xz7bxn38cVi61BzP6Y6JjYsXU/d1rlxp9nW2b2/+XrVqlbqv8/fff2fatGlMnz6dPXv2ULRoUXr06EHPnj2pXbu2ClG9jBLQDC45OZlffvmFqVOnMnPmTC5cuEDDhg3p3bs3Xbt2JX/+Avz2W+qxYydOmJZJvXqZhLREidsfu25dKFIEFi5039dzI4v/WEy76e2Y23UuHat0tG9gEREvk2xZ1N+yBQvYVKcOPjYlYFu3mirz7783BUC3Iynp78dTX7789+Op8+Y1jzt69CgzZsxg2rRpbNmyhTx58tCpUydCQkJo1qwZvjYWYcmtUQKaicTGxrJgwQKmTJnC0qVL8fX15f7776dXr17cd999uFxZWbbM/MLPn29OL2re3PzCP/QQ3Epf4+3bzUzq/Pnw4IOe+5r+Kj4pnqCPgiieuzgre6/Uu10RyfTWnz9Po61b+bxSJfoWLWrbuPXqQdGisGDBrT1v+3bzN2jaNFNAVLly6oErpUubx5w/f565c+cybdo0Vq9ejZ+fH+3atSMkJIR27dqRPbtWvtIDJaCZ1PHjx/n222+ZMmUKW7dupUCBAnTv3p1evXrRoEEDYmL+vl/U3z/1iLIWLW68rDJwIMyYYc7Xtavtxbsb3uWF5S+w7altBBUOsmdQEREv1zMyklVnz/J7gwbksak59EcfQf/+pvNKkSLXf+zhw6Zjy9SppqF9wYKpR06n7Ou8cuUKixcvZvr06fzwww/Ex8fTrFkzQkJC6NSpE/ls3GIg7qEEVIiIiGDq1KlMmzaNw4cPU6FCBXr37s3DDz9MmTJlOHAgddP3rl3mxSRlv2jNmv/eL3rlitmE3revfcVHJy6doOL7FekZ1JMP231oz6AiIunAobg4KoWG0r94cd4uV86WMc+dMzOgI0bAkCH/vv/iRbO0PmWK2deZNWvqvs7Wrc3ERXJyMj/99BPTp09n9uzZnDt3jjvvvJOQkBC6detGibTsERPHKQGV/0lKSmL16tVMnTqVOXPmcOnSJZo0aUKvXr3o0qULefLkZcuW1P2iJ0+a/aK9e5uEtHhxc53Zs6FLF9MMv0oVe2J/6oenmBk5kz/6/0FB/4L2DCoikk6M2L+fUQcOsKNePSr4+9syZs+eZj9oZKSZqEhKMsnm1KmmqOjyZWjSJHVfZ758poJ9+/btTJs2jW+//ZbDhw9TtmxZevbsSUhICFXs+qMiHqcEVK7q0qVLfP/990yZMoWVK1eSNWtWHnzwQXr37k2rVq2ALP/bLzpvHsTHm6X5Xr3gm29Mj9ENG+yJdduxbdT+pDbvtXmPAQ0G2DOoiEg6cjkpiSqhodTKlYv5QfZsUVqxwpw+NGUKhIWZlbSjR6FSpdR9nWXKmMdGRUUxffp0pk2bxs6dOylYsCDdunUjJCSEu+66S3v6MyAloHJDhw8fZvr06UyZMoWIiAgCAgLo2bMnvXr1onbt2sTEuJg92ySjP/1knjNoEIwf7/nYrP9v796joq7zP46/YAYRQbwgXgGRi6artKWQWpmaRv5228xf7hoslqf2bG2/jpc2S2uz0m5aqW1tW+0xFxdTy45buYparWSpqOVqWgKiiJe4KIlXYGB+f3wXy1KYge98YZjn45w5jPOd7/v7xsOZ72u+l8/H6dTwvw9XyZkS/efe/yjAxjxrAHApK4qL9Zu9e7U+IUGjOnb0+PZqaqSQEOncOeO6zgkTjDNmgwYZR0RLSkq0YsUKLV26VJ9//rmCg4M1duxYpaamatSoUQpg3swWjQAKl9WeGqm9XrSoqEj9+vVTWlqaUlNTFRkZqccfl555xhj7s/aORU96d++7Gv/OeK1NXavkuGTPbxAAvJTT6dQNO3fqRFWVdg4aJLu/5ydDvO02af16Y2ak4GDj7NqqVau0dOlSZWZmys/PT8nJyUpJSdGtt96q4OBgj/eE5oEAigZxOBzasGGD0tPTtWrVKp0/f14jR45Ufn6a+vYdp9Wr3RizqYHOVZ1T31f7akCXAfrgjg88vj0A8HZfnjqlgTt26M/x8bq/9sJ9D9q9W0pIqNKsWeuVm5uhVatW6ezZs7r22muVkpKi8ePHKzw83ON9oPkhgKLRysvLtXLlSr3xxhJt2fKJAgPb6Pbbb1NaWppGjRrlsYGA52TN0VMbn9KeP+xRfFi8R7YBAC3N7/bt08qSEuVec43CPHSa2+l0avPmzcrIyNDrr69QdXWp+vXrd2E6zF5WTo+HZokACtM884w0e/YhPfJIhpYtS9c333yjbt26KSUlRRMnTlRCQoJp2zpcflh9XumjPwz6g+bdNM+0ugDQ0hVVVip+61bd2bWr/hxv7pf3vXv3XpgO8+DBg4qIiFB09B3avj1VpaUJCg7mZiIYCKAwzYABxmPpUuPb7/bt27VkyRK9/fbbKi0tVUJCgiZOnKiUlBR1a+SMHL9977dan79eOf+Xo3at25n0GwCAb3jh0CE9kp+v/yQm6meNvO7y8OHDF6bD3Llzp9q3b6/x48crJSVFw4YNU36+v+LjpeXLpV//2qRfAF6PAApT7NljjAl6qak3q6qqtHbtWqWnp+v999+Xw+HQ6NGjNXHiRI0dO1Zt3ByTbnPhZg1dNFRv3vKm7rn6HhN/CwDwDZU1Neq/bZuiW7dWZkKC28MclZWVaeXKlcrIyNDGjRsVGBioW265RSkpKRozZowCAwMven9iohQRYQw+D0gEUJhk9mxp3jxjcPoffe5cpKysTO+8846WLFmiTZs2KSQkRLfffrvS0tI0fPhw+ddzV2aNs0aD/zZY1c5qZd+TLZu/Z64vBYCW7sPSUt3y1Vf6Z//++lWn+ifwOH/+vD788ENlZGToX//6lxwOh0aOHKnU1FSNGzdOoaGhl1133jxp1iyptNSY2hkggMIUAwdK8fHG/O+uys/P1z/+8Q+lp6dr//79ioyMVGpqqtLS0tSvX79LrvP3nX/XXf+8S59O+lTXRV1nUvcA4HucTqfG7NqlvHPntCcpSYGXOABQO0NeRkaG3nvvPZWXl2vQoEEXpsN09XKq3Fypd2/jCOjYsWb/JvBGBFA0WmGhFBVlTM85YYL76zudTm3ZskXp6elavny5ysrKNHDgQE2cOFETJkxQ586dJUmnKk6p9yu9dUPPG7TsdjeSLgDgkr4+c0YDtm3T0zExejgqSpLxmbxjxw4tXbpUy5Yt07FjxxQXF3fhDvY+ffo0aFs/+5mUlCS99ZaZvwG8FQEUjfbKK8bMRyUlUrtG3g9UUVGh1atXa8mSJVq9erVqamo0ZswYpaWlaVvINr3y5Sva93/7FNUuypzmAcDHTc7N1aJvv9W6sDCtf/ddZWRkKCcnR507d9aECROUmpqqxMTERk+HOXOm9MYb0rffSna7Sc3DaxFA0WijR0v+/lJmprl1jx8/ruXLlys9PV1bt26VWkuT5k7SogcWmbshAPBhZVVV6nrzzar8+GOFhIRo3LhxSk1N1ciRI2U3MSlmZ0vXXGNM2TxsmGll4aUIoGiUsjKpc2fp5Zel++7z3HZGzx+trWu2KuftHHUN6+q5DQGAD7r7L3/RoqIifXrffbquq2c+Y2tqpMhI6Te/kV56ySObgBfx/ESwaNHWrZMcDumWWzy3jY/yP9KG8g16/cXXCZ8A4AGv33uv+v/yl3r46FF56riUv7+xr/jwQ4+Uh5chgKJR1q0zLiyPiPBMfUeNQ1Myp+jayGs1oX8D7nACANTL7u+vBXFx+ry8XMuKiz22neRk4474Awc8tgl4CQIoGszpNK77TE723Dbe3PGm9hTv0cKbFzb6AngAwOXd2KGDbuvUSdPz83Wmutoj2xg5UrLZjIMX8G0EUDTY3r3SkSOeC6Anzp3Qnz75kyb9fJIGdh/omY0AAC54ITZWxZWVev7QIY/Ub9dOGjLE/JtW4X0IoGiwzEypdWvp+us9U//Jfz+pyupKPX3j057ZAADgIjFBQXowMlLzCgtVcP68R7Zx003SRx9JVVUeKQ8vQQBFg2VmGkNpBAWZX3tvyV69uu1VPTbsMXUN4cYjALDKjKgodbDbNX3/fo/UT06WysulrVs9Uh5eggCKBqmokLKyjG+yZnM6nZqWOU3R7aM1+ZrJ5m8AAHBZbe12PRsToxUlJcr67jvT6w8cKHXsKK1fb3ppeBECKBpk2zbp/HlpxAjza6/OXa3M/Zl68aYXFWgPNH8DAIA6pXXposS2bTUlL0/VJg/LZLMZZ8+yskwtCy9DAEWDZGVJbdtKV15pbt3K6kpNzZyqUTGj9Ks+vzK3OADAJf5+floYF6cvT5/WW8eOmV5/2DBpyxbjbBp8EwEUDZKVJV13nfFN1kwvb31ZB8oOaH7yfIZdAoAmNKRdO/22SxfNPHBAJx0OU2vfcINxFm37dlPLwosQQOE2h0P67DPz5/ItOl2kpzY+pfsG3af+nfubWxwA4LbnYmJ0prpaTx08aGrdK680zqJxGt53EUDhtp07pdOnzQ+gj378qOz+dj0x/AlzCwMAGqRHYKBm9uypl48cUc7Zs6bVtdmMs2gEUN9FAIXbsrKM8T8HDTKv5hfHvtCiLxdp9ojZCmsTZl5hAECjTIuIUERgoB40eVimYcOkTZuMs2rwPQRQuG3LFikxUWrVypx6TqdTk9dOVr/wfvr9oN+bUxQAYIogm03zYmL04fHjyjxxwrS6Q4caZ9O+/tq0kvAiBFC4LTtbSkoyr96KPSu06dAmzU+eL7u/3bzCAABT/G94uG5o105T8/JUVVNjSs2rr5b8/Y19CnwPARRuKS6WCgrMC6Bnq87qofUP6dY+t2p07GhzigIATOXn56cFcXHad/asXjt61JSaISFSv37GuNLwPQRQuKX2gyIx0Zx68z6bp6IzRXrhphfMKQgA8Iift22re7p106yDB1VaWWlKzaQkjoD6KgIo3JKdLXXqJEVHN75W4clCPf/Z85o6eKriOsY1viAAwKPm9Oolp9OpP5k0LFNiorRrl3TunCnl4EUIoHDLtm3GN1YzxoifvmG6QgNDNfP6mY0vBgDwuPBWrTQrOlpvHD2qXadPN7peUpJUXW0M7wffQgCFW3bsMGf4pU2HNmnZV8v03KjnFBoY2viCAABL3N+jh+KDgjQlL0/ORs4TP2CAMaIKMyL5HgIoXFZUZNyElJDQuDo1zhpNXjtZg7oP0sQrJ5rTHADAEq38/fVSXJw++e47rSotbVStgACpb19p926TmoPXIIDCZbUfEAMGNK7O4p2L9cWxL7Tw5oXy9+NPEAC8zf+EhWlMx456cP9+na+ublStAQMIoL6IvT9ctnu3FBQkxcY2vEZ5RblmfDRDd/S/Q0Mjh5rXHADAUi/FxqqwokLzDx9uVJ0BA6SvvpJMGl4UXoIACpft3m2M2WazNbzGnKw5Ol15WnNHzzWvMQCA5a4IDtYDPXro6YICHa2oaHCdhARjRqSCAhObQ7NHAIXLdu9u3On33OO5WrBlgR659hFFhEaY1xgAoEk83rOngmw2zcjPb3CN2v3Krl0mNQWvQACFS2pqpD17GhdAH1z3oLq17aY/Dv2jeY0BAJpM+4AAPd2rl9KLirS1vLxBNbp3lzp04DpQX0MAhUsOHzYGCr7iioatv27/On2Q84HmjZ6noIAgc5sDADSZu7t105XBwZqcm6uaBgzL5Odn7FtycjzQHJotAihckptr/IyPd39dR41DUzOn6vqo6zW+33hzGwMANCnbf+eJ33rqlJYWFTWoRnz89/sZ+AYCKFySm2vcfNSQKTj/uv2v+rrkay28eaH8zJhCCQDQrAzv0EG3h4fr4fx8nXY43F6fAOp7CKBwSW6uET4DAtxb7/jZ43r8k8d191V366puV3mkNwBA05sXE6PjVVV67tAht9eNi5OOH5fKyjzQGJolAihckpfXsNPvs/49S9XOaj1949PmNwUAaDaig4L0UFSUXigs1IFz59xat3b/kpfngcbQLBFA4ZLcXPcD6O6i3Xpt+2t6fNjj6hzc2TONAQCajUeiotQpIEAP7d/v1nq1+xdOw/sOAijq5XRK+fnuzYDkdDo1NXOqYjvE6oFrHvBccwCAZiPYZtPzsbFaWVqqT9w4nx4aKnXqJLmZW+HFCKCoV2mpVFEhRUW5vs77+97XRwc+0kvJL6mVrZXnmgMANCspnTtrcGiopuTlqdqNYZkiI40h/+AbCKCoV2Gh8TPCxcmLKhwVmrZumpJjk/WL+F94rjEAQLPj5+enhXFx2nXmjP527JjL6xFAfQsBFPWq/UCIjHTt/Qu2LFDBdwWanzyfYZcAwAclhYbqzi5d9Gh+vsqqqlxaJyLi+wMeaPkIoKhXYaEx/FJnF+4jOnbqmOZ8Okf3J96vvuF9Pd8cAKBZejYmRhVOp548eNCl93ME1LcQQFGvw4elHj0kfxf+WmZ+PFOBtkA9MfwJj/cFAGi+ugUG6tGoKL169Ki+OXOm3vdHRBjjgLrwVrQABFDUq7DQtes/tx3ZpsU7F2vOyDnqENTB840BAJq1KRERigoM1DQXbm+vvcyLo6C+gQCKehUXS1271v0ep9OpKZlTlNAlQb+7+nfWNAYAaNZa22x6MTZWa06c0Orjx+t8b5cuxs/iYgsaQ5MjgKJepaXG+Gx1efurt/V54edakLxANn+bNY0BAJq9Wzt10sj27TUtL0+VNTWXfV94uPGzpMSixtCkCKCoV0nJ9x8Ml3Km8oymr5+ucX3HaUSvEdY1BgBo9vz8/LQgLk55587p1SNHLvu+9u2New1KSy1sDk2GAIo6OZ31HwGd+9lclZ4t1bzR86xrDADgNQaEhOj33bvryYMHVVJZecn32GxSx44cAfUVBFDU6exZ6fz5ywfQgu8KNPfzuXpwyIOK6RBjbXMAAK/xVHS0/Pz89NiBA5d9T3g4R0B9BQEUdar9Jnq5ADp9w3R1aN1BM66fYV1TAACv06lVKz0ZHa03jx3TzlOnLv2eThwB9RUEUNTpxAnjZ1jYT5dlFWRpxZ4Ven7U8wppFWJtYwAAr3Nf9+66ok0bTcnLk/MS88SHhX2/30HLRgBFnWq/pLZte/Hr1TXVmrx2spJ6JCk1IdX6xgAAXifA31/z4+K08eRJrbzEoc62baXTp5ugMViOAIo61X4QhPzoAOeiLxdp57c7tfDmhfL3488IAOCa5I4d9cuwMP1x/36dq66+aFlICAHUV5AcUKfaD4IfHgE9ef6kHv34UaUlpGlwxOCmaQwA4LVejI3V0cpKvVhYeNHrbdt+f+YNLRsBFHWqDaBt2nz/2uys2TpbdVbP3vhs0zQFAPBqvdu00eSICD176JCOVFRceJ0joL6DAIo6nTplhE/bfyc3yjmeo4VbF2rGdTPUI7RH0zYHAPBaj/XsqWCbTQ//YJ54AqjvIICiTqdPX3z957TMaYoIjdC0IdOarikAgNdrZ7frmV69lFFcrM0nT0r6PoDWMWMnWggCKOpUUSG1bm08X5O7RqtzV+uF0S8oKCCoaRsDAHi9Sd266aqQEE3Oy1ON03lhf+NwNG1f8DwCKOrkcEh2u1RVXaWpmVM1PHq4xvUd19RtAQBaAJufnxbGxWnbqVNaUlQku914nQDa8tmbugE0TyUlJZo+fbo++CBb5eUORcafVFG7Ir225DX5+fk1dXsAgBbi+vbtdavNpnvvvlsddx2QVK2BA+0aPDhJc+fOVXh4eFO3CA/wc15qKgL4tOLiYg0dOlT7f3BheK3Y2Fht3ryZDwQAgCmKi4uVNGSICvLzf7KMfU7LRQB10e7du3X48GHZ7XYFBATIbrdfePzw3/Uts9lszf4I4qRJk7R48eLLLr/rrrv01ltvWdcQAKDFagn7nJqaGjkcDlVVVcnhcPzkuavLbrzxRrWuvRC2heMUvIsWLHhFixa9YUotm80muz1ANpv9wqP230ZYbfyyi5+7t2zNmg119p+dnW3K/wMAAPXtU9as2aDnnlshh6NK1dUOVVc7fvLc4XB4bNkPX7/cMrOO5eXkFCo+PsKUWs0dR0BdtHHjSQ0fflpSlSTHfx8/fP7jf7u6zIwaja3vnt69e2vfvn1urwcAwI/16dNHOTk5bq7lLylAxnG02kfAZZ43dJn19bOzOysx0ebm/4V34gioixIT22nHjnZN3YbpnE6nampqLvomd+ed16ig4PIfBnY7fzYAAHPUt0/p2bOP0tOzf3AGzyZ//5Y5iM8VVzR1B9YhSbioTRvp6qubugtP8JNk++8jUJI0YsRQLV58+QCalJRkSWcAgJYvKSlJe/fuvezyESOGaNiwUAs7ghU4BY+fKCkp0ZAhQ7gLHgDgcexzfBMBFJdUOw5odna2HA6H7Ha7kpIYkw0AYD72Ob6HAAoAAABLtcyreAEAANBsEUABAABgKQIoAAAALEUABQAAgKUIoAAAALAUARQAAACWIoACAADAUgRQAAAAWIoACgAAAEsRQAEAAGApAigAAAAsRQAFAACApQigAAAAsBQBFAAAAJYigAIAAMBSBFAAAABYigAKAAAASxFAAQAAYCkCKAAAACxFAAUAAIClCKAAAACwFAEUAAAAliKAAgAAwFIEUAAAAFiKAAoAAABLEUABAABgKQIoAAAALEUABQAAgKUIoAAAALAUARQAAACWIoACAADAUgRQAAAAWIoACgAAAEsRQAEAAGApAigAAAAsRQAFAACApQigAAAAsBQBFAAAAJYigAIAAMBSBFAAAABYigAKAAAASxFAAQAAYCkCKAAAACxFAAUAAIClCKAAAACwFAEUAAAAliKAAgAAwFIEUAAAAFiKAAoAAABLEUABAABgKQIoAAAALEUABQAAgKUIoAAAALAUARQAAACWIoACAADAUgRQAAAAWIoACgAAAEsRQAEAAGApAigAAAAsRQAFAACApQigAAAAsBQBFAAAAJYigAIAAMBSBFAAAABY6v8B/RLwxzs4r1MAAAAASUVORK5CYII=" - ], - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-15.0,15.0,-2.0,14.0)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot_stuff(elements)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Normal direction fitted in least squares sense. Getting better all the time. Now the field is accurate in nodal points and quite close in all around the faceted surface. Why not also fit geometry based on normal direction information? Let's increase the degree of approximation by introducing new basis function to hierarchical basis and use that to get more accurate solution:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "for el in elements\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" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "fit_derivative_field! (generic function with 2 methods)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - "Fit field s.t. || ∫ ∂/∂ξ(∑Nᵢ(ξ)αᵢ)f(el, ξ) dS || -> min!\n", - "\"\"\"\n", - "function fit_derivative_field!(el::Element, field, f, fixed_coeffs=Int[])\n", - " w = [\n", - " 128/225,\n", - " (332+13*sqrt(70))/900,\n", - " (332+13*sqrt(70))/900,\n", - " (332-13*sqrt(70))/900,\n", - " (332-13*sqrt(70))/900]\n", - " xi = Vector[\n", - " [0.0],\n", - " [ 1/3*sqrt(5 - 2*sqrt(10/7))],\n", - " [-1/3*sqrt(5 - 2*sqrt(10/7))], \n", - " [ 1/3*sqrt(5 + 2*sqrt(10/7))],\n", - " [-1/3*sqrt(5 + 2*sqrt(10/7))]]\n", - " n = get_number_of_basis_functions(el)\n", - " fld = get_field(el, field)\n", - " nfld = length(fld[1])\n", - " #Logging.debug(\"dim of field $field: $nfld\")\n", - "\n", - " M = zeros(n, n)\n", - " b = zeros(n, nfld)\n", - " for i=1:length(w)\n", - " detJ = get_detJ(el, xi[i])\n", - " dNdxi = get_dbasisdxi(el, xi[i])\n", - " dNdX = dNdxi / detJ\n", - " M += w[i]*dNdX*dNdX'*detJ\n", - " fi = f(el, xi[i])\n", - " for j=1:nfld\n", - " b[:, j] += w[i]*dNdX*fi[j]*detJ\n", - " end\n", - " end\n", - "\n", - " coeffs = zeros(n)\n", - " for j=1:nfld\n", - " for k=1:n\n", - " coeffs[k] = fld[k][j]\n", - " end\n", - " if length(fixed_coeffs) != 0\n", - " #Logging.info(\"constrained problem, some coefficients are fixed\")\n", - " N = Int[] # rest of coeffs\n", - " S = Int[] # fixed coeffs\n", - " for i = 1:n\n", - " if i in fixed_coeffs\n", - " push!(S, i)\n", - " else\n", - " push!(N, i)\n", - " end\n", - " end\n", - " lhs = M[N,N]\n", - " rhs = b[N,j] - M[N,S]*coeffs[S]\n", - " coeffs[N] = lhs \\ rhs\n", - " else\n", - " coeffs[:] = M \\ b[:,j]\n", - " end\n", - " for k=1:n\n", - " fld[k][j] = coeffs[k]\n", - " end\n", - " end\n", - " set_field(el, field, fld)\n", - " return\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "\"\"\"\n", - "Return tangent vector in point ξ for element el.\n", - "\"\"\"\n", - "function tangent(el, xi)\n", - " normal = interpolate(el, :Normals, xi)\n", - " [0 -1; 1 0]'*normal\n", - "end\n", - "\n", - "for i=1:5\n", - " for el in elements\n", - " fit_field!(el, :Normals, f)\n", - " fit_derivative_field!(el, :Geometry, tangent, Int[1, 2])\n", - " end\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": [ - "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" - ], - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-15.0,15.0,-2.0,14.0)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot_stuff(elements)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Remark: we didn't use accurate geometry information in any phase to fix geometry." - ] - } - ], - "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 -} diff --git a/notebooks/2015-12-18-normal-tangential-coordinates.ipynb b/notebooks/2015-12-18-normal-tangential-coordinates.ipynb deleted file mode 100644 index 953a828..0000000 --- a/notebooks/2015-12-18-normal-tangential-coordinates.ipynb +++ /dev/null @@ -1,3259 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Normal-tangential coordinates\n", - "\n", - "Author: Jukka Aho\n", - "\n", - "**Abstract**: Use of normal tangential coordinate system" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Array{Float64,1}" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using JuliaFEM.Core: Quad4, Seg2, Seg3, PlaneStressLinearElasticityProblem, DirichletProblem, update!, DirectSolver\n", - "typealias Node Vector{Float64}" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "using Gadfly\n", - "set_default_plot_size(10cm, 10cm)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Element normal definition in 2d" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " x\n", - " \n", - " \n", - " -0.5\n", - " 0.0\n", - " 0.5\n", - " 1.0\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " n\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " t\n", - " \n", - " \n", - " 1\n", - " 2\n", - " 3\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " -0.5\n", - " 0.0\n", - " 0.5\n", - " 1.0\n", - " \n", - " \n", - " y\n", - " \n", - "\n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " x\n", - " \n", - " \n", - " -2.5\n", - " -2.0\n", - " -1.5\n", - " -1.0\n", - " -0.5\n", - " 0.0\n", - " 0.5\n", - " 1.0\n", - " 1.5\n", - " 2.0\n", - " 2.5\n", - " 3.0\n", - " -2.00\n", - " -1.95\n", - " -1.90\n", - " -1.85\n", - " -1.80\n", - " -1.75\n", - " -1.70\n", - " -1.65\n", - " -1.60\n", - " -1.55\n", - " -1.50\n", - " -1.45\n", - " -1.40\n", - " -1.35\n", - " -1.30\n", - " -1.25\n", - " -1.20\n", - " -1.15\n", - " -1.10\n", - " -1.05\n", - " -1.00\n", - " -0.95\n", - " -0.90\n", - " -0.85\n", - " -0.80\n", - " -0.75\n", - " -0.70\n", - " -0.65\n", - " -0.60\n", - " -0.55\n", - " -0.50\n", - " -0.45\n", - " -0.40\n", - " -0.35\n", - " -0.30\n", - " -0.25\n", - " -0.20\n", - " -0.15\n", - " -0.10\n", - " -0.05\n", - " 0.00\n", - " 0.05\n", - " 0.10\n", - " 0.15\n", - " 0.20\n", - " 0.25\n", - " 0.30\n", - " 0.35\n", - " 0.40\n", - " 0.45\n", - " 0.50\n", - " 0.55\n", - " 0.60\n", - " 0.65\n", - " 0.70\n", - " 0.75\n", - " 0.80\n", - " 0.85\n", - " 0.90\n", - " 0.95\n", - " 1.00\n", - " 1.05\n", - " 1.10\n", - " 1.15\n", - " 1.20\n", - " 1.25\n", - " 1.30\n", - " 1.35\n", - " 1.40\n", - " 1.45\n", - " 1.50\n", - " 1.55\n", - " 1.60\n", - " 1.65\n", - " 1.70\n", - " 1.75\n", - " 1.80\n", - " 1.85\n", - " 1.90\n", - " 1.95\n", - " 2.00\n", - " 2.05\n", - " 2.10\n", - " 2.15\n", - " 2.20\n", - " 2.25\n", - " 2.30\n", - " 2.35\n", - " 2.40\n", - " 2.45\n", - " 2.50\n", - " -2\n", - " 0\n", - " 2\n", - " 4\n", - " -2.0\n", - " -1.9\n", - " -1.8\n", - " -1.7\n", - " -1.6\n", - " -1.5\n", - " -1.4\n", - " -1.3\n", - " -1.2\n", - " -1.1\n", - " -1.0\n", - " -0.9\n", - " -0.8\n", - " -0.7\n", - " -0.6\n", - " -0.5\n", - " -0.4\n", - " -0.3\n", - " -0.2\n", - " -0.1\n", - " 0.0\n", - " 0.1\n", - " 0.2\n", - " 0.3\n", - " 0.4\n", - " 0.5\n", - " 0.6\n", - " 0.7\n", - " 0.8\n", - " 0.9\n", - " 1.0\n", - " 1.1\n", - " 1.2\n", - " 1.3\n", - " 1.4\n", - " 1.5\n", - " 1.6\n", - " 1.7\n", - " 1.8\n", - " 1.9\n", - " 2.0\n", - " 2.1\n", - " 2.2\n", - " 2.3\n", - " 2.4\n", - " 2.5\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " n\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " t\n", - " \n", - " \n", - " 1\n", - " 2\n", - " 3\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " -2.5\n", - " -2.0\n", - " -1.5\n", - " -1.0\n", - " -0.5\n", - " 0.0\n", - " 0.5\n", - " 1.0\n", - " 1.5\n", - " 2.0\n", - " 2.5\n", - " 3.0\n", - " -2.00\n", - " -1.95\n", - " -1.90\n", - " -1.85\n", - " -1.80\n", - " -1.75\n", - " -1.70\n", - " -1.65\n", - " -1.60\n", - " -1.55\n", - " -1.50\n", - " -1.45\n", - " -1.40\n", - " -1.35\n", - " -1.30\n", - " -1.25\n", - " -1.20\n", - " -1.15\n", - " -1.10\n", - " -1.05\n", - " -1.00\n", - " -0.95\n", - " -0.90\n", - " -0.85\n", - " -0.80\n", - " -0.75\n", - " -0.70\n", - " -0.65\n", - " -0.60\n", - " -0.55\n", - " -0.50\n", - " -0.45\n", - " -0.40\n", - " -0.35\n", - " -0.30\n", - " -0.25\n", - " -0.20\n", - " -0.15\n", - " -0.10\n", - " -0.05\n", - " 0.00\n", - " 0.05\n", - " 0.10\n", - " 0.15\n", - " 0.20\n", - " 0.25\n", - " 0.30\n", - " 0.35\n", - " 0.40\n", - " 0.45\n", - " 0.50\n", - " 0.55\n", - " 0.60\n", - " 0.65\n", - " 0.70\n", - " 0.75\n", - " 0.80\n", - " 0.85\n", - " 0.90\n", - " 0.95\n", - " 1.00\n", - " 1.05\n", - " 1.10\n", - " 1.15\n", - " 1.20\n", - " 1.25\n", - " 1.30\n", - " 1.35\n", - " 1.40\n", - " 1.45\n", - " 1.50\n", - " 1.55\n", - " 1.60\n", - " 1.65\n", - " 1.70\n", - " 1.75\n", - " 1.80\n", - " 1.85\n", - " 1.90\n", - " 1.95\n", - " 2.00\n", - " 2.05\n", - " 2.10\n", - " 2.15\n", - " 2.20\n", - " 2.25\n", - " 2.30\n", - " 2.35\n", - " 2.40\n", - " 2.45\n", - " 2.50\n", - " -2\n", - " 0\n", - " 2\n", - " 4\n", - " -2.0\n", - " -1.9\n", - " -1.8\n", - " -1.7\n", - " -1.6\n", - " -1.5\n", - " -1.4\n", - " -1.3\n", - " -1.2\n", - " -1.1\n", - " -1.0\n", - " -0.9\n", - " -0.8\n", - " -0.7\n", - " -0.6\n", - " -0.5\n", - " -0.4\n", - " -0.3\n", - " -0.2\n", - " -0.1\n", - " 0.0\n", - " 0.1\n", - " 0.2\n", - " 0.3\n", - " 0.4\n", - " 0.5\n", - " 0.6\n", - " 0.7\n", - " 0.8\n", - " 0.9\n", - " 1.0\n", - " 1.1\n", - " 1.2\n", - " 1.3\n", - " 1.4\n", - " 1.5\n", - " 1.6\n", - " 1.7\n", - " 1.8\n", - " 1.9\n", - " 2.0\n", - " 2.1\n", - " 2.2\n", - " 2.3\n", - " 2.4\n", - " 2.5\n", - " \n", - " \n", - " y\n", - " \n", - "\n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "Plot(...)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "el = Seg3([1, 2, 3])\n", - "el[\"geometry\"] = Node[[-0.2, -0.1], [1.0, 0.8], [0.2, 0.7]]\n", - "x = Float64[]\n", - "y = Float64[]\n", - "for xi in linspace(-1, 1)\n", - " X = el(\"geometry\", [xi], 0.0)\n", - " push!(x, X[1])\n", - " push!(y, X[2])\n", - "end\n", - "l1 = layer(x=x, y=y, Geom.line)\n", - "\n", - "X1 = el(\"geometry\", [-1.0], 0.0)\n", - "X2 = el(\"geometry\", [1.0], 0.0)\n", - "X3 = el(\"geometry\", [0.0], 0.0)\n", - "l2 = layer(x=[X1[1],X2[1],X3[1]], y=[X1[2],X2[2],X3[2]], label=[\"1\",\"2\",\"3\"],\n", - " Geom.point, Geom.label(;hide_overlaps=false))\n", - "\n", - "xi = [-0.5]\n", - "X = el(\"geometry\", xi, 0.0)\n", - "J = JuliaFEM.Core.get_jacobian(el, xi, 0.0)\n", - "t = vec(J)/norm(J)\n", - "n = [cos(pi/2) -sin(pi/2); sin(pi/2) cos(pi/2)]*t\n", - "a = 0.3\n", - "l3 = layer(x=[X[1], X[1]+a*t[1]], y=[X[2], X[2]+a*t[2]], label=[\"\",\"t\"],\n", - " Geom.label(;hide_overlaps=false), Geom.line, Theme(default_color=colorant\"red\"))\n", - "l4 = layer(x=[X[1], X[1]+a*n[1]], y=[X[2], X[2]+a*n[2]], label=[\"\",\"n\"],\n", - " Geom.label(;hide_overlaps=false), Geom.line, Theme(default_color=colorant\"red\"))\n", - "\n", - "p = plot(l1, l2, l3, l4, Coord.Cartesian(xmin=-0.5, ymin=-0.5, xmax=1.0, ymax=1.0))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Model defined in cartesian coordinates" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Model defined using cartesian coordinates. In general set individual components of vector values using index number, 1=x, 2=y, 3=z." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Starting solver simple 2d block\n", - "INFO: # of field problems: 1\n", - "INFO: # of boundary problems: 1\n", - "INFO: Starting iteration 1\n", - "INFO: Assembling field problems...\n", - "INFO: Assembling body 1: block\n", - "INFO: dim = 8\n", - "INFO: Assembling boundary problems...\n", - "INFO: Assembling boundary 1: dirichlet boundary conditions\n", - "INFO: Solving system\n", - "INFO: UMFPACK: solved in 0.20885300636291504 seconds. norm = 0.16197088596792505\n" - ] - }, - { - "data": { - "text/plain": [ - "(1,true)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: timing info for iteration:\n", - "INFO: boundary assembly : 0.11499595642089844\n", - "INFO: field assembly : 1.344099998474121\n", - "INFO: dump matrices to disk : 1.1920928955078125e-6\n", - "INFO: solve problem : 0.38971495628356934\n", - "INFO: update element data : 0.031152963638305664\n", - "INFO: non-linear iteration : 1.879986047744751\n", - "INFO: solver finished in 2.0280649662017822 seconds.\n" - ] - } - ], - "source": [ - "geometry = Dict{Int64, Node}(\n", - " 1 => [0.0, 0.0],\n", - " 2 => [1.0, 0.0],\n", - " 3 => [1.0, 1.0],\n", - " 4 => [0.0, 1.0])\n", - "el1 = Quad4([1, 2, 3, 4])\n", - "el2 = Seg2([3, 4]) # load\n", - "el3 = Seg2([1, 2]) # symmetry 2\n", - "el4 = Seg2([4, 1]) # symmetry 1\n", - "update!([el1, el2, el3, el4], \"geometry\", geometry)\n", - "el1[\"youngs modulus\"] = 900.0\n", - "el1[\"poissons ratio\"] = 0.25\n", - "el2[\"displacement traction force 2\"] = -100.0\n", - "el3[\"displacement 2\"] = 0.0\n", - "el4[\"displacement 1\"] = 0.0\n", - "problem = PlaneStressLinearElasticityProblem(\"block\")\n", - "boundary = DirichletProblem(\"dirichlet boundary conditions\", \"displacement\", 2)\n", - "push!(problem, el1, el2)\n", - "push!(boundary, el3, el4)\n", - "solver = DirectSolver(\"simple 2d block\")\n", - "push!(solver, problem)\n", - "push!(solver, boundary)\n", - "solver.method = :UMFPACK\n", - "solver.nonlinear_problem = false\n", - "call(solver, 0.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Test Passed\n", - " Expression: isapprox(el1(\"displacement\",[1.0,1.0],0.0),[1 / 36,-1 / 9])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using JuliaFEM.Test\n", - "@test isapprox(el1(\"displacement\", [1.0, 1.0], 0.0), [1/36, -1/9])" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0.11453071182271282" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm(el1(\"displacement\", [1.0, 1.0], 0.0))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "Compose.Context(Measures.BoundingBox{Tuple{Measures.Length{:cx,Int64},Measures.Length{:cy,Int64}},Tuple{Measures.Length{:cx,Int64},Measures.Length{:cy,Int64}}}((0cx,0cy),(1cx,1cy)),Nullable{Compose.UnitBox{S,T,U,V}}(),Nullable{Compose.Rotation{P<:NTuple{N,Measures.Measure}}}(),Nullable{Compose.Mirror}(),Compose.ListNode{Compose.Container}(Compose.Context(Measures.BoundingBox{Tuple{Measures.Length{:cx,Int64},Measures.Length{:cy,Int64}},Tuple{Measures.Length{:cx,Int64},Measures.Length{:cy,Int64}}}((0cx,0cy),(1cx,1cy)),Nullable{Compose.UnitBox{S,T,U,V}}(),Nullable{Compose.Rotation{P<:NTuple{N,Measures.Measure}}}(),Nullable{Compose.Mirror}(),Compose.ListNull{Compose.Container}(),Compose.ListNode{Compose.Form{P<:Compose.FormPrimitive}}(Compose.Form{Compose.SimplePolygonPrimitive{Tuple{Measures.Length{:cx,Float64},Measures.Length{:cy,Float64}}}}([Compose.SimplePolygonPrimitive{Tuple{Measures.Length{:cx,Float64},Measures.Length{:cy,Float64}}}([(0.0cx,0.0cy),(1.0277777777777777cx,0.0cy),(1.0277777777777777cx,0.8888888888888888cy),(0.0cx,0.8888888888888888cy)])],symbol(\"\")),Compose.ListNull{Compose.Form{P<:Compose.FormPrimitive}}()),Compose.ListNode{Compose.Property{P<:Compose.PropertyPrimitive}}(Compose.Property{Compose.StrokePrimitive}([Compose.StrokePrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0))]),Compose.ListNode{Compose.Property{P<:Compose.PropertyPrimitive}}(Compose.Property{Compose.FillPrimitive}([Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]),Compose.ListNode{Compose.Property{P<:Compose.PropertyPrimitive}}(Compose.Property{Compose.LineWidthPrimitive}([Compose.LineWidthPrimitive(1.0mm)]),Compose.ListNull{Compose.Property{P<:Compose.PropertyPrimitive}}()))),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\")),Compose.ListNull{Compose.Container}()),Compose.ListNode{Compose.Form{P<:Compose.FormPrimitive}}(Compose.Form{Compose.SimplePolygonPrimitive{Tuple{Measures.Length{:cx,Float64},Measures.Length{:cy,Float64}}}}([Compose.SimplePolygonPrimitive{Tuple{Measures.Length{:cx,Float64},Measures.Length{:cy,Float64}}}([(0.0cx,0.0cy),(1.0cx,0.0cy),(1.0cx,1.0cy),(0.0cx,1.0cy)])],symbol(\"\")),Compose.ListNull{Compose.Form{P<:Compose.FormPrimitive}}()),Compose.ListNode{Compose.Property{P<:Compose.PropertyPrimitive}}(Compose.Property{Compose.StrokePrimitive}([Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]),Compose.ListNode{Compose.Property{P<:Compose.PropertyPrimitive}}(Compose.Property{Compose.FillPrimitive}([Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]),Compose.ListNode{Compose.Property{P<:Compose.PropertyPrimitive}}(Compose.Property{Compose.LineWidthPrimitive}([Compose.LineWidthPrimitive(1.0mm)]),Compose.ListNull{Compose.Property{P<:Compose.PropertyPrimitive}}()))),0,false,false,false,false,nothing,nothing,0.0,symbol(\"\"))" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using Compose\n", - "\n", - "X = el1(\"geometry\")\n", - "u = el1(\"displacement\", 0.0)\n", - "x = X+u\n", - "\n", - "root = context(0, 0, 1, 1)\n", - "p1 = polygon([tuple(X[i][1], X[i][2]) for i=1:4])\n", - "p2 = polygon([tuple(x[i][1], x[i][2]) for i=1:4])\n", - "undeformed = compose(root, p1, linewidth(1mm), fill(nothing), stroke(\"black\"))\n", - "deformed = compose(root, p2, linewidth(1mm), fill(nothing), stroke(\"red\"))\n", - "compose(undeformed, deformed)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Using normal tangential coordinates\n", - "\n", - "Sometimes it's more convenient to set boundary conditions using normal-tangential coordinates." - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "rot (generic function with 1 method)" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rot(ϕ) = [cos(ϕ) -sin(ϕ); sin(ϕ) cos(ϕ)]" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "false" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using JuliaFEM.Core: Quad4, Seg2, Seg3, PlaneStressLinearElasticityProblem, DirichletProblem, update!, DirectSolver\n", - "typealias Node Vector{Float64}\n", - "using JuliaFEM.Core: calculate_normal_tangential_coordinates!\n", - "\n", - "# 2d rotation matrix\n", - "#phi = pi/10\n", - "phi = 0.0\n", - "rmat(phi) = [cos(phi) -sin(phi); sin(phi) cos(phi)]\n", - "\n", - "geometry = Dict{Int64, Node}(\n", - " 1 => rmat(phi)*[0.0, 0.0],\n", - " 2 => rmat(phi)*[1.0, 0.0],\n", - " 3 => rmat(phi)*[1.0, 1.0],\n", - " 4 => rmat(phi)*[0.0, 1.0])\n", - "el1 = Quad4([1, 2, 3, 4])\n", - "el2 = Seg2([3, 4]) # load\n", - "el3 = Seg2([1, 2]) # symmetry 2\n", - "el4 = Seg2([4, 1]) # symmetry 1\n", - "update!([el1, el2, el3, el4], \"geometry\", geometry)\n", - "calculate_normal_tangential_coordinates!([el2, el3, el4], 0.0)\n", - "\n", - "el1[\"youngs modulus\"] = 900.0\n", - "el1[\"poissons ratio\"] = 0.25\n", - "# traction force in local coordinates\n", - "el2[\"local displacement traction force 1\"] = 100.0\n", - "# support sides in local coordinates\n", - "el3[\"local displacement 1\"] = 0.0\n", - "el4[\"local displacement 2\"] = 0.0\n", - "for el in [el3, el4]\n", - " el[\"displacement near coord (0.0,0.0)\"] = 0.0\n", - "end\n", - "problem = PlaneStressLinearElasticityProblem(\"block\")\n", - "boundary = DirichletProblem(\"dirichlet boundary conditions\", \"displacement\", 2)\n", - "push!(problem, el1, el2)\n", - "push!(boundary, el3, el4)\n", - "solver = DirectSolver(\"rotated 2d block\")\n", - "push!(solver, problem)\n", - "push!(solver, boundary)\n", - "solver.method = :UMFPACK\n", - "solver.nonlinear_problem = false\n", - "#call(solver, 0.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "8x1 sparse matrix with 2 Float64 entries:\n", - "\t[6, 1] = -50.0\n", - "\t[8, 1] = -50.0" - ] - }, - "execution_count": 85, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "K = sparse(JuliaFEM.Core.assemble(problem, 0.0).stiffness_matrix)\n", - "f = sparse(JuliaFEM.Core.assemble(problem, 0.0).force_vector)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "using JuliaFEM.Core: SparseMatrixCOO\n", - "\n", - "\"\"\"\n", - "For general problem type\n", - "Au + C₁'λ = f\n", - "C₂u + Dλ = g\n", - "\"\"\"\n", - "type BoundaryAssembly\n", - " C1 :: SparseMatrixCOO\n", - " C2 :: SparseMatrixCOO\n", - " D :: SparseMatrixCOO\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "BoundaryAssembly" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function BoundaryAssembly()\n", - " return BoundaryAssembly(SparseMatrixCOO(), SparseMatrixCOO(), SparseMatrixCOO())\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: De = [0.5 0.0\n", - " 0.0 0.5]\n", - "INFO: De = [0.5 0.0\n", - " 0.0 0.5]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Array(Float64,(8,8)) 8x8 Array{Float64,2}" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: De = [0.5 0.0\n", - " 0.0 0.5]\n", - "INFO: De = [0.5 0.0\n", - " 0.0 0.5]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ":\n", - " 2.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 2.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0\n", - "Array(Float64,(7,8)) 7x8 Array{Float64,2}:\n", - " 2.0 2.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 2.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 2.0 0.0\n", - "Array(Float64,(8,8)) 8x8 Array{Float64,2}:\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 2.0 -2.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 2.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -2.0\n" - ] - } - ], - "source": [ - "using JuliaFEM.Core: get_gdofs, get_integration_points, get_jacobian, add!, get_connectivity\n", - "\n", - "function do_boundary()\n", - " assembly = BoundaryAssembly()\n", - " field_dim = 2\n", - " time = 0.0\n", - " for element in [el3, el4]\n", - " gdofs = get_gdofs(element, field_dim)\n", - " for ip in get_integration_points(element, Val{2})\n", - " w = ip.weight\n", - " J = get_jacobian(element, ip, time)\n", - " N = element(ip, time)\n", - " N_bo = [1/2*(1-3*ip.xi[1]) 1/2*(1+3*ip.xi[1])]\n", - " #C1 = w*N_bo'*N*norm(J)\n", - " De = eye(2)*norm(J)\n", - " info(\"De = $De\")\n", - " # add to C1\n", - " for i=1:field_dim\n", - " ldofs = gdofs[i:field_dim:end]\n", - " add!(assembly.C1, ldofs, ldofs, De)\n", - " end\n", - " # add to C2\n", - " nt = element(\"normal-tangential coordinates\", ip, time)\n", - " nt = transpose(nt)\n", - " normal = nt[1,:]\n", - " tangent = nt[2,:]\n", - " for nid in get_connectivity(element)\n", - " ndofs = [2*(nid-1)+1, 2*(nid-1)+2]\n", - " add!(assembly.C2, [2*(nid-1)+1], ndofs, normal)\n", - " add!(assembly.D, [2*(nid-1)+2], ndofs, tangent)\n", - " end\n", - " end\n", - " end\n", - " return assembly\n", - "end\n", - "\n", - "ntass = do_boundary()\n", - "ENV[\"COLUMNS\"] = 300\n", - "dump(round(full(ntass.C1), 2))\n", - "dump(round(full(ntass.C2), 2))\n", - "dump(round(full(ntass.D), 2))" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: size of A = (16,16)\n", - "INFO: total dim = 16\n" - ] - }, - { - "data": { - "text/plain": [ - "2x8 Array{Float64,2}:\n", - " 0.0 0.0277778 0.0277778 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 -0.111111 -0.111111 -25.0 -25.0 0.0 0.0" - ] - }, - "execution_count": 98, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: solving\n", - "INFO: solved\n" - ] - } - ], - "source": [ - "g = spzeros(8, 1)\n", - "A = [K B'; C D]\n", - "b = [f; g]\n", - "\n", - "info(\"size of A = $(size(A))\")\n", - "ENV[\"COLUMNS\"] = 300\n", - "\n", - "dim = size(A, 1)\n", - "info(\"total dim = $dim\")\n", - "\n", - "nz1 = sort(unique(rowvals(A)))\n", - "nz2 = sort(unique(rowvals(A')))\n", - "A = A[nz1, nz2]\n", - "b = b[nz1]\n", - "u = zeros(dim)\n", - "T = full(A)\n", - "T[abs(T) .< 1.0e-9] = 0\n", - "info(\"solving\")\n", - "sol = T \\ full(b)\n", - "info(\"solved\")\n", - "\n", - "u[nz1] = sol\n", - "u[abs(u).<1.0e-9] = 0.0\n", - "u = reshape(full(u), 2, round(Int, length(u)/2))\n", - "full(u)" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2-element Array{Float64,1}:\n", - " 0.0277778\n", - " -0.111111 " - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "u[:,3]" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Test Passed\n", - " Expression: isapprox(norm(u[:,3]),0.11453071182271282)" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "@test isapprox(norm(u[:,3]), 0.11453071182271282)" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "16x16 Array{Int64,2}:\n", - " 440 150 -260 -30 -220 -150 40 30 2 0 0 0 0 0 0 0\n", - " 150 440 30 40 -150 -220 -30 -260 0 2 0 0 0 0 0 0\n", - " -260 30 440 -150 40 -30 -220 150 0 0 2 0 0 0 0 0\n", - " -30 40 -150 440 30 -260 150 -220 0 0 0 2 0 0 0 0\n", - " -220 -150 40 30 440 150 -260 -30 0 0 0 0 2 0 0 0\n", - " -150 -220 -30 -260 150 440 30 40 0 0 0 0 0 2 0 0\n", - " 40 -30 -220 150 -260 30 440 -150 0 0 0 0 0 0 2 0\n", - " 30 -260 150 -220 -30 40 -150 440 0 0 0 0 0 0 0 2\n", - " 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", - " 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", - " 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0\n", - " 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0\n", - " 0 0 0 0 0 0 0 0 0 0 0 0 -1 0 0 0\n", - " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0\n", - " 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0\n", - " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "round(Int, T)" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "16x16 Array{Float64,2}:\n", - " 440.0 150.0 -260.0 -30.0 -220.0 -150.0 40.0 30.0 2.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 150.0 440.0 30.0 40.0 -150.0 -220.0 -30.0 -260.0 0.0 2.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " -260.0 30.0 440.0 -150.0 40.0 -30.0 -220.0 150.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0\n", - " -30.0 40.0 -150.0 440.0 30.0 -260.0 150.0 -220.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0\n", - " -220.0 -150.0 40.0 30.0 440.0 150.0 -260.0 -30.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " -150.0 -220.0 -30.0 -260.0 150.0 440.0 30.0 40.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 40.0 -30.0 -220.0 150.0 -260.0 30.0 440.0 -150.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0\n", - " 30.0 -260.0 150.0 -220.0 -30.0 40.0 -150.0 440.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0\n", - " 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 2.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 2.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 2.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -2.0" - ] - }, - "execution_count": 119, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "C1 = sparse(ntass.C1, 8, 8)\n", - "C2 = sparse(ntass.C2, 8, 8)\n", - "D = sparse(ntass.D, 8, 8)\n", - "C2[1,:] = 0\n", - "D[2,:] = 0\n", - "C2[1,1] = 1\n", - "C2[2,2] = 1\n", - "#C2[2,:] = D[2,:]\n", - "#D[2,:] = 0\n", - "A = [K C1'; C2 D]\n", - "#A[9,:] = 0\n", - "#A[9, 1] = 1\n", - "#A[10,:] = 0\n", - "#A[10, 1] = 2\n", - "#A[10, 2] = -2\n", - "full(A)" - ] - }, - { - "cell_type": "code", - "execution_count": 120, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2x8 Array{Float64,2}:\n", - " 0.0 0.0277778 0.0277778 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 -0.111111 -0.111111 -25.0 -50.0 0.0 0.0" - ] - }, - "execution_count": 120, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "b = [f; spzeros(8, 1)]\n", - "nz1 = sort(unique(rowvals(A)))\n", - "nz2 = sort(unique(rowvals(A')))\n", - "sol = zeros(length(b))\n", - "sol[nz1] = A[nz1, nz2] \\ full(b)[nz1]\n", - "sol[abs(sol) .< 1.0e-9] = 0\n", - "sol = reshape(sol, 2, 8)" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Test Passed\n", - " Expression: isapprox(norm(sol[:,3]),0.11453071182271282)" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "@test isapprox(norm(sol[:,3]), 0.11453071182271282)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "ename": "LoadError", - "evalue": "LoadError: KeyError: displacement not found\nwhile loading In[13], in expression starting on line 1", - "output_type": "error", - "traceback": [ - "LoadError: KeyError: displacement not found\nwhile loading In[13], in expression starting on line 1", - "", - " in getindex at /home/jukka/.julia/v0.4/JuliaFEM/src/elements.jl:94", - " in call at /home/jukka/.julia/v0.4/JuliaFEM/src/elements.jl:130 (repeats 2 times)" - ] - } - ], - "source": [ - "u_tip = el1(\"displacement\", [1.0, 1.0], 0.0)\n", - "info(\"displacement on tip: $u_tip, magnitude = $(norm(u_tip))\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error During Test\n", - " Test threw an exception of type UndefVarError\n", - " Expression: isapprox(" - ] - }, - { - "ename": "LoadError", - "evalue": "LoadError: There was an error during testing\nwhile loading In[14], in expression starting on line 2", - "output_type": "error", - "traceback": [ - "LoadError: There was an error during testing\nwhile loading In[14], in expression starting on line 2", - "", - " in record at /home/jukka/.julia/v0.4/BaseTestNext/src/BaseTestNext.jl:290", - " in do_test at /home/jukka/.julia/v0.4/BaseTestNext/src/BaseTestNext.jl:192" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "norm(u_tip),norm([1 / 36,-1 / 9]))\n", - " UndefVarError: u_tip not defined\n", - " in anonymous at /home/jukka/.julia/v0.4/BaseTestNext/src/BaseTestNext.jl:165\n", - " in do_test at /home/jukka/.julia/v0.4/BaseTestNext/src/BaseTestNext.jl:181\n", - " in include_string at loading.jl:266\n", - " in execute_request_0x535c5df2 at /home/jukka/.julia/v0.4/IJulia/src/execute_request.jl:177\n", - " in eventloop at /home/jukka/.julia/v0.4/IJulia/src/IJulia.jl:141\n", - " in anonymous at task.jl:447\n" - ] - } - ], - "source": [ - "using JuliaFEM.Test\n", - "@test isapprox(norm(u_tip), norm([1/36, -1/9]))" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "using JuliaFEM.Core: Seg2, Element, update!\n", - "using JuliaFEM.Core: calculate_normal_tangential_coordinates!\n", - "typealias Node Vector{Float64}\n", - "\n", - "nodes = Dict{Int, Node}(\n", - "1 => [0.0, 0.1],\n", - "2 => [1.0, 0.3],\n", - "3 => [2.0, -0.1],\n", - "4 => [3.0, 0.6],\n", - "5 => [4.0, 0.3])\n", - "\n", - "s1 = Seg2([1, 2])\n", - "s2 = Seg2([2, 3])\n", - "s3 = Seg2([3, 4])\n", - "s4 = Seg2([4, 5])\n", - "elems = Element[s1, s2, s3, s4]\n", - "update!(elems, \"geometry\", nodes)\n", - "calculate_normal_tangential_coordinates!([s1, s2, s3, s4], 0.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-0.5,4.5)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using PyPlot\n", - "fig = figure(figsize=(5, 3))\n", - "for s in [s1, s2, s3, s4]\n", - " X1 = s(\"geometry\", [-1.0], 0.0)\n", - " X2 = s(\"geometry\", [ 1.0], 0.0)\n", - " nt1 = s(\"normal-tangential coordinates\", [-1.0], 0.0)\n", - " nt2 = s(\"normal-tangential coordinates\", [ 1.0], 0.0)\n", - " plot([X1[1],X2[1]], [X1[2],X2[2]], \"-ko\")\n", - " X1N1 = X1 + nt1[:,1]*0.5\n", - " X1T1 = X1 + nt1[:,2]*0.5\n", - " plot([X1[1],X1N1[1]], [X1[2],X1N1[2]], \"-r\")\n", - " plot([X1[1],X1T1[1]], [X1[2],X1T1[2]], \"-g\")\n", - " X2N2 = X2 + nt2[:,1]*0.5\n", - " X2T2 = X2 + nt2[:,2]*0.5\n", - " plot([X2[1],X2N2[1]], [X2[2],X2N2[2]], \"-b\")\n", - " plot([X2[1],X2T2[1]], [X2[2],X2T2[2]], \"-y\")\n", - "end\n", - "axis(\"equal\")\n", - "ylim(-0.5, 1.0)\n", - "xlim(-0.5, 4.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "10x10 Array{Float64,2}:\n", - " -0.196116 0.980581 0.0 0.0 … 0.0 0.0 0.0 \n", - " 0.980581 0.196116 0.0 0.0 0.0 0.0 0.0 \n", - " 0.0 0.0 0.0914276 0.995812 0.0 0.0 0.0 \n", - " 0.0 0.0 0.995812 -0.0914276 0.0 0.0 0.0 \n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - " 0.0 0.0 0.0 0.0 … 0.0 0.0 0.0 \n", - " 0.0 0.0 0.0 0.0 0.987285 0.0 0.0 \n", - " 0.0 0.0 0.0 0.0 0.158957 0.0 0.0 \n", - " 0.0 0.0 0.0 0.0 0.0 0.287348 0.957826\n", - " 0.0 0.0 0.0 0.0 0.0 0.957826 -0.287348" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using JuliaFEM.Core: SparseMatrixCOO, Element, get_integration_points, get_jacobian, get_connectivity, add!\n", - "\n", - "function calculate_normal_tangential_coordinates(elements::Vector{Element}, time::Real)\n", - " P = SparseMatrixCOO()\n", - " field_dim = 2\n", - " time = 0.0\n", - " for element in elements\n", - " for ip in get_integration_points(element, Val{2})\n", - " J = get_jacobian(element, ip, time)\n", - " w = ip.weight*norm(J)\n", - " nt = transpose(element(\"normal-tangential coordinates\", ip, time))\n", - " normal = nt[1,:]\n", - " tangent = nt[2,:]\n", - " for nid in get_connectivity(element)\n", - " ndofs = [2*(nid-1)+1, 2*(nid-1)+2]\n", - " add!(P, [2*(nid-1)+1], ndofs, normal)\n", - " add!(P, [2*(nid-1)+2], ndofs, tangent)\n", - " end\n", - " end\n", - " end\n", - " P = sparse(P)\n", - " for i=1:size(P,1)\n", - " if sum(abs(P[i,:])) > 0.0\n", - " P[i,:] = P[i,:] / norm(P[i,:])\n", - " end\n", - " end\n", - " return P\n", - "end\n", - "P = calculate_normal_tangential_coordinates(Element[s1, s2, s3, s4], 0.0)\n", - "P = full(P)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "i = 1, normal = [-0.19611613513818404,0.9805806756909202], tangent = [0.9805806756909202,0.19611613513818404], dot = 0" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-1.0,5.0,-0.2,1.2000000000000002)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ".0\n", - "i = 2, normal = [0.09142755332923394,0.9958117304451831], tangent = [0.9958117304451831,-0.09142755332923394], dot = 0.0\n", - "i = 3, normal = [-0.11485575612958872,0.9933821798703159], tangent = [0.9933821798703159,0.11485575612958872], dot = 0.0\n", - "i = 4, normal = [-0.15895744828402364,0.9872854347325458], tangent = [0.9872854347325458,0.15895744828402364], dot = 0.0\n", - "i = 5, normal = [0.28734788556634544,0.9578262852211514], tangent = [0.9578262852211514,-0.28734788556634544], dot = 0.0\n" - ] - } - ], - "source": [ - "for s in [s1, s2, s3, s4]\n", - " X1 = s(\"geometry\", [-1.0], 0.0)\n", - " X2 = s(\"geometry\", [ 1.0], 0.0)\n", - " plot([X1[1],X2[1]], [X1[2],X2[2]], \"-ko\")\n", - "end\n", - "for i=1:5\n", - " s = 2*(i-1)+1\n", - " e = s + 1\n", - " normal = vec(P[2*(i-1)+1, s:e])\n", - " tangent = vec(P[2*(i-1)+2, s:e])\n", - " println(\"i = $i, normal = $normal, tangent = $tangent, dot = \", dot(normal, tangent))\n", - " plot([nodes[i][1], nodes[i][1]+normal[1]*0.5], [nodes[i][2], nodes[i][2]+normal[2]*0.5], \"-r\")\n", - " plot([nodes[i][1], nodes[i][1]+tangent[1]*0.5], [nodes[i][2], nodes[i][2]+tangent[2]*0.5], \"-b\")\n", - "end\n", - "ylim(-0.5, 1.0)\n", - "xlim(-0.5, 4.5)\n", - "axis(\"equal\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 0.4.2", - "language": "julia", - "name": "julia-0.4" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "0.4.2" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -}