ngstrefftz 0.3.2403.dev5__tar.gz → 0.3.2403.dev9__tar.gz

{ngstrefftz-0.3.2403.dev5/src/ngstrefftz.egg-info → ngstrefftz-0.3.2403.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ngstrefftz
-Version: 0.3.2403.dev5
+Version: 0.3.2403.dev9
 Summary: NGSTrefftz is an add-on to NGSolve for Trefftz methods.
 Home-page: https://github.com/PaulSt/ngstrefftz
 Author: Paul Stocker

{ngstrefftz-0.3.2403.dev5 → ngstrefftz-0.3.2403.dev9}/docs/index.rst

@@ -54,14 +54,14 @@ NGSTrefftz is an add-On to NGSolve for Trefftz methods.
    notebooks/index.ipynb
    notebooks/laplace.ipynb
    notebooks/helmholtz.ipynb
-   notebooks/tunfitted.ipynb
    notebooks/twave.ipynb
+   notebooks/qtelliptic.ipynb
    notebooks/qtwave.ipynb
-   notebooks/twavetents.ipynb
    notebooks/embTrefftz.ipynb
    notebooks/embTrefftz-poi.ipynb
    notebooks/embTrefftz-wave.ipynb
    notebooks/embTrefftz-helm.ipynb
    notebooks/embTrefftz-adv.ipynb
    notebooks/embTrefftz-stokes.ipynb
-
+   notebooks/tunfitted.ipynb
+   notebooks/twavetents.ipynb

{ngstrefftz-0.3.2403.dev5 → ngstrefftz-0.3.2403.dev9}/docs/notebooks/embTrefftz-wave.ipynb

@@ -271,7 +271,7 @@
     "    tgfu = GridFunction(fes)\n",
     "    tgfu.vec.data = PP*TU\n",
     "    \n",
-    "Draw(tgfu.components[0],clipping={\"z\":-1, \"dist\":-.11})"
+    "Draw(tgfu.components[0],clipping={\"z\":-1, \"dist\":-.11, \"function\":True})"
    ]
   },
   {
@@ -302,7 +302,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

{ngstrefftz-0.3.2403.dev5 → ngstrefftz-0.3.2403.dev9}/docs/notebooks/index.ipynb

@@ -25,20 +25,24 @@
     "1. [Notebook](laplace.ipynb) introduces the Trefftz space in NGSolve alongside a Trefftz-DG method using harmonic polynomials to solve the Laplace problem.\n",
     "2. [Notebook](helmholtz.ipynb) presents plane waves for the Helmholtz equation.\n",
     "3. [Notebook](twave.ipynb) presents the space-time DG Trefftz method for the acoustic wave equation on meshes Cartesian in time.\n",
-    "4. [Notebook](tunfitted.ipynb) presents the Trefftz method on unfitted geometries using ngsxfem.\n",
     "\n",
-    "### Advanced Trefftz methods for the acoustic wave equation\n",
     "\n",
+    "### Quasi-Trefftz methods\n",
+    "\n",
+    "4. [Notebook](qtelliptic.ipynb) presents the quasi-Trefftz DG method for the diffusion-advection-reaction equation with piecewise-smooth coefficients and right-hand side.\n",
     "5. [Notebook](qtwave.ipynb) presents quasi-Trefftz functions that are used for the wave equation with piecewise-smooth wavespeed.\n",
-    "6. [Notebook](twavetents.ipynb) shows how to use the Trefftz and quasi-Trefftz methods with tent-pitched meshes.\n",
     "\n",
     "### Embedded Trefftz methods\n",
-    "7. [Notebook](embTrefftz.ipynb) presents the embedded Trefftz method\n",
-    "8. [Notebook](embTrefftz-poi.ipynb) for inhomogeneous problems\n",
-    "9. [Notebook](embTrefftz-helm.ipynb) for the Helmholtz problem\n",
-    "10. [Notebook](embTrefftz-wave.ipynb) for the acoustic wave equation\n",
-    "11. [Notebook](embTrefftz-adv.ipynb) for advection\n",
-    "12. [Notebook](embTrefftz-stokes.ipynb) for the Stokes problem"
+    "6. [Notebook](embTrefftz.ipynb) presents the embedded Trefftz method\n",
+    "7. [Notebook](embTrefftz-poi.ipynb) for inhomogeneous problems\n",
+    "8. [Notebook](embTrefftz-helm.ipynb) for the Helmholtz problem\n",
+    "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",
+    "\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*."
    ]
   }
  ],
