ngstrefftz 0.3.2604.dev5__tar.gz → 0.3.2604.dev8__tar.gz

{ngstrefftz-0.3.2604.dev5 → ngstrefftz-0.3.2604.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ngstrefftz
-Version: 0.3.2604.dev5
+Version: 0.3.2604.dev8
 Summary: NGSTrefftz is an add-on to NGSolve for Trefftz methods.
 Author-Email: Paul Stocker <paul.stocker@univie.ac.at>
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)

{ngstrefftz-0.3.2604.dev5 → ngstrefftz-0.3.2604.dev8}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.2604.dev5'
-__version_tuple__ = version_tuple = (0, 3, 2604, 'dev5')
+__version__ = version = '0.3.2604.dev8'
+__version_tuple__ = version_tuple = (0, 3, 2604, 'dev8')
 
-__commit_id__ = commit_id = 'g2374c3cb2'
+__commit_id__ = commit_id = 'gfe72334f0'

{ngstrefftz-0.3.2604.dev5 → ngstrefftz-0.3.2604.dev8}/docs/index.rst

@@ -62,5 +62,6 @@ NGSTrefftz is an add-On to NGSolve for Trefftz methods.
    notebooks/embTrefftz-helm.ipynb
    notebooks/embTrefftz-adv.ipynb
    notebooks/embTrefftz-stokes.ipynb
+   notebooks/embTrefftz-ns.ipynb
    notebooks/tunfitted.ipynb
    notebooks/twavetents.ipynb

ngstrefftz-0.3.2604.dev8/docs/notebooks/embTrefftz-ns.ipynb

