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 0000000..35e7727 Binary files /dev/null and b/geometry/2d_beam/2015-12-22-splitted-beam-mesh.png differ diff --git a/geometry/2d_beam/2d_beam.hdf b/geometry/2d_beam/2d_beam.hdf new file mode 100644 index 0000000..f5d63b3 Binary files /dev/null and b/geometry/2d_beam/2d_beam.hdf differ diff --git a/geometry/2d_beam/BEAM.med b/geometry/2d_beam/BEAM.med new file mode 100644 index 0000000..cc15adc Binary files /dev/null and b/geometry/2d_beam/BEAM.med differ diff --git a/notebooks/2015-11-23-2d-tie-contact.ipynb b/notebooks/2015-11-23-2d-tie-contact.ipynb index dc957db..69761a0 100644 --- a/notebooks/2015-11-23-2d-tie-contact.ipynb +++ b/notebooks/2015-11-23-2d-tie-contact.ipynb @@ -851,17 +851,1316 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Model 3: splitted beam, frictionless contact, small sliding" + "## Model 3: splitted beam, frictionless contact, small sliding\n", + "\n", + "Same model as above, now with sliding contact. " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], - "source": [] + "source": [ + "using JuliaFEM.Preprocess: parse_aster_med_file\n", + "using JuliaFEM.Core: PlaneStressLinearElasticityProblem, DirichletProblem,\n", + " get_connectivity, Quad4, Tri3, Seg2, LinearSolver,\n", + " update!, get_elements, BiorthogonalBasis" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Found 5 element sets: LOWER_TO_UPPER, RIGHT, UPPER_TO_LOWER, LEFT, LOAD\n" + ] + }, + { + "data": { + "text/plain": [ + "Dict{ASCIIString,Any} with 2 entries:\n", + " \"nodes\" => 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