@@ -58,7 +62,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

ngstrefftz-0.3.2403.dev9/docs/notebooks/qtelliptic.ipynb

@@ -0,0 +1,477 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1ffc608a-0a36-49c0-9a86-646e3b82ca20",
+   "metadata": {},
+   "source": [
+    "# Quasi-Treffz DG: diffusion-advection-reaction \n",
+    "Consider the following diffusion-advection-reaction BVP\n",
+    "$$\n",
+    "\\begin{cases}\n",
+    "\\mathcal{L}u:=\\text{div}(-\\boldsymbol{K} \\nabla u +\\boldsymbol{\\beta} u) +\\sigma u = f   &\\text{in $\\Omega$,}\\\\\n",
+    "u=g_{D} &\\text{on $ \\Gamma_{D}$,}\\\\\n",
+    "- \\boldsymbol{K} \\nabla u  \\cdot \\mathbf{n} =g_{N}  &\\text{on $ \\Gamma_{N}$.}\n",
+    "\\end{cases}\n",
+    "$$\n",
+    "with piecewise-smooth coefficients and right-hand side: $\\boldsymbol{K}=\\boldsymbol{K}^T$ diffusion matrix, $\\boldsymbol{\\beta}$ advection vector, $\\sigma$ reaction scalar and $ f$ source term.\n",
+    "\n",
+    "We want to solve this second-order elliptic boundary value problem using a quasi-Trefftz DG method."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1fa04d60-934b-4bbd-b2f5-52ca7fba48c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ngsolve import *\n",
+    "from ngstrefftz import *\n",
+    "from netgen.occ import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71d73d55-196f-4796-87ab-a94b6d3f550b",
+   "metadata": {},
+   "source": [
+    "### Constructing a polynomial quasi-Trefftz space"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39e67ca9-151b-489b-b588-60a52a081146",
+   "metadata": {},
+   "source": [
+    "A polynomial quasi-Trefftz space for the diffusion-advection-reaction equation is given by the polynomials that locally belong to\n",
+    "$$\n",
+    "\\mathbb{Q\\!T}^p_f(E):=\\big\\{ v\\in \\mathbb{P}^p(E) \\mid D^{\\boldsymbol{i}} \\mathcal{L} v (\\boldsymbol{x}^E)=D^{\\boldsymbol{i}} f (\\boldsymbol{x}^E)\\quad \\forall \\boldsymbol{i}\\in \\mathbb{N}^d_0,\\ |\\boldsymbol{i}|\\leq p-2\\big\\}\n",
+    "\\qquad \\boldsymbol{x}^E \\in E, \\quad p\\in \\mathbb{N}.\n",
+    "$$\n",
+    "\n",
+    "We can construct it in NGSolve like so:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4dacb2d-3787-4299-9180-87a120a0ee46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h = 0.03; \n",
+    "order = 3;\n",
+    "mesh = Mesh(unit_square.GenerateMesh(maxh=h))\n",
+    "SetNumThreads(4)\n",
+    "with TaskManager():\n",
+    "    fes = trefftzfespace(mesh,order=order,eq=\"qtelliptic\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54592f60-a42b-45f1-b4be-0a423a06f250",
+   "metadata": {},
+   "source": [
+    "Using the eq key word one needs to tell `trefftzfespace` the operator for which to construct quasi-Trefftz functions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf42df1e-83af-4b30-9288-e632262e0359",
+   "metadata": {},
+   "source": [
+    "We will consider the following manufactured example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21be3fa3-2e7d-4d0c-be17-6d48fea9b0a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exact = sin(pi*(x+y))\n",
+    "K = CF((1+x+y,0,0,1+x+y),dims=(2,2))\n",
+    "beta = CF((1,0))\n",
+    "sigma = 3/(1+x+y)\n",
+    "rhs = -sum( (K*CF((exact.Diff(x),exact.Diff(y))))[i].Diff(var) for i,var in enumerate([x,y])) + beta*CF((exact.Diff(x),exact.Diff(y))) + sigma*exact"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e26cef3-2c9c-4924-b0b3-45d59eb3cfd4",
+   "metadata": {},
+   "source": [
+    "To set the coefficients for the construction of the quasi-Trefftz basis functions of $ \\mathbb{Q\\!T}^p_0(\\mathcal{T}_h)$ use "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8bb5ff3b-4320-4374-aff9-eeaeb55c30e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with TaskManager():\n",
+    "    fes.SetCoeff(K,beta,sigma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9cc70f2-fbc9-4b39-a387-b9a86d5b4c1e",
+   "metadata": {},
+   "source": [
+    "To set the right-hand side for the construction of the quasi-Trefftz particular approximate solution $u_{h,f}\\in \\mathbb{Q\\!T}^p_f(\\mathcal{T}_h)$ use "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc5e2734-1c26-433f-89fc-e02808eb83e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with TaskManager():\n",
+    "    uf = fes.GetEWSolution(rhs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "33507b04-023b-4b33-9d1a-7d826df4d1b4",
+   "metadata": {},
+   "source": [
+    "A possbile DG method is: \n",
+    "$$\n",
+    "\\text{Find } u_{h} \\in \\mathbb{Q\\!T}^p_f(\\mathcal{T}_h) \\text{ such that }\n",
+    "\\mathcal{A}_h^\\mathrm{dar}(u_{h},v_h)=L_h(v_h) \\quad \\forall v_h \\in  \\mathbb{Q\\!T}^p_0(\\mathcal{T}_h),\n",
+    "$$\n",
+    "with the bilinear form \n",
+    "$$\\begin{align}\n",
+    "\\mathcal{A}_h^\\mathrm{dar}(u_h,v_h):=&\\sum_{E\\in \\mathcal{T}_h}\t\\int_E \\Big(\\Big(\\boldsymbol{K}\\nabla u_h -\\boldsymbol{\\beta} u_h\\Big) \\cdot \\nabla  v_h+\\sigma u_h  v_h\\Big)\\\\&+\n",
+    "\\sum_{F\\in\\mathcal{F}_h^{\\mathrm I}\\cup \\mathcal{F}_h^{\\mathrm D}}\n",
+    "\\int_F \\Big(-\\{\\!\\!\\{\\boldsymbol{K}   \\nabla u_h \\}\\!\\!\\} \\cdot [\\![v_h]\\!]- [\\![u_h]\\!] \\cdot \\{\\!\\!\\{\\boldsymbol{K}   \\nabla v_h \\}\\!\\!\\}\n",
+    "+ \\gamma\\frac{K_F}{h_F} [\\![u_h]\\!]\\cdot [\\![v_h]\\!]\\Big)\\\\ \n",
+    "&+\n",
+    "\\int_{\\mathcal{F}_h^{\\mathrm I}} \\Big( \\{\\!\\!\\{\\boldsymbol{\\beta} u_h\\}\\!\\!\\} \\cdot [\\![v_h]\\!]+\\frac12|\\boldsymbol{\\beta}\\cdot \\mathbf{n}_F|[\\![u_h]\\!]\\cdot[\\![v_h]\\!]\\Big)+\n",
+    "\\int_{\\mathcal{F}_h^+}  u_h\\boldsymbol{\\beta}   \\cdot \\mathbf{n} v_h,\n",
+    "\\end{align} $$\n",
+    "and the linear form\n",
+    "$$\n",
+    "L_h(v_h):=\\sum_{E\\in\\mathcal{T}_h}\\int_E  f v_h - \n",
+    "\\int_{\\mathcal{F}_h^\\mathrm{N}}  g_{\\mathrm N} v_h +\n",
+    "\\int_{\\mathcal{F}_h^{\\mathrm D}} g_{\\mathrm D}  \\Big(-\\boldsymbol{K}   \\nabla v_h  \\cdot \\mathbf{n}  + \\gamma\\frac{K_F}{h_F} v_h%-   \\bbeta  \\cdot \\mathbf{n} v_h\n",
+    "\\Big)\n",
+    "-\\int_{\\mathcal{F}_h^-}g_D\\boldsymbol{\\beta}\\cdot\\mathbf{n} v_h.\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "57ef0895-4638-4c4c-9c45-5669c4cc11ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def dgell(fes,K,beta=CF((0,0)),sigma=0,Dbndc=0,Dbnd=\".*\",Nbndc=0,Nbnd=\"\",rhs=0,uf=None,alpha=0):\n",
+    "    mesh = fes.mesh\n",
+    "    order = fes.globalorder\n",
+    "\n",
+    "    n = specialcf.normal(mesh.dim)\n",
+    "    h = specialcf.mesh_size\n",
+    "\n",
+    "    alpha = 50*order**2/h if alpha==0 else alpha\n",
+    "\n",
+    "    u = fes.TrialFunction()\n",
+    "    v = fes.TestFunction()\n",
+    "    jump = lambda u: (u-u.Other())*n\n",
+    "    mean_d = lambda u: 0.5 * K * (grad(u)+grad(u).Other())\n",
+    "    mean_B = lambda u: 0.5 * beta * (u+u.Other())\n",
+    "\n",
+    "    a = BilinearForm(fes)\n",
+    "    a += K*grad(u)*grad(v) * dx \\\n",
+    "        +alpha*jump(u)*jump(v) * dx(skeleton=True) \\\n",
+    "        +(-mean_d(u)*jump(v)-mean_d(v)*jump(u)) * dx(skeleton=True) \\\n",
+    "        +alpha*u*v * ds(skeleton=True,definedon=mesh.Boundaries(Dbnd)) \\\n",
+    "        +(-K*grad(u)*n*v-K*grad(v)*n*u)* ds(skeleton=True,definedon=mesh.Boundaries(Dbnd))\n",
+    "    a += (-beta*u*grad(v) + sigma*u*v) * dx \\\n",
+    "        + (mean_B(u) * jump(v) + 0.5*sqrt((beta*n)**2)*jump(u)*jump(v)) * dx(skeleton=True) \\\n",
+    "        + beta*u*n*v * ds(skeleton=True,definedon=mesh.Boundaries(Nbnd))\n",
+    "\n",
+    "    f = LinearForm(fes)\n",
+    "    f += Dbndc * (-K*grad(v)*n + alpha*v - beta*n*v) * ds(skeleton=True,definedon=mesh.Boundaries(Dbnd)) \\\n",
+    "         - Nbndc * v * ds(skeleton=True,definedon=mesh.Boundaries(Nbnd)) \\\n",
+    "         + rhs*v*dx\n",
+    "    if uf:\n",
+    "        f += -K*grad(uf)*grad(v) * dx \\\n",
+    "            -alpha*jump(uf)*jump(v) * dx(skeleton=True) \\\n",
+    "            -(-mean_d(uf)*jump(v)-mean_d(v)*jump(uf)) * dx(skeleton=True) \\\n",
+    "            -alpha*uf*v * ds(skeleton=True,definedon=mesh.Boundaries(Dbnd)) \\\n",
+    "            -(-K*grad(uf)*n*v-K*grad(v)*n*uf)* ds(skeleton=True,definedon=mesh.Boundaries(Dbnd))\n",
+    "        f += (beta*uf*grad(v) - sigma*uf*v) * dx \\\n",
+    "            - (mean_B(uf) * jump(v) + 0.5*sqrt((beta*n)**2)*jump(uf)*jump(v)) * dx(skeleton=True) \\\n",
+    "            - beta*uf*n*v * ds(skeleton=True,definedon=mesh.Boundaries(Nbnd))\n",
+    "\n",
+    "    with TaskManager():\n",
+    "        a.Assemble()\n",
+    "        f.Assemble()\n",
+    "\n",
+    "    return a,f"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "03ae6810-6716-4a63-bc52-b0be5326b54b",
+   "metadata": {},
+   "source": [
+    "Consider the previous manufactured example and obtain the approximate solution `gfu` "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c87a578-ac0d-4c84-99f4-1852916e8289",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Dbndc = exact\n",
+    "Dbnd = '.*'\n",
+    "Nbndc = 0\n",
+    "Nbnd = ''\n",
+    "\n",
+    "a,f = dgell(fes,K,beta,sigma,Dbndc=Dbndc,Dbnd=Dbnd,Nbnd=Nbnd,Nbndc=Nbndc,rhs=rhs,uf=uf)\n",
+    "gfu = GridFunction(fes)\n",
+    "\n",
+    "with TaskManager():\n",
+    "    gfu.vec.data = a.mat.Inverse()*f.vec"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0cbc4795-cb36-4129-8d76-c96091d8c443",
+   "metadata": {},
+   "source": [
+    "We can calculate the $L^2(\\Omega)$-error:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ff7a8109-3657-40a5-bfe1-ed08b8efbd5d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "error = sqrt(Integrate((gfu-exact)**2, mesh))\n",
+    "print(\"quasi-Trefftz DG error:\",error)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d9818abd-c055-4859-a2c6-2691bf77faa2",
+   "metadata": {},
+   "source": [
+    "We can plot the approximate solution like so:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "663ddaff-a1d8-4c9d-81c2-d264eca04376",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ngsolve.webgui import Draw\n",
+    "Draw(gfu,mesh,\"gfu\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a6c8846d-a388-4844-bd73-7f5ed01d6658",
+   "metadata": {},
+   "source": [
+    "### Advection-dominated example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0061d855-0ae6-4e19-8e3c-045ad2513653",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nu = 10**(-3)\n",
+    "K = CF((nu,0,0,nu),dims=(2,2))\n",
+    "beta = CF((y+1,-x+2))\n",
+    "sigma = 0\n",
+    "rhs = 0\n",
+    "uf = None\n",
+    "Dbndc = IfPos(IfPos(x-10**-10,0,1) + IfPos(y-10**-10,0,1)*IfPos(x-1/3,0,1) - 0.5, 1, 0)\n",
+    "Nbndc = 0\n",
+    "Dbnd = \"bottom|left\"\n",
+    "Nbnd = \"top|right\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83dfd9f8-69d5-4d65-8812-fc8822b77f15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with TaskManager():\n",
+    "    fes = trefftzfespace(mesh,order=order,eq=\"qtelliptic\")\n",
+    "    fes.SetCoeff(K,beta,sigma)\n",
+    "    \n",
+    "alpha = 100*nu/h\n",
+    "a,f = dgell(fes,K,beta,sigma,Dbndc=Dbndc,Dbnd=Dbnd,Nbnd=Nbnd,Nbndc=Nbndc,rhs=rhs,uf=uf,alpha=alpha)\n",
+    "gfu = GridFunction(fes)\n",
+    "with TaskManager():\n",
+    "    gfu.vec.data = a.mat.Inverse() * f.vec\n",
+    "Draw(gfu,mesh,\"gfu\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "128e02a2-5115-476c-8dbc-e83eeb8ba48d",
+   "metadata": {},
+   "source": [
+    "To see the 3D surface click `Open Controls` and select `deformation`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5548554-7123-49df-89a1-65928e6a30b7",
+   "metadata": {},
+   "source": [
+    "### Circular obstacle example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16c76b3b-c745-4aa1-86be-b9e6b4cc8334",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h = 0.05\n",
+    "wp = WorkPlane().RectangleC(2,2) \\\n",
+    "    .Circle(0,0,0.25).Reverse() \n",
+    "geo = wp.Face()\n",
+    "mesh = Mesh(OCCGeometry(geo,dim=2).GenerateMesh(maxh=h))\n",
+    "mesh.Curve(order)\n",
+    "mesh.ngmesh.SetBCName(0,\"top\")\n",
+    "mesh.ngmesh.SetBCName(1,\"bottom\")\n",
+    "mesh.ngmesh.SetBCName(2,\"left\")\n",
+    "mesh.ngmesh.SetBCName(3,\"right\")\n",
+    "mesh.ngmesh.SetBCName(4,\"innercircle\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aed18fb0-8d32-430c-8e60-2b8b233a2228",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "nu = 10**(-3)\n",
+    "K = CF((nu,0,0,nu),dims=(2,2))\n",
+    "beta = CF((1+1/16*(y**2-x**2)/((x**2+y**2)**2),-1/8*x*y/((x**2+y**2)**2)))\n",
+    "sigma = 0\n",
+    "Dbndc = IfPos(x+1/2,1,0)\n",
+    "Nbndc = 0\n",
+    "Dbnd=\"right|innercircle\"\n",
+    "Nbnd=\"left|top|bottom\"\n",
+    "rhs = 0\n",
+    "uf = None\n",
+    "\n",
+    "order = 3\n",
+    "with TaskManager():\n",
+    "    fes = trefftzfespace(mesh,order=order,eq=\"qtelliptic\")\n",
+    "    fes.SetCoeff(K,beta,sigma)\n",
+    "    alpha = nu*50*order/h\n",
+    "    a,f = dgell(fes,K,beta,sigma,Dbndc=Dbndc,Dbnd=Dbnd,Nbnd=Nbnd,Nbndc=Nbndc,rhs=rhs,uf=uf,alpha=alpha)\n",
+    "gfu = GridFunction(fes)\n",
+    "with TaskManager():\n",
+    "    gfu.vec.data = a.mat.Inverse() * f.vec\n",
+    "\n",
+    "Draw(gfu,mesh,\"gfu\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ebf21741-f21e-441d-9be7-432a32415cb3",
+   "metadata": {},
+   "source": [
+    "### L-shaped domain example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "31807cbc-c6c5-44a0-a809-490bb419de58",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "wp = WorkPlane()\n",
+    "wp.MoveTo(0,0.5).LineTo(0.5,0.5).LineTo(0.5,0).LineTo(1,0).LineTo(1,1).LineTo(0,1).Close()\n",
+    "geo = wp.Face()\n",
+    "h = 0.05\n",
+    "mesh = Mesh(OCCGeometry(geo,dim=2).GenerateMesh(maxh=h))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8de5679e-376f-495c-a7a0-f6b8d4184ee1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nu = 5*10**(-3)\n",
+    "K = CF((nu,0,0,nu),dims=(2,2))\n",
+    "beta = CF((-y,x))\n",
+    "sigma = 0\n",
+    "Dbndc = IfPos(y,0,1)\n",
+    "Dbnd = \".*\"\n",
+    "rhs = 0\n",
+    "uf = None\n",
+    "\n",
+    "order = 4\n",
+    "with TaskManager():\n",
+    "    fes = trefftzfespace(mesh,order=order,eq=\"qtelliptic\")\n",
+    "    fes.SetCoeff(K,beta,sigma)\n",
+    "    alpha = nu*50*order/h\n",
+    "    a,f = dgell(fes,K,beta,sigma,Dbndc=Dbndc,Dbnd=Dbnd,Nbnd=Nbnd,Nbndc=Nbndc,rhs=rhs,uf=uf,alpha=alpha)\n",
+    "  \n",
+    "gfu = GridFunction(fes)\n",
+    "with TaskManager():\n",
+    "    gfu.vec.data = a.mat.Inverse() * f.vec\n",
+    "Draw(gfu,mesh,\"gfu\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{ngstrefftz-0.3.2403.dev5 → ngstrefftz-0.3.2403.dev9}/docs/notebooks/qtwave.ipynb

@@ -210,7 +210,7 @@
     "    \n",
     "gfu = GridFunction(fes, name=\"uDG\")\n",
     "gfu.vec.data = a.mat.Inverse()*f.vec\n",
-    "Draw(gfu,clipping={\"z\":-1, \"dist\":-.33})"
+    "Draw(gfu,clipping={\"z\":-1, \"dist\":-.33, \"function\":True})"
    ]
   },
   {
@@ -240,7 +240,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

{ngstrefftz-0.3.2403.dev5 → ngstrefftz-0.3.2403.dev9}/src/condensedg.cpp

@@ -94,8 +94,10 @@ namespace ngcomp
                 }
 
             Array<int> els = GetElNeighbours (ma, ei);
-            for (auto elnr : els)
+            int nels = els.Size ();
+            for (int i = 0; i < nels; i++)
               {
+                int elnr = els[i];
                 dnums.SetSize0 ();
                 fes->GetDofNrs (ElementId (elnr), dnums, VISIBLE_DOF);
                 for (DofId d : dnums)
@@ -107,6 +109,7 @@ namespace ngcomp
                   {
                     if (elnr2 == ei.Nr () || els.Contains (elnr2))
                       continue;
+                    els.Append (elnr2);
                     dnums.SetSize0 ();
                     fes->GetDofNrs (ElementId (elnr2), dnums, VISIBLE_DOF);
                     for (DofId d : dnums)

{ngstrefftz-0.3.2403.dev5 → ngstrefftz-0.3.2403.dev9/src/ngstrefftz.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ngstrefftz
-Version: 0.3.2403.dev5
+Version: 0.3.2403.dev9
 Summary: NGSTrefftz is an add-on to NGSolve for Trefftz methods.
 Home-page: https://github.com/PaulSt/ngstrefftz
 Author: Paul Stocker

{ngstrefftz-0.3.2403.dev5 → ngstrefftz-0.3.2403.dev9}/src/ngstrefftz.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ docs/notebooks/embTrefftz.ipynb
 docs/notebooks/helmholtz.ipynb
 docs/notebooks/index.ipynb
 docs/notebooks/laplace.ipynb
+docs/notebooks/qtelliptic.ipynb
 docs/notebooks/qtwave.ipynb
 docs/notebooks/tunfitted.ipynb
 docs/notebooks/twave.ipynb