@@ -0,0 +1,443 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "00f2188c",
+   "metadata": {},
+   "source": [
+    "# Embedded Trefftz-DG: Navier-Stokes\n",
+    "\n",
+    "For the stationary incompressible Navier-Stokes equations,\n",
+    "\n",
+    "$$\n",
+    "-\\nu\\Delta u + (u\\cdot\\nabla)u + \\nabla p = f,\n",
+    "\\qquad\n",
+    "\\nabla\\cdot u = 0,\n",
+    "$$\n",
+    "\n",
+    "the nonlinear part is the convective velocity in $(u\\cdot\\nabla)u$. The\n",
+    "embedded Trefftz construction enters after linearization: freeze one velocity\n",
+    "field and solve an Oseen problem in a Trefftz space adapted to that frozen\n",
+    "operator.\n",
+    "\n",
+    "We use the following DG formulation\n",
+    "\n",
+    "$$\n",
+    "\\newcommand{\\jump}[1]{\\left[\\!\\left[#1\\right]\\!\\right]}\n",
+    "\\newcommand{\\avg}[1]{\\left\\{\\!\\left\\{#1\\right\\}\\!\\right\\}}\n",
+    "\\begin{aligned}\n",
+    "a_h^w((u,p),(v,q))\n",
+    "&=\n",
+    "\\nu\\int_{\\Omega}\\nabla u:\\nabla v\\,\\mathrm{d}x\n",
+    "-\n",
+    "\\int_{\\Omega}\n",
+    "\\left(\n",
+    "q\\,\\nabla\\cdot u\n",
+    "+\n",
+    "p\\,\\nabla\\cdot v\n",
+    "\\right)\n",
+    "\\,\\mathrm{d}x\n",
+    "\\\\\n",
+    "&\\quad\n",
+    "+\n",
+    "\\int_{\\Omega}\n",
+    "\\left(\n",
+    "(w\\cdot \\nabla u)\\cdot v\n",
+    "+\n",
+    "\\frac12(\\nabla\\cdot w)\\,u\\cdot v\n",
+    "\\right)\n",
+    "\\,\\mathrm{d}x\n",
+    "\\\\\n",
+    "&\\quad\n",
+    "-\n",
+    "\\int_{\\mathcal F_h^{\\mathrm{int}}}\n",
+    "\\left(\n",
+    "\\nu\\avg{\\nabla u}n\\cdot\\jump{v}\n",
+    "+\n",
+    "\\nu\\avg{\\nabla v}n\\cdot\\jump{u}\n",
+    "-\n",
+    "\\nu\\frac{\\alpha k^2}{h}\n",
+    "\\jump{u}\\cdot\\jump{v}\n",
+    "\\right)\n",
+    "\\,\\mathrm{d}s\n",
+    "\\\\\n",
+    "&\\quad\n",
+    "-\n",
+    "\\int_{\\mathcal F_h^{\\mathrm{int}}}\n",
+    "\\left(\n",
+    "\\avg{p}\\,n\\cdot\\jump{v}\n",
+    "-\n",
+    "\\avg{q}\\,n\\cdot\\jump{u}\n",
+    "\\right)\n",
+    "\\,\\mathrm{d}s\n",
+    "\\\\\n",
+    "&\\quad\n",
+    "+\n",
+    "\\int_{\\mathcal F_h^{\\mathrm{int}}}\n",
+    "\\left(\n",
+    "(\\avg{w}\\cdot n)\n",
+    "\\jump{u}\\cdot\\avg{v}\n",
+    "+\n",
+    "\\frac12(\\jump{w}\\cdot n)\n",
+    "\\avg{u\\cdot v}\n",
+    "\\right)\n",
+    "\\,\\mathrm{d}s\n",
+    "\\\\\n",
+    "&\\quad\n",
+    "+\\text{ suitable boundary terms}.\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa7ab7ae",
+   "metadata": {
+    "tags": [
+     "hide-input"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "from ngsolve import *\n",
+    "from netgen.occ import *\n",
+    "from ngstrefftz import *\n",
+    "from ngsolve.webgui import Draw\n",
+    "\n",
+    "def VLap(u, dim):\n",
+    "    hesse = u.Operator(\"hesse\")\n",
+    "    return CF(tuple(sum(hesse[i, j * (dim + 1)] for j in range(dim))for i in range(dim)))\n",
+    "\n",
+    "def SolveOseen(mesh,k,nu,rhs=None,wn=None,trefftz=True,ubnd=None,bndname=\".*\",inletname=None,alpha=50):\n",
+    "    if hasattr(wn, \"Operators\") and \"div\" in wn.Operators():\n",
+    "        divwn = div(wn)\n",
+    "    elif wn is not None:\n",
+    "        if mesh.dim == 2:\n",
+    "            divwn = wn[0].Diff(x) + wn[1].Diff(y)\n",
+    "        elif mesh.dim == 3:\n",
+    "            divwn = wn[0].Diff(x) + wn[1].Diff(y) + wn[2].Diff(z)\n",
+    "\n",
+    "    bint = 16\n",
+    "    if inletname is None:\n",
+    "        inletname = bndname\n",
+    "    solver = \"pardiso\"\n",
+    "    stab = 1e-7\n",
+    "\n",
+    "    V = VectorL2(mesh, order=k, dgjumps=True)\n",
+    "    Q = L2(mesh, order=k - 1, dgjumps=True)\n",
+    "    basefes = V * Q\n",
+    "\n",
+    "    n = specialcf.normal(mesh.dim)\n",
+    "    h = specialcf.mesh_size\n",
+    "\n",
+    "    if trefftz:\n",
+    "        Vs = VectorL2(mesh, order=k - 2)\n",
+    "        Qs = L2(mesh, order=k - 1)\n",
+    "        test_fes = Vs * Qs\n",
+    "        u, p = basefes.TrialFunction()[0:2]\n",
+    "        wu, wp = test_fes.TestFunction()[0:2]\n",
+    "        oseen_residual = -nu * VLap(u, mesh.dim) + grad(p)\n",
+    "        if wn is not None:\n",
+    "            oseen_residual += grad(u) * wn\n",
+    "        op = oseen_residual * wu * dx(bonus_intorder=bint)\n",
+    "        op += div(u) * wp * dx(bonus_intorder=bint)\n",
+    "\n",
+    "        emb = TrefftzEmbedding(op)\n",
+    "        fes = EmbeddedTrefftzFES(emb)\n",
+    "        if rhs is not None:\n",
+    "            upf = GridFunction(basefes)\n",
+    "            lop = rhs * wu * dx(bonus_intorder=bint)\n",
+    "            upf.vec.data = emb.GetParticularSolution(lop)\n",
+    "    else:\n",
+    "        fes = basefes\n",
+    "\n",
+    "    u, v = fes.TrialFunction()[0], fes.TestFunction()[0]\n",
+    "    p, q = fes.TrialFunction()[1], fes.TestFunction()[1]\n",
+    "\n",
+    "    def jump(v):\n",
+    "        return v - v.Other()\n",
+    "\n",
+    "    def mean(v):\n",
+    "        return 0.5 * (v + v.Other())\n",
+    "\n",
+    "    def mean2(u, v):\n",
+    "        return 0.5 * (u * v + u.Other() * v.Other())\n",
+    "\n",
+    "    a = BilinearForm(fes)\n",
+    "    def dgterms(u,p,v,q):\n",
+    "        a = nu * InnerProduct(grad(u), grad(v)) * dx\n",
+    "        a += nu * alpha * k**2 / h * jump(u) * jump(v) * dx(skeleton=True)\n",
+    "        a += nu * (-mean(grad(u)) * n * jump(v) - mean(grad(v)) * n * jump(u)) * dx(skeleton=True)\n",
+    "        a += nu * alpha * k**2 / h * u * v * ds(skeleton=True, definedon=mesh.Boundaries(bndname))\n",
+    "        a += nu * (-grad(u) * n * v - grad(v) * n * u) * ds(skeleton=True, definedon=mesh.Boundaries(bndname))\n",
+    "        a += (mean(p) * n * jump(v) + mean(q) * n * jump(u)) * dx(skeleton=True)\n",
+    "        a += (p * v * n + q * u * n) * ds(skeleton=True, definedon=mesh.Boundaries(bndname))\n",
+    "        a += (-div(u) * q - div(v) * p) * dx\n",
+    "        a += -stab * p * q * dx\n",
+    "        if wn is not None:\n",
+    "            a += (grad(u) * wn) * v * dx(bonus_intorder=bint)\n",
+    "            a += -mean(wn) * n * jump(u) * mean(v) * dx(skeleton=True, bonus_intorder=bint)\n",
+    "            a += 0.5 * divwn * u * v * dx(bonus_intorder=bint)\n",
+    "            a += -0.5 * jump(wn) * n * mean2(u, v) * dx(skeleton=True, bonus_intorder=bint)\n",
+    "            a += -0.5 * wn * n * u * v * ds(skeleton=True,bonus_intorder=bint,definedon=mesh.Boundaries(bndname),)\n",
+    "        return a\n",
+    "    a += dgterms(u,p,v,q)\n",
+    "\n",
+    "    f = LinearForm(fes)\n",
+    "    if rhs is not None:\n",
+    "        f += rhs * v * dx(bonus_intorder=bint)\n",
+    "    if ubnd is not None:\n",
+    "        f += nu * alpha * k**2 / h * ubnd * v * ds(skeleton=True,definedon=mesh.Boundaries(inletname),bonus_intorder=bint,)\n",
+    "        f += nu * (-grad(v) * n * ubnd) * ds(skeleton=True,definedon=mesh.Boundaries(inletname),bonus_intorder=bint,)\n",
+    "        f += q * ubnd * n * ds(skeleton=True,definedon=mesh.Boundaries(inletname),bonus_intorder=bint,)\n",
+    "        if wn is not None:\n",
+    "            f += -0.5 * wn * n * ubnd * v * ds(skeleton=True,definedon=mesh.Boundaries(inletname),bonus_intorder=bint,)\n",
+    "    if trefftz and rhs is not None:\n",
+    "        mupf = GridFunction(basefes)\n",
+    "        mupf.vec.data = -1*upf.vec\n",
+    "        muf = mupf.components[0]\n",
+    "        mpf = mupf.components[1]\n",
+    "        f += dgterms(muf, mpf, v, q)\n",
+    "\n",
+    "\n",
+    "    a.Assemble()\n",
+    "    f.Assemble()\n",
+    "\n",
+    "    gfu = GridFunction(fes)\n",
+    "    gfu.vec.data = a.mat.Inverse(inverse=solver) * f.vec\n",
+    "\n",
+    "    if trefftz:\n",
+    "        polygfu = GridFunction(basefes)\n",
+    "        polygfu.vec.data = emb.Embed(gfu.vec)\n",
+    "        gfu = GridFunction(basefes)\n",
+    "        if rhs is not None:\n",
+    "            gfu.vec.data = polygfu.vec + upf.vec\n",
+    "        else:\n",
+    "            gfu = polygfu\n",
+    "\n",
+    "    uh, ph = gfu.components[0:2]\n",
+    "\n",
+    "    return uh, ph, fes.ndof"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "14316319",
+   "metadata": {},
+   "source": [
+    "## Picard Linearization\n",
+    "\n",
+    "Given a velocity $w$, the Oseen operator is\n",
+    "\n",
+    "$$\n",
+    "\\mathcal O_w(u,p)\n",
+    "=\n",
+    "-\\nu\\Delta u\n",
+    "+ (w\\cdot\\nabla)u\n",
+    "+ \\nabla p,\n",
+    "\\qquad\n",
+    "\\nabla\\cdot u=0.\n",
+    "$$\n",
+    "\n",
+    "The Trefftz embedding uses as local operator.\n",
+    "\n",
+    "Picard iteration freezes the convection field at the previous velocity:\n",
+    "\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "\\mathcal O_{u^{m}}(u^{m+1},p^{m+1}) &= f,\\\\\n",
+    "\\nabla\\cdot u^{m+1} &= 0.\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "In each loop we solve the discrete problem with\n",
+    "\n",
+    "$$\n",
+    "(u\\cdot\\nabla)u\n",
+    "\\quad\\leadsto\\quad\n",
+    "(u^m\\cdot\\nabla)u^{m+1}.\n",
+    "$$\n",
+    "\n",
+    "The embedded Trefftz space is updated in each iteration step.\n",
+    "\n",
+    "```python\n",
+    "wn = None\n",
+    "for step in range(maxiter):\n",
+    "    uh, ph = solve_oseen(mesh, nu, wn=wn, trefftz=True)\n",
+    "    if wn is not None and norm(uh - wn) < tol:\n",
+    "        break\n",
+    "    wn = uh\n",
+    "```\n",
+    "\n",
+    "The next Oseen solve, and therefore the next embedded Trefftz space, is rebuilt for this new convection field.\n",
+    "\n",
+    "## Oseen Trefftz Space\n",
+    "\n",
+    "On one element $K$, start with the discontinuous polynomial trial space\n",
+    "\n",
+    "$$\n",
+    "V_h^k(K)\n",
+    "=\n",
+    "[\\mathbb P^k(K)]^d \\times \\mathbb P^{k-1}(K)\n",
+    "$$\n",
+    "\n",
+    "for velocity and pressure. The residual is tested in\n",
+    "\n",
+    "$$\n",
+    "Q_h^k(K)\n",
+    "=\n",
+    "[\\mathbb P^{k-2}(K)]^d \\times \\mathbb P^{k-1}(K).\n",
+    "$$\n",
+    "\n",
+    "For fixed convection $w$, the embedded Oseen Trefftz space is\n",
+    "\n",
+    "$$\n",
+    "\\mathbb T_{w,h}^k(K)\n",
+    "=\n",
+    "\\left\\{\n",
+    "(u_h,p_h)\\in V_h^k(K):\n",
+    "\\begin{array}{l}\n",
+    "\\left(-\\nu\\Delta u + (w\\cdot\\nabla)u + \\nabla p, v\\right)_K=0\\\\\n",
+    "(\\nabla\\cdot u,q)_K =0\n",
+    "\\end{array}\n",
+    "\\quad\\forall (v_h,q_h)\\in Q_h^k(K)\n",
+    "\\right\\},\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb7294b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mesh = Mesh(unit_square.GenerateMesh(maxh=0.45))\n",
+    "k = 3\n",
+    "nu = 1.0\n",
+    "wn = CF((1, 0))\n",
+    "\n",
+    "V = VectorL2(mesh, order=k, dgjumps=True)\n",
+    "Q = L2(mesh, order=k - 1, dgjumps=True)\n",
+    "base = V * Q\n",
+    "\n",
+    "R = VectorL2(mesh, order=k - 2) * L2(mesh, order=k - 1)\n",
+    "u, p = base.TrialFunction()[0:2]\n",
+    "v, q = R.TestFunction()[0:2]\n",
+    "\n",
+    "op = (-nu * VLap(u, mesh.dim) + grad(p) + grad(u) * wn) * v * dx(bonus_intorder=16)\n",
+    "op += div(u) * q * dx(bonus_intorder=16)\n",
+    "\n",
+    "emb = TrefftzEmbedding(op)\n",
+    "tfes = EmbeddedTrefftzFES(emb)\n",
+    "\n",
+    "print(f\"full Oseen polynomial dofs: {base.ndof}\")\n",
+    "print(f\"embedded Oseen Trefftz dofs: {tfes.ndof}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2fa0be92",
+   "metadata": {},
+   "source": [
+    "## Schäfer-Turek Benchmark\n",
+    "\n",
+    "We now run the DFG 2D-1 Schäfer-Turek flow in the channel with a circular obstacle,\n",
+    "\n",
+    "$$\n",
+    "\\Omega=(0,2.2)\\times(0,0.41)\\setminus B_{0.05}(0.2,0.2).\n",
+    "$$\n",
+    "\n",
+    "The inflow profile is parabolic,\n",
+    "\n",
+    "$$\n",
+    "u_{\\mathrm{in}}(y)\n",
+    "=\n",
+    "\\left(\n",
+    "\\frac{4U_{\\max}y(0.41-y)}{0.41^2},\n",
+    "0\n",
+    "\\right),\n",
+    "\\qquad\n",
+    "U_{\\max}=0.3,\n",
+    "\\qquad\n",
+    "\\nu=10^{-3}.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "de562684",
+   "metadata": {
+    "tags": [
+     "hide-input"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "def solve_ns(mesh,k=4,nu=0.001,ubnd=None,bndname=\"inlet|wall|cyl\",inletname=\"inlet\",maxiter=100,tol=1e-8,alpha=50,trefftz=True):\n",
+    "    wn = CF((0,0))\n",
+    "    uh_old = wn\n",
+    "\n",
+    "    for step in range(1, maxiter + 1):\n",
+    "        uh, ph, ndof = SolveOseen(mesh,k=k,nu=nu,wn=wn,trefftz=trefftz,ubnd=ubnd,bndname=bndname,inletname=inletname,alpha=alpha,)\n",
+    "        update = sqrt(Integrate(InnerProduct(uh - uh_old, uh - uh_old), mesh))\n",
+    "        print(f\"Step: {step}, residual: {update}\")\n",
+    "        if update < tol:\n",
+    "            return uh, ph, ndof, step\n",
+    "\n",
+    "        uh_old = uh\n",
+    "        wn = uh\n",
+    "\n",
+    "    return uh, ph, ndof, maxiter\n",
+    "\n",
+    "ubnd = CF((4 * .3 * y * (0.41 - y) / (0.41 * 0.41), 0))\n",
+    "shape = Rectangle(2.2, 0.41).Circle(0.2, 0.2, 0.05).Reverse().Face()\n",
+    "shape.edges.name = \"cyl\"\n",
+    "shape.edges.Min(X).name = \"inlet\"\n",
+    "shape.edges.Max(X).name = \"outlet\"\n",
+    "shape.edges.Min(Y).name = shape.edges.Max(Y).name = \"wall\"\n",
+    "mesh = Mesh(OCCGeometry(shape, dim=2).GenerateMesh(maxh=0.05)).Curve(4)\n",
+    "\n",
+    "with TaskManager():\n",
+    "    uh, ph, ndof, steps = solve_ns(mesh,k=4,ubnd=ubnd,trefftz=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fdbb7397",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Draw(Norm(uh), mesh, \"speed\");\n",
+    "Draw(ph - Integrate(ph, mesh) / Integrate(1, mesh), mesh, \"pressure\");"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "default_lexer": "ipython3"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{ngstrefftz-0.3.2604.dev5 → ngstrefftz-0.3.2604.dev8}/docs/notebooks/index.ipynb

@@ -39,10 +39,11 @@
     "9. [Notebook](embTrefftz-wave.ipynb) for the acoustic wave equation\n",
     "10. [Notebook](embTrefftz-adv.ipynb) for advection\n",
     "11. [Notebook](embTrefftz-stokes.ipynb) for the Stokes problem\n",
+    "12. [Notebook](embTrefftz-ns.ipynb) for the Navier-Stokes problem\n",
     "\n",
     "### Trefftz methods and ...\n",
-    "12. [Notebook](tunfitted.ipynb) presents the Trefftz method on unfitted geometries using *ngsxfem*.\n",
-    "13. [Notebook](twavetents.ipynb) shows how to use the Trefftz and quasi-Trefftz methods with tent-pitched meshes using *ngstents*."
+    "13. [Notebook](tunfitted.ipynb) presents the Trefftz method on unfitted geometries using *ngsxfem*.\n",
+    "14. [Notebook](twavetents.ipynb) shows how to use the Trefftz and quasi-Trefftz methods with tent-pitched meshes using *ngstents*."
    ]
   }
  ],

{ngstrefftz-0.3.2604.dev5 → ngstrefftz-0.3.2604.dev8}/docs/requirements.txt

@@ -23,4 +23,4 @@ numpy>=2.0.0
 scipy>=1.13.1
 webgui-jupyter-widgets>=0.2.35
 
-#xfem==2.1.2605
+xfem==2.1.2605

{ngstrefftz-0.3.2604.dev5 → ngstrefftz-0.3.2604.dev8}/src/embtrefftz.cpp

@@ -493,9 +493,9 @@ bool bfIsDefinedOnElement (const SumOfIntegrals &bf,
       if (icf->dx.vb != mesh_element.VB ())
         continue;
 
-      if (!icf->dx.definedonelements
-          || icf->dx.definedonelements->Test (mesh_element.Nr ()))
-        return true;
+      if (icf->dx.definedonelements
+          && !icf->dx.definedonelements->Test (mesh_element.Nr ()))
+        continue;
 
       if (icf->dx.definedon) // check region
         {
@@ -506,10 +506,14 @@ bool bfIsDefinedOnElement (const SumOfIntegrals &bf,
               const BitArray &definedon = reg.Mask ();
               size_t mat = ma->GetElIndex (mesh_element);
               if (mat >= definedon.Size ())
-                return false;
-              return definedon.Test (mat);
+                continue;
+              if (definedon.Test (mat))
+                return true;
+              continue;
             }
         }
+
+      return true;
     }
   return false;
 }