From e3ffe6188ddad4e1fedba82f7d10a931c1906b00 Mon Sep 17 00:00:00 2001 From: Jukka Aho Date: Wed, 23 Dec 2015 17:39:53 +0200 Subject: [PATCH] frictionless 2d contact --- .../2d_beam/2015-12-22-splitted-beam-mesh.png | Bin 0 -> 6290 bytes geometry/2d_beam/2d_beam.hdf | Bin 0 -> 336615 bytes geometry/2d_beam/BEAM.med | Bin 0 -> 18181 bytes notebooks/2015-11-23-2d-tie-contact.ipynb | 1307 ++++++++++++++++- src/dirichlet.jl | 83 +- src/elements.jl | 4 + src/mortar.jl | 132 +- src/types.jl | 2 + test/test_dirichlet.jl | 96 +- 9 files changed, 1586 insertions(+), 38 deletions(-) create mode 100644 geometry/2d_beam/2015-12-22-splitted-beam-mesh.png create mode 100644 geometry/2d_beam/2d_beam.hdf create mode 100644 geometry/2d_beam/BEAM.med diff --git a/geometry/2d_beam/2015-12-22-splitted-beam-mesh.png b/geometry/2d_beam/2015-12-22-splitted-beam-mesh.png new file mode 100644 index 0000000000000000000000000000000000000000..35e7727d8d185959cc5fb932df38830e2c3836d7 GIT binary patch literal 6290 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 literal 0 HcmV?d00001 diff --git a/geometry/2d_beam/2d_beam.hdf b/geometry/2d_beam/2d_beam.hdf new file mode 100644 index 0000000000000000000000000000000000000000..f5d63b3d59832ae75c42b472beb379e08ee35860 GIT binary patch literal 336615 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 z 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 literal 0 HcmV?d00001 diff --git a/geometry/2d_beam/BEAM.med b/geometry/2d_beam/BEAM.med new file mode 100644 index 0000000000000000000000000000000000000000..cc15adc0da894b6bae00602465d6e7b7f4ed9e87 GIT binary patch literal 18181 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 SzBr%DQML2wyamoc3;Y+* Dict(68=>[71.42857142857142,9.999999999999998],2=>[95.0,-4.…\n", + " \"connectivity\" => Dict(11=>(:SE2,:OTHER,[11,12]),134=>(:TR3,:OTHER,[75,96,76]…" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mesh = parse_aster_med_file(Pkg.dir(\"JuliaFEM\")*\"/geometry/2d_beam/BEAM.med\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: created 104 field elements.\n", + "INFO: created 4 boundary elements.\n" + ] + } + ], + "source": [ + "field_problem = PlaneStressLinearElasticityProblem()\n", + "\n", + "# field problems\n", + "joo = Dict(:QU4 => Quad4, :TR3 => Tri3)\n", + "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype in keys(joo) || continue\n", + " element = joo[eltype](elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " element[\"youngs modulus\"] = 900.0\n", + " element[\"poissons ratio\"] = 0.25\n", + " push!(field_problem, element)\n", + "end\n", + "\n", + "# neumann boundary condition -1 on y direction\n", + "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == :LOAD || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " element[\"displacement traction force 2\"] = -1.0\n", + " push!(field_problem, element)\n", + "end\n", + "\n", + "# boundary conditions\n", + "boundary_problem = DirichletProblem(\"displacement\", 2; basis=BiorthogonalBasis)\n", + "\n", + "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == :LEFT || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " element[\"displacement\"] = 0.0\n", + " push!(boundary_problem, element)\n", + "end\n", + "\n", + "info(\"created $(length(get_elements(field_problem))) field elements.\")\n", + "info(\"created $(length(get_elements(boundary_problem))) boundary elements.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: # of master elements: 14\n", + "INFO: # of slave elements: 20\n" + ] + } + ], + "source": [ + "using JuliaFEM.Core: ContactProblem, SmallSlidingContact, Element,\n", + " calculate_normal_tangential_coordinates!\n", + "\n", + "mortar_surface = :UPPER_TO_LOWER\n", + "slave_surface = :LOWER_TO_UPPER\n", + "\n", + "master_elements = JuliaFEM.Core.Element[]\n", + "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == mortar_surface || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " push!(master_elements, element)\n", + "end\n", + "\n", + "contact_problem = ContactProblem(\"slider between two half-beams\", \"displacement\", 2;\n", + " contact_type=SmallSlidingContact)\n", + "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == slave_surface || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " element[\"master elements\"] = master_elements\n", + " calculate_normal_tangential_coordinates!(element, 0.0)\n", + " push!(contact_problem, element)\n", + "end\n", + "\n", + "info(\"# of master elements: $(length(master_elements))\")\n", + "info(\"# of slave elements: $(length(contact_problem.elements))\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Starting solver divided_beam_small_sliding_contact\n", + "INFO: # of field problems: 1\n", + "INFO: # of boundary problems: 2\n", + "INFO: Starting iteration 1\n", + "INFO: Assembling field problems...\n", + "INFO: Assembling body 1: plane stress linear elasticity\n", + "INFO: Assembly: 10.0 % done. \n", + "INFO: Assembly: 20.0 % done. \n", + "INFO: Assembly: 30.0 % done. \n", + "INFO: Assembly: 40.0 % done. \n", + "INFO: Assembly: 50.0 % done. \n", + "INFO: Assembly: 60.0 % done. \n", + "INFO: Assembly: 70.0 % done. \n", + "INFO: Assembly: 80.0 % done. \n", + "INFO: Assembly: 90.0 % done. \n", + "INFO: Assembly: 100.0 % done. \n", + "INFO: dim = 210\n", + "INFO: Assembling boundary problems...\n", + "INFO: Assembling boundary 1: dirichlet boundary\n", + "INFO: Assembling boundary 2: slider between two half-beams\n", + "INFO: slave dofs of element: [65,66,61,62]\n", + "INFO: normal dofs: [65]\n", + "INFO: tangent dofs: [61]\n", + "INFO: normal dofs: [66]\n", + "INFO: tangent dofs: [62]\n", + "INFO: normal dofs: [65]\n", + "INFO: tangent dofs: [61]\n", + "INFO: normal dofs: [66]\n", + "INFO: tangent dofs: [62]\n", + "INFO: normal dofs: [65]\n", + "INFO: tangent dofs: [61]\n", + "INFO: normal dofs: [66]\n", + "INFO: tangent dofs: [62]\n", + "INFO: normal dofs: [65]\n", + "INFO: tangent dofs: [61]\n", + "INFO: normal dofs: [66]\n", + "INFO: tangent dofs: [62]\n", + "INFO: normal dofs: [65]\n", + "INFO: tangent dofs: [61]\n", + "INFO: normal dofs: [66]\n", + "INFO: tangent dofs: [62]\n", + "INFO: slave dofs of element: [97,98,99,100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: normal dofs: [97]\n", + "INFO: tangent dofs: [99]\n", + "INFO: normal dofs: [98]\n", + "INFO: tangent dofs: [100]\n", + "INFO: slave dofs of element: [99,100,101,102]\n", + "INFO: normal dofs: [99]\n", + "INFO: tangent dofs: [101]\n", + "INFO: normal dofs: [100]\n", + "INFO: tangent dofs: [102]\n", + "INFO: normal dofs: [99]\n", + "INFO: tangent dofs: [101]\n", + "INFO: normal dofs: [100]\n", + "INFO: tangent dofs: [102]\n", + "INFO: normal dofs: [99]\n", + "INFO: tangent dofs: [101]\n", + "INFO: normal dofs: [100]\n", + "INFO: tangent dofs: [102]\n", + "INFO: normal dofs: [99]\n", + "INFO: tangent dofs: [101]\n", + "INFO: normal dofs: [100]\n", + "INFO: tangent dofs: [102]\n", + "INFO: normal dofs: [99]\n", + "INFO: tangent dofs: [101]\n", + "INFO: normal dofs: [100]\n", + "INFO: tangent dofs: [102]\n", + "INFO: slave dofs of element: [45,46,83,84]\n", + "INFO: normal dofs: [45]\n", + "INFO: tangent dofs: [83]\n", + "INFO: normal dofs: [46]\n", + "INFO: tangent dofs: [84]\n", + "INFO: normal dofs: [45]\n", + "INFO: tangent dofs: [83]\n", + "INFO: normal dofs: [46]\n", + "INFO: tangent dofs: [84]\n", + "INFO: normal dofs: [45]\n", + "INFO: tangent dofs: [83]\n", + "INFO: normal dofs: [46]\n", + "INFO: tangent dofs: [84]\n", + "INFO: normal dofs: [45]\n", + "INFO: tangent dofs: [83]\n", + "INFO: normal dofs: [46]\n", + "INFO: tangent dofs: [84]\n", + "INFO: normal dofs: [45]\n", + "INFO: tangent dofs: [83]\n", + "INFO: normal dofs: [46]\n", + "INFO: tangent dofs: [84]\n", + "INFO: slave dofs of element: [73,74,69,70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: normal dofs: [73]\n", + "INFO: tangent dofs: [69]\n", + "INFO: normal dofs: [74]\n", + "INFO: tangent dofs: [70]\n", + "INFO: slave dofs of element: [87,88,89,90]\n", + "INFO: normal dofs: [87]\n", + "INFO: tangent dofs: [89]\n", + "INFO: normal dofs: [88]\n", + "INFO: tangent dofs: [90]\n", + "INFO: normal dofs: [87]\n", + "INFO: tangent dofs: [89]\n", + "INFO: normal dofs: [88]\n", + "INFO: tangent dofs: [90]\n", + "INFO: normal dofs: [87]\n", + "INFO: tangent dofs: [89]\n", + "INFO: normal dofs: [88]\n", + "INFO: tangent dofs: [90]\n", + "INFO: normal dofs: [87]\n", + "INFO: tangent dofs: [89]\n", + "INFO: normal dofs: [88]\n", + "INFO: tangent dofs: [90]\n", + "INFO: normal dofs: [87]\n", + "INFO: tangent dofs: [89]\n", + "INFO: normal dofs: [88]\n", + "INFO: tangent dofs: [90]\n", + "INFO: slave dofs of element: [93,94,95,96]\n", + "INFO: normal dofs: [93]\n", + "INFO: tangent dofs: [95]\n", + "INFO: normal dofs: [94]\n", + "INFO: tangent dofs: [96]\n", + "INFO: normal dofs: [93]\n", + "INFO: tangent dofs: [95]\n", + "INFO: normal dofs: [94]\n", + "INFO: tangent dofs: [96]\n", + "INFO: normal dofs: [93]\n", + "INFO: tangent dofs: [95]\n", + "INFO: normal dofs: [94]\n", + "INFO: tangent dofs: [96]\n", + "INFO: normal dofs: [93]\n", + "INFO: tangent dofs: [95]\n", + "INFO: normal dofs: [94]\n", + "INFO: tangent dofs: [96]\n", + "INFO: normal dofs: [93]\n", + "INFO: tangent dofs: [95]\n", + "INFO: normal dofs: [94]\n", + "INFO: tangent dofs: [96]\n", + "INFO: slave dofs of element: [85,86,87,88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: normal dofs: [85]\n", + "INFO: tangent dofs: [87]\n", + "INFO: normal dofs: [86]\n", + "INFO: tangent dofs: [88]\n", + "INFO: slave dofs of element: [95,96,97,98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: normal dofs: [95]\n", + "INFO: tangent dofs: [97]\n", + "INFO: normal dofs: [96]\n", + "INFO: tangent dofs: [98]\n", + "INFO: slave dofs of element: [101,102,103,104]\n", + "INFO: normal dofs: [101]\n", + "INFO: tangent dofs: [103]\n", + "INFO: normal dofs: [102]\n", + "INFO: tangent dofs: [104]\n", + "INFO: normal dofs: [101]\n", + "INFO: tangent dofs: [103]\n", + "INFO: normal dofs: [102]\n", + "INFO: tangent dofs: [104]\n", + "INFO: normal dofs: [101]\n", + "INFO: tangent dofs: [103]\n", + "INFO: normal dofs: [102]\n", + "INFO: tangent dofs: [104]\n", + "INFO: normal dofs: [101]\n", + "INFO: tangent dofs: [103]\n", + "INFO: normal dofs: [102]\n", + "INFO: tangent dofs: [104]\n", + "INFO: normal dofs: [101]\n", + "INFO: tangent dofs: [103]\n", + "INFO: normal dofs: [102]\n", + "INFO: tangent dofs: [104]\n", + "INFO: slave dofs of element: [77,78,73,74]\n", + "INFO: normal dofs: [77]\n", + "INFO: tangent dofs: [73]\n", + "INFO: normal dofs: [78]\n", + "INFO: tangent dofs: [74]\n", + "INFO: normal dofs: [77]\n", + "INFO: tangent dofs: [73]\n", + "INFO: normal dofs: [78]\n", + "INFO: tangent dofs: [74]\n", + "INFO: normal dofs: [77]\n", + "INFO: tangent dofs: [73]\n", + "INFO: normal dofs: [78]\n", + "INFO: tangent dofs: [74]\n", + "INFO: normal dofs: [77]\n", + "INFO: tangent dofs: [73]\n", + "INFO: normal dofs: [78]\n", + "INFO: tangent dofs: [74]\n", + "INFO: normal dofs: [77]\n", + "INFO: tangent dofs: [73]\n", + "INFO: normal dofs: [78]\n", + "INFO: tangent dofs: [74]\n", + "INFO: slave dofs of element: [53,54,49,50]\n", + "INFO: normal dofs: [53]\n", + "INFO: tangent dofs: [49]\n", + "INFO: normal dofs: [54]\n", + "INFO: tangent dofs: [50]\n", + "INFO: normal dofs: [53]\n", + "INFO: tangent dofs: [49]\n", + "INFO: normal dofs: [54]\n", + "INFO: tangent dofs: [50]\n", + "INFO: normal dofs: [53]\n", + "INFO: tangent dofs: [49]\n", + "INFO: normal dofs: [54]\n", + "INFO: tangent dofs: [50]\n", + "INFO: normal dofs: [53]\n", + "INFO: tangent dofs: [49]\n", + "INFO: normal dofs: [54]\n", + "INFO: tangent dofs: [50]\n", + "INFO: normal dofs: [53]\n", + "INFO: tangent dofs: [49]\n", + "INFO: normal dofs: [54]\n", + "INFO: tangent dofs: [50]\n", + "INFO: slave dofs of element: [91,92,93,94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: normal dofs: [91]\n", + "INFO: tangent dofs: [93]\n", + "INFO: normal dofs: [92]\n", + "INFO: tangent dofs: [94]\n", + "INFO: slave dofs of element: [83,84,85,86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: normal dofs: [83]\n", + "INFO: tangent dofs: [85]\n", + "INFO: normal dofs: [84]\n", + "INFO: tangent dofs: [86]\n", + "INFO: slave dofs of element: [61,62,57,58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: normal dofs: [61]\n", + "INFO: tangent dofs: [57]\n", + "INFO: normal dofs: [62]\n", + "INFO: tangent dofs: [58]\n", + "INFO: slave dofs of element: [57,58,53,54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: normal dofs: [57]\n", + "INFO: tangent dofs: [53]\n", + "INFO: normal dofs: [58]\n", + "INFO: tangent dofs: [54]\n", + "INFO: slave dofs of element: [103,104,81,82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: normal dofs: [103]\n", + "INFO: tangent dofs: [81]\n", + "INFO: normal dofs: [104]\n", + "INFO: tangent dofs: [82]\n", + "INFO: slave dofs of element: [89,90,91,92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: normal dofs: [89]\n", + "INFO: tangent dofs: [91]\n", + "INFO: normal dofs: [90]\n", + "INFO: tangent dofs: [92]\n", + "INFO: slave dofs of element: [81,82,77,78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: normal dofs: [81]\n", + "INFO: tangent dofs: [77]\n", + "INFO: normal dofs: [82]\n", + "INFO: tangent dofs: [78]\n", + "INFO: slave dofs of element: [69,70,65,66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: normal dofs: [69]\n", + "INFO: tangent dofs: [65]\n", + "INFO: normal dofs: [70]\n", + "INFO: tangent dofs: [66]\n", + "INFO: Solving system\n", + "INFO: UMFPACK: solved in 0.33138203620910645 seconds. norm = 104.1324449731285\n", + "INFO: timing info for iteration:\n" + ] + }, + { + "data": { + "text/plain": [ + "(1,true)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: boundary assembly : 0.9452250003814697\n", + "INFO: field assembly : 1.2981817722320557\n", + "INFO: dump matrices to disk : 9.5367431640625e-7\n", + "INFO: solve problem : 0.45281195640563965\n", + "INFO: update element data : 0.022320985794067383\n", + "INFO: non-linear iteration : 2.7185611724853516\n", + "INFO: solver finished in 2.850562810897827 seconds.\n" + ] + } + ], + "source": [ + "using JuliaFEM.Core: DirectSolver\n", + "solver = DirectSolver()\n", + "solver.name = \"divided_beam_small_sliding_contact\"\n", + "solver.method = :UMFPACK\n", + "solver.nonlinear_problem = false\n", + "solver.max_iterations = 1\n", + "solver.dump_matrices = false\n", + "push!(solver, field_problem)\n", + "push!(solver, boundary_problem)\n", + "push!(solver, contact_problem)\n", + "call(solver, 0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: using PyPlot.mesh in module Main conflicts with an existing identifier.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "PyPlot.Figure(PyObject )" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "using PyPlot\n", + "\n", + "fig = figure(figsize=(15, 4))\n", + "for element in field_problem.elements\n", + " conn = get_connectivity(element)\n", + " X = element(\"geometry\", 0.0)\n", + " #info(X)\n", + " for i=1:length(X)\n", + " px1 = X[i][1]\n", + " py1 = X[i][2]\n", + " px2 = X[mod(i,length(X))+1][1]\n", + " py2 = X[mod(i,length(X))+1][2]\n", + " plot([px1, px2], [py1, py2], \"k-\")\n", + " end\n", + "end\n", + "for element in field_problem.elements\n", + " conn = get_connectivity(element)\n", + " X = element(\"geometry\", 0.0)\n", + " u = element(\"displacement\", 0.0)\n", + " x = X + u\n", + " #info(X)\n", + " for i=1:length(x)\n", + " px1 = x[i][1]\n", + " py1 = x[i][2]\n", + " px2 = x[mod(i,length(x))+1][1]\n", + " py2 = x[mod(i,length(x))+1][2]\n", + " plot([px1, px2], [py1, py2], \"r--\", alpha=0.5)\n", + " end\n", + "end\n", + "\n", + "#axis(\"equal\")\n", + "#axis(\"off\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "JuliaFEM.Core.BoundaryAssembly(JuliaFEM.Core.SparseMatrixCOO([65,61,65,61,65,61,65,61,66,62 … 69,65,70,66,70,66,70,66,70,66],[65,65,61,61,149,149,151,151,66,66 … 149,149,70,70,66,66,148,148,150,150],[1.04962,-0.485085,0.051661,-0.0238754,-0.844859,0.390455,-0.256418,0.118505,1.04962,-0.485085 … 0.0174914,-0.430652,-0.00571773,0.140775,-0.0121938,0.30022,0.000420114,-0.0103436,0.0174914,-0.430652]),JuliaFEM.Core.SparseMatrixCOO([65,65,65,65,66,66,66,66,65,65 … 70,70,69,69,69,69,70,70,70,70],[65,61,149,151,66,62,150,152,65,61 … 148,150,69,65,147,149,70,66,148,150],[0.485085,0.0238754,-0.390455,-0.118505,0.485085,0.0238754,-0.390455,-0.118505,0.283224,0.0849655 … 0.0639392,0.49021,-0.140775,-0.30022,0.0103436,0.430652,-0.140775,-0.30022,0.0103436,0.430652]),JuliaFEM.Core.SparseMatrixCOO([61,61,62,62,61,61,62,62,61,61 … 66,66,65,65,66,66,65,65,66,66],[65,61,66,62,65,61,66,62,65,61 … 70,66,69,65,70,66,69,65,70,66],[-1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0 … -1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0]),JuliaFEM.Core.SparseMatrixCOO(Int64[],Int64[],Float64[]))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "con = assemble(contact_problem, 0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0x0 sparse matrix with 0 Float64 entries:" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "C1 = sparse(con.C1)\n", + "C2 = sparse(con.C2)\n", + "D = sparse(con.D)\n", + "g = sparse(con.g)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "40x40 Array{Float64,2}:\n", + " 0.0 0.0 -5.0 0.0 … 0.0 0.0 0.0 0.0 0.0\n", + " 0.0 0.0 0.0 -5.0 0.0 0.0 0.0 0.0 0.0\n", + " 0.0 0.0 3.55271e-15 0.0 0.0 0.0 0.0 0.0 0.0\n", + " 0.0 0.0 0.0 3.55271e-15 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\n", + " 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\n", + " 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\n", + " 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\n", + " 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\n", + " ⋮ ⋱ ⋮ \n", + " 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\n", + " 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\n", + " 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\n", + " 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 … 3.55271e-15 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\n", + " 0.0 0.0 0.0 0.0 -5.0 0.0 0.0 0.0 0.0\n", + " 0.0 0.0 0.0 0.0 0.0 -5.0 0.0 0.0 0.0\n", + " 0.0 0.0 0.0 0.0 0.0 0.0 -5.0 0.0 0.0" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nz1 = sort(unique(rowvals(D)))\n", + "nz2 = sort(unique(rowvals(D')))\n", + "full(D[nz1,nz2])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Dict{Int64,Array{Float64,1}} with 7 entries:\n", + " 7 => [4.0,0.0]\n", + " 4 => [2.0,6.0]\n", + " 2 => [2.0,2.0]\n", + " 3 => [2.0,4.0]\n", + " 5 => [0.0,0.0]\n", + " 6 => [2.0,0.0]\n", + " 1 => [0.0,2.0]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using JuliaFEM.Core: Seg2, Tri3, Quad4, Node, update!,\n", + " calculate_normal_tangential_coordinates!, PlaneStressLinearElasticityProblem, \n", + " ContactProblem, SmallSlidingContact, Element\n", + "using JuliaFEM.Core: PlaneStressLinearElasticityProblem, DirichletProblem,\n", + " get_connectivity, Quad4, Tri3, Seg2, LinearSolver,\n", + " update!, get_elements, BiorthogonalBasis\n", + "nodes = Dict{Int64, Node}(\n", + " 1 => [0.0, 2.0],\n", + " 2 => [2.0, 2.0],\n", + " 3 => [2.0, 4.0],\n", + " 4 => [2.0, 6.0],\n", + " 5 => [0.0, 0.0],\n", + " 6 => [2.0, 0.0],\n", + " 7 => [4.0, 0.0])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "el1 = Quad4([5, 6, 2, 1])\n", + "el2 = Tri3([1, 2, 3])\n", + "el3 = Tri3([6, 7, 4])\n", + "del1 = Seg2([5, 6])\n", + "del2 = Seg2([6, 7])\n", + "sel1 = Seg2([3, 2])\n", + "sel2 = Seg2([2, 6])\n", + "mel1 = Seg2([6, 4])\n", + "update!([el1, el2, el3, sel1, sel2, mel1, del1, del2], \"geometry\", nodes)\n", + "for el in [el1, el2, el3]\n", + " el[\"youngs modulus\"] = 90.0\n", + " el[\"poissons ratio\"] = 0.25\n", + "end\n", + "for el in [del1, del2]\n", + " el[\"displacement\"] = 0.0\n", + "end\n", + "for el in [sel1, sel2]\n", + " el[\"master elements\"] = Element[mel1]\n", + " calculate_normal_tangential_coordinates!(el, 0.0)\n", + "end\n", + "prob = PlaneStressLinearElasticityProblem()\n", + "push!(prob, el1, el2, el3)\n", + "bc = DirichletProblem(\"displacement\", 2; basis=BiorthogonalBasis)\n", + "push!(bc, del1, del2)\n", + "con = ContactProblem(\"cont\", \"displacement\", 2;\n", + " contact_type=SmallSlidingContact)\n", + "push!(con, sel1, sel2);" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: slave dofs of element: [5,6,3,4]\n", + "INFO: normal dofs: [5]\n" + ] + }, + { + "data": { + "text/plain": [ + "JuliaFEM.Core.BoundaryAssembly(JuliaFEM.Core.SparseMatrixCOO([5,3,5,3,5,3,5,3,6,4 … 3,11,4,12,4,12,4,12,4,12],[5,5,3,3,11,11,7,7,6,6 … 7,7,4,4,12,12,12,12,8,8],[0.00955015,-0.0206644,0.194034,-0.419847,-0.132539,0.286786,-0.0710448,0.153725,0.00955015,-0.0206644 … 0.139949,-0.064678,-0.419847,0.194034,-0.0206644,0.00955015,0.300562,-0.138906,0.139949,-0.064678]),JuliaFEM.Core.SparseMatrixCOO([5,5,5,5,3,3,3,3,6,6 … 11,11,4,4,4,4,12,12,12,12],[5,3,11,7,5,3,11,7,6,4 … 11,7,4,12,12,8,4,12,12,8],[0.00955015,0.194034,-0.132539,-0.0710448,0.0206644,0.419847,-0.286786,-0.153725,0.00955015,0.194034 … 0.138906,0.064678,-0.419847,-0.0206644,0.300562,0.139949,-0.194034,-0.00955015,0.138906,0.064678]),JuliaFEM.Core.SparseMatrixCOO(Int64[],Int64[],Float64[]),JuliaFEM.Core.SparseMatrixCOO(Int64[],Int64[],Float64[]))" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: tangent dofs: [3]\n", + "INFO: normal dofs: [6]\n", + "INFO: tangent dofs: [4]\n", + "INFO: normal dofs: [5]\n", + "INFO: tangent dofs: [3]\n", + "INFO: normal dofs: [6]\n", + "INFO: tangent dofs: [4]\n", + "INFO: normal dofs: [5]\n", + "INFO: tangent dofs: [3]\n", + "INFO: normal dofs: [6]\n", + "INFO: tangent dofs: [4]\n", + "INFO: normal dofs: [5]\n", + "INFO: tangent dofs: [3]\n", + "INFO: normal dofs: [6]\n", + "INFO: tangent dofs: [4]\n", + "INFO: normal dofs: [5]\n", + "INFO: tangent dofs: [3]\n", + "INFO: normal dofs: [6]\n", + "INFO: tangent dofs: [4]\n", + "INFO: slave dofs of element: [3,4,11,12]\n", + "INFO: normal dofs: [3]\n", + "INFO: tangent dofs: [11]\n", + "INFO: normal dofs: [4]\n", + "INFO: tangent dofs: [12]\n", + "INFO: normal dofs: [3]\n", + "INFO: tangent dofs: [11]\n", + "INFO: normal dofs: [4]\n", + "INFO: tangent dofs: [12]\n", + "INFO: normal dofs: [3]\n", + "INFO: tangent dofs: [11]\n", + "INFO: normal dofs: [4]\n", + "INFO: tangent dofs: [12]\n", + "INFO: normal dofs: [3]\n", + "INFO: tangent dofs: [11]\n", + "INFO: normal dofs: [4]\n", + "INFO: tangent dofs: [12]\n", + "INFO: normal dofs: [3]\n", + "INFO: tangent dofs: [11]\n", + "INFO: normal dofs: [4]\n", + "INFO: tangent dofs: [12]\n" + ] + } + ], + "source": [ + "ass1 = assemble(prob, 0.0)\n", + "dbc = assemble(bc, 0.0)\n", + "cbc = assemble(con, 0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "12x12 Array{Float64,2}:\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\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\n", + " 0.0 0.0 -6.0 0.0 0.0 0.0 2.0 0.0 0.0 0.0 4.0 0.0\n", + " 0.0 0.0 0.0 -6.0 0.0 0.0 0.0 2.0 0.0 0.0 0.0 4.0\n", + " 0.0 0.0 0.0 0.0 -3.0 0.0 2.0 0.0 0.0 0.0 1.0 0.0\n", + " 0.0 0.0 0.0 0.0 0.0 -3.0 0.0 2.0 0.0 0.0 0.0 1.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\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\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\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\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\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" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ENV[\"COLUMNS\"] = 300\n", + "C1 = full(cbc.C1)*3\n", + "C1[abs(C1) .< 1.0e-9] = 0\n", + "C1" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "12x12 Array{Float64,2}:\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\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\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\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\n", + " 0.0 0.0 0.0 0.0 -3.0 0.0 2.0 0.0 0.0 0.0 1.0 0.0\n", + " 0.0 0.0 0.0 0.0 0.0 -3.0 0.0 2.0 0.0 0.0 0.0 1.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\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\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\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\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\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" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "C2 = full(cbc.C2)*3\n", + "C2[abs(C2) .< 1.0e-9] = 0\n", + "C2" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "12x12 Array{Float64,2}:\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\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\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\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\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\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\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\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\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\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\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\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" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "D = full(cbc.D, 12, 12)*3\n", + "D[abs(D) .< 1.0e-9] = 0\n", + "D" + ] } ], "metadata": { diff --git a/src/dirichlet.jl b/src/dirichlet.jl index ce01a2c..906d9bc 100644 --- a/src/dirichlet.jl +++ b/src/dirichlet.jl @@ -1,16 +1,18 @@ # This file is a part of JuliaFEM. # License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md -abstract DirichletProblem <: AbstractProblem +abstract DirichletProblem{T} <: AbstractProblem +abstract StandardBasis +abstract BiorthogonalBasis -function DirichletProblem(parent_field_name::ASCIIString, parent_field_dim::Int, dim::Int=1, elements=Element[]) - return BoundaryProblem{DirichletProblem}("dirichlet boundary", parent_field_name, parent_field_dim, dim, elements) +function DirichletProblem(parent_field_name::ASCIIString, parent_field_dim::Int, dim::Int=1, elements=Element[]; basis=StandardBasis) + return BoundaryProblem{DirichletProblem{basis}}("dirichlet boundary", parent_field_name, parent_field_dim, dim, elements) end -function DirichletProblem(problem_name::ASCIIString, parent_field_name::ASCIIString, parent_field_dim::Int, dim::Int=1, elements=Element[]) - return BoundaryProblem{DirichletProblem}(problem_name, parent_field_name, parent_field_dim, dim, elements) +function DirichletProblem(problem_name::ASCIIString, parent_field_name::ASCIIString, parent_field_dim::Int, dim::Int=1, elements=Element[]; basis=StandardBasis) + return BoundaryProblem{DirichletProblem{basis}}(problem_name, parent_field_name, parent_field_dim, dim, elements) end -function assemble!(assembly::BoundaryAssembly, problem::BoundaryProblem{DirichletProblem}, element::Element, time::Real) +function assemble!(assembly::BoundaryAssembly, problem::BoundaryProblem{DirichletProblem{StandardBasis}}, element::Element, time::Real) # get dimension and name of PARENT field field_dim = problem.parent_field_dim @@ -52,3 +54,72 @@ function assemble!(assembly::BoundaryAssembly, problem::BoundaryProblem{Dirichle end end +function assemble!(assembly::BoundaryAssembly, problem::BoundaryProblem{DirichletProblem{BiorthogonalBasis}}, element::Element, time::Real) + + # get dimension and name of PARENT field + field_dim = problem.parent_field_dim + field_name = problem.parent_field_name + gdofs = get_gdofs(element, field_dim) + + # calculate bi-orthogonal basis transformation matrix Ae + nnodes = size(element, 2) + De = zeros(nnodes, nnodes) + Me = zeros(nnodes, nnodes) + for ip in get_integration_points(element, Val{2}) + w = ip.weight + J = get_jacobian(element, ip, time) + JT = transpose(J) + if size(JT, 2) == 1 # plane problem + w *= norm(JT) + else + w *= norm(cross(JT[:,1], JT[:,2])) + end + N = element(ip, time) + De += w*diagm(vec(N)) + Me += w*N'*N + end + Ae = De*inv(Me) + + # do the actual integration + for ip in get_integration_points(element, Val{2}) + w = ip.weight + J = get_jacobian(element, ip, time) + JT = transpose(J) + if size(JT, 2) == 1 # plane problem + w *= norm(JT) + else + w *= norm(cross(JT[:,1], JT[:,2])) + end + N = element(ip, time) + Phi = (Ae*N')' + A = w*Phi'*N + A[abs(A) .< 1.0e-9] = 0 + + # C1 matrix is always the same + for i=1:field_dim + ldofs = gdofs[i:field_dim:end] + add!(assembly.C1, ldofs, ldofs, A) + end + + if haskey(element, field_name) + # add all dimensions at once if defined element["blaa"] = 0.0 + for i=1:field_dim + g = element(field_name, ip, time) + ldofs = gdofs[i:field_dim:end] + add!(assembly.C2, ldofs, ldofs, A) + add!(assembly.g, ldofs, w*g*Phi') + end + else + for i=1:field_dim + ldofs = gdofs[i:field_dim:end] + if haskey(element, field_name*" $i") + g = element(field_name*" $i", ip, time) + add!(assembly.C2, ldofs, ldofs, A) + add!(assembly.g, ldofs, w*g*Phi') + else + add!(assembly.D, ldofs, ldofs, A) + end + end + end + end +end diff --git a/src/elements.jl b/src/elements.jl index 3614e1a..7d5e17c 100644 --- a/src/elements.jl +++ b/src/elements.jl @@ -12,6 +12,10 @@ function Base.size{E}(::Element{E}) return size(E) end +function Base.size{E}(::Element{E}, i::Int64) + return size(E)[i] +end + function convert{E}(::Type{Element{E}}, connectivity::Vector{Int}) # return Element{E}(connectivity, get_integration_points(E), Dict()) return Element{E}(connectivity, Dict()) diff --git a/src/mortar.jl b/src/mortar.jl index 2cbc7b3..83859c2 100644 --- a/src/mortar.jl +++ b/src/mortar.jl @@ -658,7 +658,21 @@ function MortarProblem(problem_name::ASCIIString, parent_field_name::ASCIIString return BoundaryProblem{MortarProblem}(problem_name, parent_field_name, parent_field_dim, dim, elements) end -# Mortar assembly +abstract ContactProblem{T} <: AbstractProblem + +abstract AbstractContact +abstract TieContact <: AbstractContact +abstract SmallSlidingContact <: AbstractContact + +function ContactProblem(problem_name::ASCIIString, parent_field_name::ASCIIString, parent_field_dim::Int, dim::Int=1, elements=[]; contact_type=TieContact) + return BoundaryProblem{ContactProblem{contact_type}}( + problem_name, + parent_field_name, + parent_field_dim, + dim, elements) +end + +# Mortar assembly 2d typealias MortarElements2D Union{Seg2, Seg3} @@ -707,6 +721,122 @@ function assemble!{E<:MortarElements2D}(assembly::BoundaryAssembly, problem::Bou end end +""" Calculate bi-orthogonal basis transformation matrix Aₑ. """ +function get_biorthogonal_transformation_matrix(element::Element, time::Real) + nnodes = size(element, 2) + De = zeros(nnodes, nnodes) + Me = zeros(nnodes, nnodes) + for ip in get_integration_points(element, Val{5}) + w = ip.weight + J = get_jacobian(element, ip, time) + JT = transpose(J) + if size(JT, 2) == 1 # plane problem + w *= norm(JT) + else + w *= norm(cross(JT[:,1], JT[:,2])) + end + N = element(ip, time) + De += w*diagm(vec(N)) + Me += w*N'*N + end + Ae = De*inv(Me) + return Ae +end + +""" +Small strain theory, allow frictionless tangential sliding, keep bodies in contact. +""" +function assemble!{E<:MortarElements2D}(assembly::BoundaryAssembly, problem::BoundaryProblem{ContactProblem{SmallSlidingContact}}, slave_element::Element{E}, time::Real) + + # get dimension and name of PARENT field + field_dim = problem.parent_field_dim + field_name = problem.parent_field_name + slave_dofs = get_gdofs(slave_element, field_dim) + info("slave dofs of element: $slave_dofs") + + for master_element in slave_element["master elements"] + xi1a = project_from_master_to_slave(slave_element, master_element, [-1.0]) + xi1b = project_from_master_to_slave(slave_element, master_element, [ 1.0]) + xi1 = clamp([xi1a xi1b], -1.0, 1.0) + l = 1/2*(xi1[2]-xi1[1]) + abs(l) > 1.0e-9 || continue + +# Ae = get_biorthogonal_transformation_matrix(slave_element, time) + nnodes = size(element, 2) + De = zeros(nnodes, nnodes) + Me = zeros(nnodes, nnodes) + for ip_ in get_integration_points(slave_element, Val{5}) + xi_gauss = 1/2*(1-ip_.xi)*xi1[1] + 1/2*(1+ip_.xi)*xi1[2] + ip = IntegrationPoint(xi_gauss, ip_.weight) + w = ip.weight + J = get_jacobian(slave_element, ip, time) + JT = transpose(J) + if size(JT, 2) == 1 # plane problem + w *= norm(JT) + else + w *= norm(cross(JT[:,1], JT[:,2])) + end + N = element(ip, time) + De += w*diagm(vec(N)) + Me += w*N'*N + end + Ae = De*inv(Me) + + master_dofs = get_gdofs(master_element, field_dim) + for ip in get_integration_points(slave_element, Val{5}) + J = get_jacobian(slave_element, ip, time) + w = ip.weight*norm(J)*l + + # integration point on slave side segment + xi_gauss = 1/2*(1-ip.xi)*xi1[1] + 1/2*(1+ip.xi)*xi1[2] + # projected integration point + xi_projected = project_from_slave_to_master(slave_element, master_element, xi_gauss) + + # add contribution to C1 + N1 = slave_element(xi_gauss, time) + Phi = (Ae*N1')' + N2 = master_element(xi_projected, time) + S = w*Phi'*N1 + M = w*Phi'*N2 + for i=1:field_dim + sd = slave_dofs[i:field_dim:end] + md = master_dofs[i:field_dim:end] + add!(assembly.C1, sd, sd, S) + add!(assembly.C1, sd, md, -M) + end + + # construct C2 & D + nt = slave_element("normal-tangential coordinates", ip, time) + nt = transpose(nt) + ntS = nt*S + ntM = nt*M + info("normal dofs: $(slave_dofs[1:2:end])") + info("tangent dofs: $(slave_dofs[2:2:end])") + # contribution in normal direction + for dof in slave_dofs[1:2:end] + add!(assembly.C2, [dofs], sd, ntS[1,:]) + add!(assembly.C2, sd[1:2:end], md, -ntM[1,:]) + end + # contribution in tangent direction + add!(assembly.C2, sd[2:2:end], sd, ntS[2,:]) + add!(assembly.C2, sd[2:2:end], md, -ntM[2,:]) + # set lagrange multipliers to zero in tangent direction + #tangent = nt[2, :] + #add!(assembly.D, sd[2:2:end], sd, tangent) + end +#= + nt = transpose(nt) + normal = nt[1,:] + tangent = nt[2,:] + for nid in get_connectivity(slave_element) + ndofs = [2*(nid-1)+1, 2*(nid-1)+2] + add!(assembly.C2, [2*(nid-1)+1], ndofs, normal) + add!(assembly.D, [2*(nid-1)+2], ndofs, tangent) + end +=# + end + end +end typealias MortarElements3D Union{Tri3, Quad4} diff --git a/src/types.jl b/src/types.jl index cac08e1..05878ac 100644 --- a/src/types.jl +++ b/src/types.jl @@ -1,6 +1,8 @@ # This file is a part of JuliaFEM. # License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md +typealias Node Vector{Float64} + function ForwardDiff.derivative{T}(f::Function, S::Matrix{T}, args...) shape = size(S) wrapper(S::Vector) = f(reshape(S, shape)) diff --git a/test/test_dirichlet.jl b/test/test_dirichlet.jl index 18ff04a..381199f 100644 --- a/test/test_dirichlet.jl +++ b/test/test_dirichlet.jl @@ -4,64 +4,106 @@ module TestDirichletBoundaryCondition using JuliaFEM.Test -using JuliaFEM.Core: Tri3, Seg2, DirichletProblem, Assembly, assemble +using JuliaFEM.Core: Tri3, Seg2, DirichletProblem, Assembly, assemble, Node, + BiorthogonalBasis -function test_dirichlet_problem_1_dim() +@testset "test dirichlet boundary conditions" begin + +@testset "dirichlet problem in 1 dimension" begin element = Seg2([1, 2]) - element["geometry"] = Vector[[1.0, 1.0], [0.0, 1.0]] + element["geometry"] = Node[[1.0, 1.0], [0.0, 1.0]] element["temperature"] = 0.0 problem = DirichletProblem("temperature", 1) push!(problem, element) assembly = assemble(problem, 0.0) - A = full(assembly.stiffness_matrix) - b = full(assembly.force_vector) - @test isapprox(A, 1/6*[2 1; 1 2]) - @test isapprox(b, [0.0, 0.0]) + C1 = full(assembly.C1) + C2 = full(assembly.C2) + g = full(assembly.g) + @test isapprox(C1, C2) + @test isapprox(C1, 1/6*[2 1; 1 2]) + @test isapprox(g, [0.0, 0.0]) end -function test_dirichlet_problem_2_dim() +@testset "dirichlet problem in 2 dimensions" begin element = Seg2([1, 2]) - element["geometry"] = Vector[[1.0, 1.0], [0.0, 1.0]] + element["geometry"] = Node[[1.0, 1.0], [0.0, 1.0]] element["displacement"] = 0.0 problem = DirichletProblem("displacement", 2) push!(problem, element) assembly = assemble(problem, 0.0) - A = full(assembly.stiffness_matrix) - b = full(assembly.force_vector) - A_expected = 1/6*[2 0 1 0; 0 2 0 1; 1 0 2 0; 0 1 0 2] - @test isapprox(A, A_expected) - @test isapprox(b, [0.0, 0.0, 0.0, 0.0]) + C1 = full(assembly.C1) + C2 = full(assembly.C2) + g = full(assembly.g) + @test isapprox(C1, C2) + C1_expected = 1/6*[2 0 1 0; 0 2 0 1; 1 0 2 0; 0 1 0 2] + @test isapprox(C1, C1_expected) + @test isapprox(g, [0.0, 0.0, 0.0, 0.0]) end -function test_dirichlet_problem_2_dim_single_dof_fixed() +@testset "dirichlet problem in 2 dimensions, with 1 dof fixed" begin element = Seg2([1, 2]) - element["geometry"] = Vector[[1.0, 1.0], [0.0, 1.0]] + element["geometry"] = Node[[1.0, 1.0], [0.0, 1.0]] element["displacement 2"] = 0.0 problem = DirichletProblem("displacement", 2) push!(problem, element) assembly = assemble(problem, 0.0) - A = full(assembly.stiffness_matrix) - b = full(assembly.force_vector) - info(b) - info("A = \n$A") - A_expected = 1/6*[ + C1 = full(assembly.C1) + C2 = full(assembly.C2) + g = full(assembly.g) + @test isapprox(C1, C2) + C1_expected = 1/6*[ 0 0 0 0 0 2 0 1 0 0 0 0 0 1 0 2] - @test isapprox(A, A_expected) - @test isapprox(b, [0.0, 0.0, 0.0, 0.0]) + @test isapprox(C1, C1_expected) + @test isapprox(g, [0.0, 0.0, 0.0, 0.0]) end -function test_dirichlet_surface_tri3() +@testset "dirichlet problem using tri3 surface element" begin elem = Tri3([1, 2, 3]) - elem["geometry"] = Vector{Float64}[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]] + elem["geometry"] = Node[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]] elem["temperature"] = 0.0 prob = DirichletProblem("temperature", 1) push!(prob, elem) ass = assemble(prob, 0.0) - k = full(ass.stiffness_matrix) - @test isapprox(k, 1/24*[2 1 1; 1 2 1; 1 1 2]) + C1 = full(ass.C1) + C2 = full(ass.C2) + @test isapprox(C1, C2) + @test isapprox(C1, 1/24*[2 1 1; 1 2 1; 1 1 2]) +end + +@testset "dirichlet problem using biorthogonal basis" begin + elem = Tri3([1, 2, 3]) + elem["geometry"] = Node[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]] + elem["displacement 1"] = 1.0 + prob = DirichletProblem("displacement", 3; basis=BiorthogonalBasis) + push!(prob, elem) + ass = assemble(prob, 0.0) + C1 = full(ass.C1, 9, 9) + C2 = full(ass.C2, 9, 9) + D = full(ass.D, 9, 9) + g = full(ass.g, 9, 1) + C1_expected = eye(9)*1.0/6.0 + g_expected = zeros(9) + g_expected[1] = g_expected[4] = g_expected[7] = 1.0/6.0 + C2_expected = zeros(9, 9) + D_expected = zeros(9, 9) + C2_expected[1, 1] = 1.0/6.0 + D_expected[2, 2] = 1.0/6.0 + D_expected[3, 3] = 1.0/6.0 + C2_expected[4, 4] = 1.0/6.0 + D_expected[5, 5] = 1.0/6.0 + D_expected[6, 6] = 1.0/6.0 + C2_expected[7, 7] = 1.0/6.0 + D_expected[8, 8] = 1.0/6.0 + D_expected[9, 9] = 1.0/6.0 + @test isapprox(C1, C1_expected) + @test isapprox(C2, C2_expected) + @test isapprox(D, D_expected) + @test isapprox(g, g_expected) +end + end end