From 589edaed6da44166e8e71c8d4872c3e93ec78478 Mon Sep 17 00:00:00 2001 From: nagelt Date: Sat, 1 Feb 2025 10:07:16 +0100 Subject: [PATCH] Nodal residuals --- nodal_flux_tests_1D.ipynb | 527 ++++++++++++++++++++++++++++++++++---- 1 file changed, 477 insertions(+), 50 deletions(-) diff --git a/nodal_flux_tests_1D.ipynb b/nodal_flux_tests_1D.ipynb index da61849..38170c2 100644 --- a/nodal_flux_tests_1D.ipynb +++ b/nodal_flux_tests_1D.ipynb @@ -19,14 +19,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import scipy as sp\n", - "from pypardiso import spsolve\n", + "#from pypardiso import spsolve\n", "\n", "#Some plot settings\n", "%run plot_functions/plot_settings.py" @@ -40,17 +40,17 @@ "\n", "## Divergence-free flow\n", "\n", - "Consider a linear concentration gradient of $\\nabla c = -1$ on $x \\in [0,1]$ for $v = 1$ and $D = 1$. We calculate nodal contributions based on the following terms (no units for the moment):\n", + "Consider a linear concentration gradient of $\\nabla c = 1$ on $x \\in [0,1]$ for $v = 1$ and $D = 1$. We calculate nodal contributions based on the following terms (no units for the moment):\n", "\n", "\\begin{align}\n", - " f_1 &= \\int \\limits_0^1 \\nabla N v c \\text{d}x\n", + " f_1 &= \\int \\limits_0^1 \\nabla N^\\text{T} v c \\text{d}x\n", " \\\\\n", - " f_2 &= \\int \\limits_0^1 N v \\nabla c \\text{d}x\n", + " f_2 &= \\int \\limits_0^1 N^\\text{T} v \\nabla c \\text{d}x\n", " \\\\\n", - " f_3 &= -\\int \\limits_0^1 \\nabla N v \\nabla c \\text{d}x\n", + " f_3 &= -\\int \\limits_0^1 \\nabla N^\\text{T} v \\nabla c \\text{d}x\n", "\\end{align}\n", "\n", - "$f_1$ is a treatment used for advection in total flux models, $f_2$ is motivated by the implementation of advection with substituted mass balance, $f_3$ for diffusion." + "$f_1$ is a treatment used for advection in models with total flux boundary conditions, $f_2$ is motivated by the implementation of advection with substituted mass balance (resulting in models with diffusive flux boundary conditions), $f_3$ for diffusion." ] }, { @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -187,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 50, "metadata": { "tags": [] }, @@ -197,24 +197,24 @@ "output_type": "stream", "text": [ "element order: 1\n", - "f_1: [-0.5 0.5]\n", - "f_2: [-0.5 -0.5]\n", + "Adv. total flow f_1: [-0.5 0.5]\n", + "Adv. compl. flow f_2: [-0.5 -0.5]\n", "f_1 + f_2: [-1. 0.]\n", - "f_3: [-1. 1.]\n", + "Diff. flow f_3: [-1. 1.]\n", "---\n", "\n", "element order: 2\n", - "f_1: [-0.83333333 0.66666667 0.16666667]\n", - "f_2: [-0.16666667 -0.66666667 -0.16666667]\n", + "Adv. total flow f_1: [-0.83333333 0.66666667 0.16666667]\n", + "Adv. compl. flow f_2: [-0.16666667 -0.66666667 -0.16666667]\n", "f_1 + f_2: [-1.00000000e+00 2.22044605e-16 -1.11022302e-16]\n", - "f_3: [-1. 0. 1.]\n", + "Diff. flow f_3: [-1. 0. 1.]\n", "---\n", "\n", "element order: 3\n", - "f_1: [-0.875 0.375 0.375 0.125]\n", - "f_2: [-0.125 -0.375 -0.375 -0.125]\n", - "f_1 + f_2: [-1.00000000e+00 -3.88578059e-16 4.44089210e-16 -1.38777878e-17]\n", - "f_3: [-1.00000000e+00 -7.77156117e-16 8.88178420e-16 1.00000000e+00]\n", + "Adv. total flow f_1: [-0.875 0.375 0.375 0.125]\n", + "Adv. compl. flow f_2: [-0.125 -0.375 -0.375 -0.125]\n", + "f_1 + f_2: [-1.00000000e+00 -4.99600361e-16 4.99600361e-16 -4.16333634e-17]\n", + "Diff. flow f_3: [-1.0000000e+00 -8.8817842e-16 8.8817842e-16 1.0000000e+00]\n", "---\n", "\n" ] @@ -229,10 +229,10 @@ " nconc = np.flip(ncoords)\n", " f1, f2, f3, f4 = test_assembler(elem,nconc,np.ones(len(nodes)))\n", " print(\"element order: \", i)\n", - " print(\"f_1: \", f1)\n", - " print(\"f_2: \", f2)\n", + " print(\"Adv. total flow f_1: \", f1)\n", + " print(\"Adv. compl. flow f_2: \", f2)\n", " print(\"f_1 + f_2: \", f1+f2)\n", - " print(\"f_3: \", f3)\n", + " print(\"Diff. flow f_3: \", f3)\n", " print(\"---\\n\")" ] }, @@ -240,11 +240,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Diffusion is always correctly quantified by $f_3$: 1 influx, 1 outflux, no internal fluxes in the domain.\n", + "Diffusion is always correctly quantified by $f_3$: 1 outflux, 1 influx, no internal fluxes in the domain.\n", "\n", - "Advection is approached (1 influx and 0 outflux) by $f_1$ as the element order increases, but some averaging remains also at higher order. Internal fluxes show the redistribution of mass from left to right.\n", + "Advection is approached (0 influx and 1 outflux) by $f_1$ as the element order increases, but some averaging remains also at higher order. Internal fluxes not balanced.\n", "\n", - "The sum $f_1 + f_2$ recovers the advective flux with expected values on the boundaries, without internal redistribution information." + "The sum $f_1 + f_2$ recovers the advective flux with expected values on the boundaries with balanced internal nodes." ] }, { @@ -253,12 +253,12 @@ "source": [ "## Divergent flux\n", "\n", - "Now we add a linear velocity profile with mean value of 1 and repeat the test." + "Now we add a linear velocity profile with mean value of 1 and repeat the test (resulting from a hydraulic sink, deformation or multidimensional flow)." ] }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 82, "metadata": { "tags": [] }, @@ -269,7 +269,7 @@ "array([1.25, 0.75])" ] }, - "execution_count": 109, + "execution_count": 82, "metadata": {}, "output_type": "execute_result" } @@ -282,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 83, "metadata": { "tags": [] }, @@ -292,27 +292,27 @@ "output_type": "stream", "text": [ "element order: 1\n", - "f_1: [-0.54166667 0.54166667]\n", - "f_2: [-0.54166667 -0.45833333]\n", - "f_1 + f_2: [-1.08333333 0.08333333]\n", - "f_1 + f_2 + f_4: [-1.25000000e+00 1.38777878e-16]\n", - "f_3: [-1. 1.]\n", + "Adv. total flow f_1: [-0.45833333 0.45833333]\n", + "Adv. compl. flow f_2: [0.54166667 0.45833333]\n", + "f_1 + f_2: [0.08333333 0.91666667]\n", + "f_1 + f_2 + f_4: [1.38777878e-16 7.50000000e-01]\n", + "Diff. flow f_3: [ 1. -1.]\n", "---\n", "\n", "element order: 2\n", - "f_1: [-0.95833333 0.83333333 0.125 ]\n", - "f_2: [-0.20833333 -0.66666667 -0.125 ]\n", - "f_1 + f_2: [-1.16666667e+00 1.66666667e-01 -1.24900090e-16]\n", - "f_1 + f_2 + f_4: [-1.25000000e+00 2.77555756e-16 -1.24900090e-16]\n", - "f_3: [-1. 0. 1.]\n", + "Adv. total flow f_1: [-0.20833333 -0.5 0.70833333]\n", + "Adv. compl. flow f_2: [0.20833333 0.66666667 0.125 ]\n", + "f_1 + f_2: [8.32667268e-17 1.66666667e-01 8.33333333e-01]\n", + "f_1 + f_2 + f_4: [ 8.32667268e-17 -2.77555756e-16 7.50000000e-01]\n", + "Diff. flow f_3: [ 1. 0. -1.]\n", "---\n", "\n", "element order: 3\n", - "f_1: [-1.04791667 0.58125 0.35625 0.11041667]\n", - "f_2: [-0.14791667 -0.43125 -0.31875 -0.10208333]\n", - "f_1 + f_2: [-1.19583333 0.15 0.0375 0.00833333]\n", - "f_1 + f_2 + f_4: [-1.25000000e+00 -1.94289029e-16 2.22044605e-16 -3.98986399e-17]\n", - "f_3: [-1.00000000e+00 -7.77156117e-16 8.88178420e-16 1.00000000e+00]\n", + "Adv. total flow f_1: [-0.13958333 -0.39375 -0.16875 0.70208333]\n", + "Adv. compl. flow f_2: [0.14791667 0.43125 0.31875 0.10208333]\n", + "f_1 + f_2: [0.00833333 0.0375 0.15 0.80416667]\n", + "f_1 + f_2 + f_4: [-2.77555756e-17 -3.33066907e-16 2.22044605e-16 7.50000000e-01]\n", + "Diff. flow f_3: [ 1.0000000e+00 8.8817842e-16 -8.8817842e-16 -1.0000000e+00]\n", "---\n", "\n" ] @@ -324,7 +324,83 @@ " nodes = np.linspace(0,i,i+1)\n", " ncoords = np.linspace(0,1,i+1)\n", " elem = line_element(i+1,ncoords,nodes)\n", - " nconc = np.flip(ncoords)\n", + " nconc = np.copy(ncoords)\n", + " f1, f2, f3, f4 = test_assembler(elem,nconc,np.ones(len(nodes))-(ncoords-0.5)*0.5)\n", + " print(\"element order: \", i)\n", + " print(\"Adv. total flow f_1: \", f1)\n", + " print(\"Adv. compl. flow f_2: \", f2)\n", + " print(\"f_1 + f_2: \", f1+f2)\n", + " print(\"f_1 + f_2 + f_4: \", f1+f2+f4)\n", + " print(\"Diff. flow f_3: \", f3)\n", + " print(\"---\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Der influx von 0 wird in Ordnung 2 erreicht, in 3 aber wieder verfehlt (dennoch eine Ordnung besser als im linearen Element. Im linearen Element hätten wir allerdings konstante Geschwindigkeit, wenn wir mit einem hydraulischen Potenzial an den Knoten arbeiten.). Der Outflux von 0.75 wird zunehmend besser approximiert, aber Unterschiede bleiben. Wenn man den Term verfollständigt um\n", + "\n", + "$$\n", + " f_4 = \\int \\limits_{0}^1 N c \\nabla v \\text{d}x\n", + "$$\n", + "\n", + "geht die Bilanz wieder auf. Im Standard FE allerdings nicht so easy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Konstante Konzentration" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "element order: 1\n", + "f_1: [-1. 1.]\n", + "f_2: [0. 0.]\n", + "f_1 + f_2: [-1. 1.]\n", + "f_1 + f_2 + f_4: [-1.25 0.75]\n", + "f_3: [0. 0.]\n", + "---\n", + "\n", + "element order: 2\n", + "f_1: [-1.16666667 0.33333333 0.83333333]\n", + "f_2: [0. 0. 0.]\n", + "f_1 + f_2: [-1.16666667 0.33333333 0.83333333]\n", + "f_1 + f_2 + f_4: [-1.25000000e+00 1.11022302e-16 7.50000000e-01]\n", + "f_3: [0. 0. 0.]\n", + "---\n", + "\n", + "element order: 3\n", + "f_1: [-1.1875 0.1875 0.1875 0.8125]\n", + "f_2: [ 1.18158086e-16 2.25034940e-16 -1.73910106e-16 -7.08224618e-17]\n", + "f_1 + f_2: [-1.1875 0.1875 0.1875 0.8125]\n", + "f_1 + f_2 + f_4: [-1.25000000e+00 -7.21644966e-16 4.99600361e-16 7.50000000e-01]\n", + "f_3: [ 7.28036757e-16 -6.83331972e-16 -7.63144335e-16 7.18439549e-16]\n", + "---\n", + "\n" + ] + } + ], + "source": [ + "ncoords = np.linspace(0,1,2)\n", + "v = np.ones(len(ncoords))-(ncoords-0.5)*0.5\n", + "v\n", + "#generate elements of order 1 to 5 and calculate fluxes\n", + "for i in range(1,4):\n", + " nodes = np.linspace(0,i,i+1)\n", + " ncoords = np.linspace(0,1,i+1)\n", + " elem = line_element(i+1,ncoords,nodes)\n", + " nconc = np.ones(i+1)\n", " f1, f2, f3, f4 = test_assembler(elem,nconc,np.ones(len(nodes))-(ncoords-0.5)*0.5)\n", " print(\"element order: \", i)\n", " print(\"f_1: \", f1)\n", @@ -339,13 +415,364 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Der outflux von 0 wird in Ordnung 2 erreicht, in 3 aber wieder verfehlt (dennoch eine Ordnung besser als im linearen Element. Im linearen Element hätten wir allerdings konstante Geschwindigkeit, wenn wir mit einem hydraulischen Potenzial an den Knoten arbeiten.). Der Influx von 1.25 wird zunehmend besser approximiert, aber Unterschiede bleiben. Wenn man den Term verfollständigt um\n", + "Erwartungsgemäß verschwinden die diffusiven Flüsse. Nur die (diffizile) Gesamtsumme passt zu den erwarteten advektiven Flüssen." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Wiederverwendung der Masseflüsse aus H" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In $H$ assemblieren wir bereits $\\nabla \\cdot \\vec{v} = 0$. Leaving gravity out of the picture and setting $k/\\mu = 1$ the standard implementation is (keep in mind that we have both volume flux and mass lux based implementations):\n", "\n", "$$\n", - " f_4 = \\int \\limits_{0}^1 N c \\nabla v \\text{d}x\n", + " f_\\text{M} = -\\int \\limits_0^1 \\nabla N^\\text{T} \\nabla p \\,\\text{d}x + \\int \\limits_0^1 N^\\text{T} r \\,\\text{d}x\n", "$$\n", "\n", - "geht die Bilanz wieder auf. Im Standard FE allerdings nicht so easy." + "mit dem Quellterm $r$." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "def test_assembler_HC(elem, c_nodes, p_nodes, r=0):\n", + " element_order = elem._line_element__nnodes\n", + " b_1 = np.zeros(element_order)\n", + " b_2 = np.zeros(element_order)\n", + " b_3 = np.zeros(element_order)\n", + " b_4 = np.zeros(element_order)\n", + " #z_nodes = elem._line_element__coords\n", + " for i in range(elem._line_element__quad_degree):\n", + " #local integration point coordinate\n", + " xi = elem._line_element__quad_points[i]\n", + " #shape function\n", + " N = shape_function(element_order,xi)\n", + " #gradient of shape function\n", + " dN_dX = grad_shape_function(elem,xi)\n", + " #determinant of Jacobian\n", + " detJ = np.abs(element_jacobian(elem,xi))\n", + " #integration weight\n", + " w = elem._line_element__quad_weights[i]\n", + "\n", + " #global integration point coordinate (for spatially varying properties)\n", + " grad_p = np.dot(dN_dX,p_nodes)\n", + " grad_c = np.dot(dN_dX,c_nodes)\n", + " #evaluation of local material/structural properties\n", + " #assembly of local RHS\n", + " b_3 -= dN_dX * grad_c * w * detJ\n", + " b_4 -= dN_dX * grad_p * w * detJ + N * r * w * detJ\n", + " return b_3, b_4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Linear pressure profile" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "element order: 1\n", + "f_diff: [ 1. -1.]\n", + "f_hyd: [-1. 1.]\n", + "f_adv = c * f_hyd: [-0. 1.]\n", + "---\n", + "\n", + "element order: 2\n", + "f_diff: [ 1. 0. -1.]\n", + "f_hyd: [-1. 0. 1.]\n", + "f_adv = c * f_hyd: [-0. 0. 1.]\n", + "---\n", + "\n", + "element order: 3\n", + "f_diff: [ 1.0000000e+00 8.8817842e-16 -8.8817842e-16 -1.0000000e+00]\n", + "f_hyd: [-1.0000000e+00 -8.8817842e-16 8.8817842e-16 1.0000000e+00]\n", + "f_adv = c * f_hyd: [-0.00000000e+00 -2.96059473e-16 5.92118946e-16 1.00000000e+00]\n", + "---\n", + "\n" + ] + } + ], + "source": [ + "#generate elements of order 1 to 5 and calculate fluxes\n", + "for i in range(1,4):\n", + " nodes = np.linspace(0,i,i+1)\n", + " ncoords = np.linspace(0,1,i+1)\n", + " elem = line_element(i+1,ncoords,nodes)\n", + " nconc = np.copy(ncoords)\n", + " npress = np.flip(ncoords)\n", + " f3, f4 = test_assembler_HC(elem,nconc,npress)\n", + " print(\"element order: \", i)\n", + " print(\"f_diff: \", f3)\n", + " print(\"f_hyd: \", f4)\n", + " print(\"f_adv = c * f_hyd: \", f4*nconc)\n", + " print(\"---\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Nonlinear pressure profile" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\begin{align*}\n", + " p_{,xx} &= r\n", + " \\\\\n", + " p_{,x} &= rx + c_1\n", + " \\\\\n", + " p &= \\frac{r}{2} x^2 + c_1 x + c_2\n", + " \\\\\n", + " \\text{RB } &:\n", + " \\\\\n", + " p(x = 0) &= 1 \\quad \\rightarrow \\quad c_2 = 1\n", + " \\\\\n", + " p(x = 1) &= 0 \\quad \\rightarrow \\quad c_1 = - \\left( 1 + \\frac{r}{2} \\right)\n", + " \\\\\n", + " p(x) &= \\frac{r}{2} x^2 - \\left( 1 + \\frac{r}{2} \\right) x + 1\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_sol = lambda x,r: r/2 * x**2 - (1+r/2)*x + 1\n", + "coords = np.linspace(0,1,100)\n", + "fig, ax = plt.subplots()\n", + "for r in [0,1,2]:\n", + " ax.plot(coords,p_sol(coords,r),label=\"r = %.1f\" %r)\n", + "ax.set_xlabel('$x$')\n", + "ax.set_ylabel('$p$')\n", + "ax.legend()\n", + "fig.tight_layout();" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r = 0.0. v left: 1.000000, v right: 1.000000\n", + "r = 1.0. v left: 1.500000, v right: 0.500000\n", + "r = 2.0. v left: 2.000000, v right: 0.000000\n", + "c left: 0, c right: 1\n" + ] + } + ], + "source": [ + "v_sol = lambda x,r: -r*x + (1+r/2)\n", + "for r in [0,1,2]:\n", + " print(\"r = %.1f. v left: %3f, v right: %3f\" %(r,v_sol(0,r),v_sol(1,r)))\n", + "\n", + "print(\"c left: 0, c right: 1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quellfrei" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "element order: 1\n", + "f_diff: [ 1. -1.]\n", + "f_hyd: [-1. 1.]\n", + "f_adv = c * f_hyd: [-0. 1.]\n", + "---\n", + "\n", + "element order: 2\n", + "f_diff: [ 1. 0. -1.]\n", + "f_hyd: [-1. 0. 1.]\n", + "f_adv = c * f_hyd: [-0. 0. 1.]\n", + "---\n", + "\n", + "element order: 3\n", + "f_diff: [ 1.0000000e+00 8.8817842e-16 -8.8817842e-16 -1.0000000e+00]\n", + "f_hyd: [-1.00000000e+00 -1.77635684e-15 8.88178420e-16 1.00000000e+00]\n", + "f_adv = c * f_hyd: [-0.00000000e+00 -5.92118946e-16 5.92118946e-16 1.00000000e+00]\n", + "---\n", + "\n" + ] + } + ], + "source": [ + "#generate elements of order 1 to 5 and calculate fluxes\n", + "r = 0\n", + "for i in range(1,4):\n", + " nodes = np.linspace(0,i,i+1)\n", + " ncoords = np.linspace(0,1,i+1)\n", + " elem = line_element(i+1,ncoords,nodes)\n", + " nconc = np.copy(ncoords)\n", + " npress = p_sol(ncoords,r)\n", + " f3, f4 = test_assembler_HC(elem,nconc,npress,r)\n", + " print(\"element order: \", i)\n", + " print(\"f_diff: \", f3)\n", + " print(\"f_hyd: \", f4)\n", + " print(\"f_adv = c * f_hyd: \", f4*nconc)\n", + " print(\"---\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quelle $r=1$" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "element order: 1\n", + "f_diff: [ 1. -1.]\n", + "f_hyd: [-1.5 0.5]\n", + "f_adv = c * f_hyd: [-0. 0.5]\n", + "---\n", + "\n", + "element order: 2\n", + "f_diff: [ 1. 0. -1.]\n", + "f_hyd: [-1.50000000e+00 2.22044605e-16 5.00000000e-01]\n", + "f_adv = c * f_hyd: [-0.00000000e+00 1.11022302e-16 5.00000000e-01]\n", + "---\n", + "\n", + "element order: 3\n", + "f_diff: [ 1.0000000e+00 8.8817842e-16 -8.8817842e-16 -1.0000000e+00]\n", + "f_hyd: [-1.50000000e+00 -1.55431223e-15 1.44328993e-15 5.00000000e-01]\n", + "f_adv = c * f_hyd: [-0.00000000e+00 -5.18104078e-16 9.62193288e-16 5.00000000e-01]\n", + "---\n", + "\n" + ] + } + ], + "source": [ + "#generate elements of order 1 to 5 and calculate fluxes\n", + "r = 1\n", + "for i in range(1,4):\n", + " nodes = np.linspace(0,i,i+1)\n", + " ncoords = np.linspace(0,1,i+1)\n", + " elem = line_element(i+1,ncoords,nodes)\n", + " nconc = np.copy(ncoords)\n", + " npress = p_sol(ncoords,r)\n", + " f3, f4 = test_assembler_HC(elem,nconc,npress,r)\n", + " print(\"element order: \", i)\n", + " print(\"f_diff: \", f3)\n", + " print(\"f_hyd: \", f4)\n", + " print(\"f_adv = c * f_hyd: \", f4*nconc)\n", + " print(\"---\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quelle r = 2" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "element order: 1\n", + "f_diff: [ 1. -1.]\n", + "f_hyd: [-2. 0.]\n", + "f_adv = c * f_hyd: [-0. 0.]\n", + "---\n", + "\n", + "element order: 2\n", + "f_diff: [ 1. 0. -1.]\n", + "f_hyd: [-2.00000000e+00 4.44089210e-16 -2.49800181e-16]\n", + "f_adv = c * f_hyd: [-0.00000000e+00 2.22044605e-16 -2.49800181e-16]\n", + "---\n", + "\n", + "element order: 3\n", + "f_diff: [ 1.0000000e+00 8.8817842e-16 -8.8817842e-16 -1.0000000e+00]\n", + "f_hyd: [-2.00000000e+00 -6.66133815e-16 5.55111512e-17 3.05311332e-16]\n", + "f_adv = c * f_hyd: [-0.00000000e+00 -2.22044605e-16 3.70074342e-17 3.05311332e-16]\n", + "---\n", + "\n" + ] + } + ], + "source": [ + "#generate elements of order 1 to 5 and calculate fluxes\n", + "r = 2\n", + "for i in range(1,4):\n", + " nodes = np.linspace(0,i,i+1)\n", + " ncoords = np.linspace(0,1,i+1)\n", + " elem = line_element(i+1,ncoords,nodes)\n", + " nconc = np.copy(ncoords)\n", + " npress = p_sol(ncoords,r)\n", + " f3, f4 = test_assembler_HC(elem,nconc,npress,r)\n", + " print(\"element order: \", i)\n", + " print(\"f_diff: \", f3)\n", + " print(\"f_hyd: \", f4)\n", + " print(\"f_adv = c * f_hyd: \", f4*nconc)\n", + " print(\"---\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die hydraulischen Knotenflüsse $\\mathbf{R}_\\text{H}$ entsprechen der analystischen Lösung. Die diffusiven Flüsse $\\mathbf{R}_\\text{Diff}$ ergeben sich korrekt aus $f_1$ (entsprechen Residuen von T in Implementierungen wie THM, TH, nicht aber HC). Die advektiven Flüsse ergeben sich jedoch entsprechend der erwarteten Lösung aus $\\mathbf{R}_\\text{Adv} = \\mathbf{c} \\odot \\mathbf{R}_\\text{H}$." ] } ],