ddfem 0.9.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

ddfem/transformers/NNS.py

@@ -1,6 +1,6 @@
 from ufl import as_vector, conditional, dot, grad, sqrt, zero
 
-from .transformer_base import transformer
+from .transformer_base import transformer_base
 
 """
 Paper: using x^- = 1/2(x-|x|), x^+ = 1/2(x+|x|) so that x = x^+ + x^-, i.e., x^+ - x = - x^-
@@ -29,9 +29,18 @@ model = - ddm2.F_c(u).grad(v) - ddm2.S_e(u)v
 """
 
 
-@transformer
-def NDDM(Model):
+def NDDM(OriginalModel, domainDescription):
+    Model = transformer_base(OriginalModel, domainDescription)
+
     class DDModel(Model):
+        def sigma(t, x, U, DU=None):
+            if DU:
+                return DU
+            return grad(U)
+
+        # self.normal = grad(self.sign_dist)
+        # self.projection = self.x - self.sign_dist * self.normal
+
         def S_e_source(t, x, U, DU):
             return DDModel.phi(x) * Model.S_e(t, x, U, DDModel.sigma(t, x, U, DU))
 
@@ -51,11 +60,31 @@ def NDDM(Model):
             else:
                 convec = zero(U.ufl_shape)
 
-            convec -= DDModel.BT.BndFlux_cExt(t, x, U)
+            convec += DDModel.BT.BndFlux_cExt(t, x, U)
             return convec
 
-        def S_outside(t, x, U, DU):
-            return -(
+        if hasattr(Model, "S_e") and hasattr(Model, "F_c"):
+            print("NDDM: S_e and F_c")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_source(t, x, U, DU) + DDModel.S_e_convection(
+                    t, x, U, DU
+                )
+
+        elif hasattr(Model, "S_e"):
+            print("NDDM: S_e")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_source(t, x, U, DU)
+
+        elif hasattr(Model, "F_c"):
+            print("NDDM: F_c")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_convection(t, x, U, DU)
+
+        def S_i_stability(t, x, U, DU):
+            return -Model.stabFactor * (
                 DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**2)
             )
 
@@ -63,7 +92,7 @@ def NDDM(Model):
             return DDModel.phi(x) * Model.S_i(t, x, U, DDModel.sigma(t, x, U, DU))
 
         def S_i_diffusion(t, x, U, DU):
-            beta = 3 * (1 - DDModel.phi(x)) / (2 * DDModel.epsilon)
+            beta = 3 * (1 - DDModel.phi(x)) * Model.stabFactor / (2 * DDModel.epsilon)
             diffusion = beta * (
                 sqrt(dot(grad(DDModel.phi(x)), grad(DDModel.phi(x))))
                 * DDModel.BT.jumpV(t, x, U)
@@ -73,10 +102,42 @@ def NDDM(Model):
             diffusion += DDModel.BT.jumpFv(t, x, U, DU, Fv)
             return -diffusion
 
-        def F_c(t, x, U):
-            return DDModel.phi(x) * Model.F_c(t, x, U)
+        if hasattr(Model, "S_i") and hasattr(Model, "F_v"):
+            print("NDDM: S_i and F_v")
+
+            def S_i(t, x, U, DU):
+                return (
+                    DDModel.S_i_stability(t, x, U, DU)
+                    + DDModel.S_i_source(t, x, U, DU)
+                    + DDModel.S_i_diffusion(t, x, U, DU)
+                )
+
+        elif hasattr(Model, "F_v"):
+            print("NDDM: F_v")
+
+            def S_i(t, x, U, DU):
+                return DDModel.S_i_stability(t, x, U, DU) + DDModel.S_i_diffusion(
+                    t, x, U, DU
+                )
+
+        elif hasattr(Model, "S_i"):
+            print("NDDM: S_i")
+
+            def S_i(t, x, U, DU):
+                return DDModel.S_i_stability(t, x, U, DU) + DDModel.S_i_source(
+                    t, x, U, DU
+                )
+
+        if hasattr(Model, "F_c"):
+            print("NDDM: F_c")
+
+            def F_c(t, x, U):
+                return DDModel.phi(x) * Model.F_c(t, x, U)
+
+        if hasattr(Model, "F_v"):
+            print("NDDM: F_v")
 
-        def F_v(t, x, U, DU):
-            return DDModel.phi(x) * Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
+            def F_v(t, x, U, DU):
+                return DDModel.phi(x) * Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
 
     return DDModel

ddfem/transformers/NS.py

@@ -1,6 +1,6 @@
 from ufl import as_vector, conditional, dot, grad, outer, sqrt, zero
 
-from .transformer_base import transformer
+from .transformer_base import transformer_base
 
 """
 Paper: using x^- = 1/2(x-|x|), x^+ = 1/2(x+|x|) so that x = x^+ + x^-, i.e., x^+ - x = - x^-
@@ -29,9 +29,18 @@ model = - ddm2.F_c(u).grad(v) - ddm2.S_e(u)v
 """
 
 
-@transformer
-def NSDDM(Model):
+def NSDDM(OriginalModel, domainDescription):
+    Model = transformer_base(OriginalModel, domainDescription)
+
     class DDModel(Model):
+        def sigma(t, x, U, DU=None):
+            if DU:
+                return DU
+            return grad(U)
+
+        # self.normal = grad(self.sign_dist)
+        # self.projection = self.x - self.sign_dist * self.normal
+
         def S_e_source(t, x, U, DU):
             return DDModel.phi(x) * Model.S_e(t, x, U, DDModel.sigma(t, x, U, DU))
 
@@ -51,11 +60,31 @@ def NSDDM(Model):
             else:
                 convec = zero(U.ufl_shape)
 
-            convec -= DDModel.BT.BndFlux_cExt(t, x, U)
+            convec += DDModel.BT.BndFlux_cExt(t, x, U)
             return convec
 
-        def S_outside(t, x, U, DU):
-            return -(
+        if hasattr(Model, "S_e") and hasattr(Model, "F_c"):
+            print("NSDDM: S_e and F_c")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_source(t, x, U, DU) + DDModel.S_e_convection(
+                    t, x, U, DU
+                )
+
+        elif hasattr(Model, "S_e"):
+            print("NSDDM: S_e")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_source(t, x, U, DU)
+
+        elif hasattr(Model, "F_c"):
+            print("NSDDM: F_c")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_convection(t, x, U, DU)
+
+        def S_i_stability(t, x, U, DU):
+            return -DDModel.stabFactor * (
                 DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**2)
             )
 
@@ -63,7 +92,7 @@ def NSDDM(Model):
             return DDModel.phi(x) * Model.S_i(t, x, U, DDModel.sigma(t, x, U, DU))
 
         def S_i_diffusion(t, x, U, DU):
-            beta = 6 * (1 - DDModel.phi(x)) / DDModel.epsilon
+            beta = 6 * (1 - DDModel.phi(x)) * Model.stabFactor / DDModel.epsilon
             diffusion = beta * (
                 sqrt(dot(grad(DDModel.phi(x)), grad(DDModel.phi(x))))
                 * DDModel.BT.jumpV(t, x, U)
@@ -73,14 +102,50 @@ def NSDDM(Model):
             diffusion += DDModel.BT.jumpFv(t, x, U, DU, Fv)
             return -diffusion
 
-        def F_c(t, x, U):
-            return DDModel.phi(x) * Model.F_c(t, x, U)
+        if hasattr(Model, "S_i") and hasattr(Model, "F_v"):
+            print("NSDDM: S_i and F_v")
+
+            def S_i(t, x, U, DU):
+                return (
+                    DDModel.S_i_stability(t, x, U, DU)
+                    + DDModel.S_i_source(t, x, U, DU)
+                    + DDModel.S_i_diffusion(t, x, U, DU)
+                )
 
-        def F_v(t, x, U, DU):
-            diffusion = DDModel.phi(x) * Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
+        elif hasattr(Model, "F_v"):
+            print("NSDDM: F_v")
 
-            out = outer(DDModel.BT.jumpV(t, x, U), grad(DDModel.phi(x)))
-            diffusion += Model.F_v_lin_mult(t, x, U, DDModel.sigma(t, x, U, DU), out)
-            return diffusion
+            def S_i(t, x, U, DU):
+                return DDModel.S_i_stability(t, x, U, DU) + DDModel.S_i_diffusion(
+                    t, x, U, DU
+                )
+
+        elif hasattr(Model, "S_i"):
+            print("NSDDM: S_i")
+
+            def S_i(t, x, U, DU):
+                return DDModel.S_i_stability(t, x, U, DU) + DDModel.S_i_source(
+                    t, x, U, DU
+                )
+
+        if hasattr(Model, "F_c"):
+            print("NSDDM: F_c")
+
+            def F_c(t, x, U):
+                return DDModel.phi(x) * Model.F_c(t, x, U)
+
+        if hasattr(Model, "F_v"):
+            print("NSDDM: F_v")
+
+            def F_v(t, x, U, DU):
+                diffusion = DDModel.phi(x) * Model.F_v(
+                    t, x, U, DDModel.sigma(t, x, U, DU)
+                )
+
+                out = outer(DDModel.BT.jumpV(t, x, U), grad(DDModel.phi(x)))
+                diffusion += Model.F_v_lin_mult(
+                    t, x, U, DDModel.sigma(t, x, U, DU), out
+                )
+                return diffusion
 
     return DDModel

ddfem/transformers/__init__.py

@@ -3,4 +3,3 @@ from .Fitted import Fitted
 from .Mix0 import Mix0DDM
 from .NNS import NDDM
 from .NS import NSDDM
-from .transformer_base import transformer, posttransformer, pretransformer

ddfem/transformers/transformer_base.py

@@ -1,30 +1,22 @@
-from ufl import as_matrix, diff, dot, grad, inner, replace, variable, zero
+from ufl import as_matrix, diff, dot, inner, replace, variable, zero
 from ufl.algorithms.ad import expand_derivatives
 
 from ..boundary import BndFlux_c, BndFlux_v, BndValue, BoundaryTerms
 
 
-def pretransformer(Model, domainDescription):
+def transformer_base(Model, domainDescription):
     class DDBase(Model):
         BT = BoundaryTerms(Model, domainDescription)
         boundary = BT.physical
         domain = BT.domain
 
-        hasFlux_c = hasattr(Model, "F_c")
-        hasFlux_v = hasattr(Model, "F_v")
-        hasSource_i = hasattr(Model, "S_i")
-        hasSource_e = hasattr(Model, "S_e")
-
-        hasOutFactor_i = hasattr(Model, "outFactor_i")
-        hasOutFactor_e = hasattr(Model, "outFactor_e")
-
         if BT.BndValueExt is not None:
-            boundary[lambda x: DDBase.domain.chi(x) < 0.5] = BndValue(BT.BndValueExt)
-
-            assert (
-                hasOutFactor_i or hasOutFactor_e
-            ), "Dirichlet boundary requires the attribute outFactor_i or outFactor_e for outside term scaling"
+            boundary[lambda x: DDBase.domain.omega.chi(x) < 0.5] = BndValue(
+                BT.BndValueExt
+            )
         else:
+            hasFlux_c = hasattr(Model, "F_c")
+            hasFlux_v = hasattr(Model, "F_v")
 
             if hasFlux_c:
                 valFc = BndFlux_c(lambda t, x, U, n: -DDBase.BT.BndFlux_cExt(t, x, U))
@@ -38,18 +30,13 @@ def pretransformer(Model, domainDescription):
                 valN = valFc
             elif hasFlux_v:
                 valN = valFv
-            boundary[lambda x: DDBase.domain.chi(x) < 0.5] = valN
+            boundary[lambda x: DDBase.domain.omega.chi(x) < 0.5] = valN
 
         phi = domain.phi
         epsilon = domain.omega.epsilon
-        ep = domain.external_projection
+        ep = domain.omega.external_projection
 
-        def sigma(t, x, U, DU=None):
-            if DU:
-                return DU
-            return grad(U)
-
-        if hasSource_e:
+        if hasattr(Model, "S_e"):
 
             def S_e(t, x, U, DU):
                 return replace(
@@ -57,7 +44,7 @@ def pretransformer(Model, domainDescription):
                     {x: DDBase.ep(x)},
                 )
 
-        if hasSource_i:
+        if hasattr(Model, "S_i"):
 
             def S_i(t, x, U, DU):
                 return replace(
@@ -65,20 +52,20 @@ def pretransformer(Model, domainDescription):
                     {x: DDBase.ep(x)},
                 )
 
-        if hasFlux_c:
+        if hasattr(Model, "F_c"):
 
             def F_c(t, x, U):
-                # return Model.F_c(t, DDBase.ep(x), U)
+                return Model.F_c(t, DDBase.ep(x), U)
 
                 return replace(
                     expand_derivatives(Model.F_c(t, x, U)),
                     {x: DDBase.ep(x)},
                 )
 
-        if hasFlux_v:
+        if hasattr(Model, "F_v"):
 
             def F_v(t, x, U, DU):
-                # return Model.F_v(t, DDBase.ep(x), U, DU)
+                return Model.F_v(t, DDBase.ep(x), U, DU)
 
                 return replace(
                     expand_derivatives(Model.F_v(t, x, U, DU)),
@@ -137,77 +124,3 @@ def pretransformer(Model, domainDescription):
             )
 
     return DDBase
-
-
-def posttransformer(DDModel):
-    class DDM(DDModel):
-        if DDModel.hasSource_e or DDModel.hasFlux_c or DDModel.hasOutFactor_e:
-
-            def S_e(t, x, U, DU):
-                total = zero(U.ufl_shape)
-
-                if DDModel.hasOutFactor_e:
-                    total += DDModel.outFactor_e * DDModel.S_outside(t, x, U, DU)
-                if DDModel.hasSource_e:
-                    total += DDModel.S_e_source(t, x, U, DU)
-                if DDModel.hasFlux_c:
-                    total += DDModel.S_e_convection(t, x, U, DU)
-                return total
-
-        else:
-            try:
-                del DDModel.S_e
-            except AttributeError:
-                pass
-
-        if DDModel.hasSource_i or DDModel.hasFlux_v or DDModel.hasOutFactor_i:
-
-            def S_i(t, x, U, DU):
-                total = zero(U.ufl_shape)
-
-                if DDModel.hasOutFactor_i:
-                    total += DDModel.outFactor_i * DDModel.S_outside(t, x, U, DU)
-                if DDModel.hasSource_i:
-                    total += DDModel.S_i_source(t, x, U, DU)
-                if DDModel.hasFlux_v:
-                    total += DDModel.S_i_diffusion(t, x, U, DU)
-                return total
-
-        else:
-            try:
-                del DDModel.S_i
-            except AttributeError:
-                pass
-
-        if DDModel.hasFlux_c:
-
-            def F_c(t, x, U):
-                return DDModel.F_c(t, x, U)
-
-        else:
-            try:
-                del DDModel.F_c
-            except AttributeError:
-                pass
-
-        if DDModel.hasFlux_v:
-
-            def F_v(t, x, U, DU):
-                return DDModel.F_v(t, x, U, DU)
-
-        else:
-            try:
-                del DDModel.F_v
-            except AttributeError:
-                pass
-
-    return DDM
-
-
-def transformer(transformer):
-    def _transformer(OriginalModel, domainDescription):
-        PreModel = pretransformer(OriginalModel, domainDescription)
-        Model = transformer(PreModel)
-        return posttransformer(Model)
-
-    return _transformer

{ddfem-0.9.0.dist-info → ddfem-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddfem
-Version: 0.9.0
+Version: 1.0.0
 Summary: Diffuse domain finite element solver
 Author-email: Luke Benfield <luke.benfield@warwick.ac.uk>, Andreas Dedner <a.s.dedner@warwick.ac.uk>
 License-Expression: MIT
@@ -12,7 +12,6 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fenics-ufl>=2022
-Requires-Dist: numpy
 Dynamic: license-file
 
 # Diffuse Domain Finite Element Methods

ddfem-1.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+ddfem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ddfem/base_model.py,sha256=BJGMMTy-qa3CuYVJILwcZ4mtY8cVUtzFtn9NOm87IeE,6825
+ddfem/boundary.py,sha256=8PQp7LXlHxA8yn4bQbF_vLljKY4XezJbPkziX9o9IvU,7196
+ddfem/dune.py,sha256=oU4bKiG4AndEhMVhAi1Nnmo9cEhjceTW3X2ptv6ombU,67
+ddfem/model2ufl.py,sha256=PhbaLqJ4DS9EVKdi22f-iFxFsd97qsN-IYK0AU3a2is,4094
+ddfem/geometry/__init__.py,sha256=P4mAihoy07qck7_TI-4m6NlsEM0i4wvuC_Xuo7vxHCY,293
+ddfem/geometry/arc.py,sha256=r8l4zQonfgWzA37B3dVXaZ5UhHgkTXL-4KedVG0PWvk,1365
+ddfem/geometry/box.py,sha256=QwtqYVDmZE9CLWRUqNsmw58WqjvBtG0WBoFruuJZWVs,925
+ddfem/geometry/circle.py,sha256=prlh37BuPIYRxo1v56UAxa2-Os1YJXsNbOWGOOMkWX4,1049
+ddfem/geometry/domain.py,sha256=scATAs_0qkeDuIlQ6ejl2j4GSuOZt1sL3PpT_-6aBh0,1110
+ddfem/geometry/domain_dune.py,sha256=eR3MXlHAE0c9swUWAsNzPEzJyqHHtU2ZMvQDPd7JiCw,2112
+ddfem/geometry/helpers.py,sha256=iykom4lPPQwnInydnUux8dhL1IL5kfOzJvpjSKDGaUw,825
+ddfem/geometry/pie.py,sha256=3X2gv4AdEYCrl5Po089luULQ6TYptEJm1SVAZR1VPHI,993
+ddfem/geometry/primitive_base.py,sha256=d5vedYORVKfJKFQeAULAIJFalZYn5xcZncX93hPYDlc,8041
+ddfem/geometry/vesica.py,sha256=NseyI7SRxGkA_wmw503P25MD524IMhkh1ZEQgUddWFA,1702
+ddfem/transformers/DDM1.py,sha256=pKj0PaB7m7kyLu_iHu0ol9_KU_tHeAatxwDutqRSdks,2854
+ddfem/transformers/Fitted.py,sha256=XTE1U68RVfezC9ascdvEBYmd6F1pn8KW5mHws02Wxns,2550
+ddfem/transformers/Mix0.py,sha256=DUDFt7vUvhQgMlyYSptClTYkZ1jcS2mYbZXcoCy_0zs,5530
+ddfem/transformers/NNS.py,sha256=yeH-sk_p6BgjHo2rThGRoiCqNETnh6Tzc5KJEFEPuqU,5310
+ddfem/transformers/NS.py,sha256=LBno0zhDWc81Lv2yMvxM7YpbWqnrsVUC-t0q39_gZ0k,5604
+ddfem/transformers/__init__.py,sha256=46DtyvhBUqtrWGBfinekdz4ahjoHW4pd7sPL2vdR-Xs,120
+ddfem/transformers/transformer_base.py,sha256=ho7Gz_97dA4W_7Nj6UlSQLKMaAJhdBN_mOhsD1BArRU,3888
+ddfem-1.0.0.dist-info/licenses/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+ddfem-1.0.0.dist-info/METADATA,sha256=vSTe1NTH9Sleq5jIEkeDVgMVNl1TKWm2392KCsL2TnA,697
+ddfem-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ddfem-1.0.0.dist-info/top_level.txt,sha256=LF2T9-5A2Bak81PqbCcsAex8d5Xrla2Wq8yrlQi-ZtY,6
+ddfem-1.0.0.dist-info/RECORD,,

ddfem/examples/advection_diffusion.py

@@ -1,74 +0,0 @@
-from dune.ufl import Constant
-from ufl import as_vector, conditional, div, dot, grad, outer, sqrt
-
-from ddfem.boundary import BndFlux_c, BndFlux_v, BndValue
-
-
-def adModel(exact, D, withVelocity, inverted):
-    class Model:
-        solution = exact
-        dimRange = 1
-        diffFactor = Constant(D)
-
-        # this should probably be a vector of dimRange and then used by
-        # componentwise multiplication with (u-g):
-        outFactor_i = diffFactor
-
-        if withVelocity:
-
-            outFactor_e = 1
-
-        def diff(t, x):
-            return Model.diffFactor * (1 - 0.5 * dot(x, x))
-
-        def F_v(t, x, U, DU):
-            return Model.diff(t, x) * DU
-
-        if withVelocity:
-
-            def b(t, x):
-                return Constant([0.9, 0.5]) + 3 * as_vector([x[1], -x[0]])
-
-            def F_c(t, x, U):
-                return outer(U, Model.b(t, x))
-
-        if exact:
-
-            def S_i(t, x, U, DU):
-                return -div(Model.F_v(t, x, exact(t, x), grad(exact(t, x)))) + (
-                    exact(t, x) - U
-                )
-
-        if exact and withVelocity:
-
-            def S_e(t, x, U, DU):
-                return div(Model.F_c(t, x, exact(t, x)))
-
-        if exact:
-            valD = BndValue(lambda t, x: exact(t, x))
-            valFv = BndFlux_v(
-                lambda t, x, U, DU, n: Model.F_v(t, x, exact(t, x), grad(exact(t, x)))
-                * n
-            )
-
-            if withVelocity:
-                valFc = BndFlux_c(lambda t, x, U, n: Model.F_c(t, x, exact(t, x)) * n)
-                valN = [valFc, valFv]
-            else:
-                valN = valFv
-
-            boundary = {
-                "sides": valD,
-                "ends": valN,
-            }
-        else:
-            x0 = as_vector([-0.5, -0.5])
-            bnd = lambda x: conditional(dot(x - Model.x0, x - Model.x0) < 0.15, 10, 0)
-            valD = BndValue(lambda t, x, U: as_vector([Model.bnd(x)]))
-            boundary = {"full": valD}
-
-        if inverted:
-            for i in range(1, 5):
-                boundary[i] = valD
-
-    return Model

ddfem/examples/beam.py

@@ -1,147 +0,0 @@
-import numpy as np
-import pygmsh
-from dune.alugrid import aluConformGrid as leafGridView
-from dune.fem import adapt, mark, markNeighbors
-from dune.fem.function import gridFunction
-from dune.fem.space import lagrange
-from dune.fem.view import adaptiveLeafGridView
-from dune.grid import cartesianDomain
-from dune.ufl import Constant, Space
-from ufl import SpatialCoordinate, sqrt
-
-from ddfem import geometry as gm
-from ddfem.geometry.domain_dune import DomainDune
-
-
-def getDomain(initialRefine, version, adaptLevels=0, epsFactor=4.5, *args, **kwargs):
-
-    domain_range = [[-0.1, -0.1], [1.1, 0.25]]
-    initial_gridsize = [360 * 2**initialRefine, 105 * 2**initialRefine]
-    h = sqrt(
-        ((domain_range[1][0] - domain_range[0][0]) / initial_gridsize[0]) ** 2
-        + ((domain_range[1][1] - domain_range[0][1]) / initial_gridsize[1]) ** 2
-    )
-
-    def get_eps(h):
-        return Constant(epsFactor * h * 0.5 ** (adaptLevels / 2), "epsilon")
-
-    rectangles = [
-        [2, 1, [1, 0.075], "left"],
-        [2, 0.15, [0, 0.075], "other"],
-    ]
-
-    sdfs = [gm.Box(c[0], c[1], c[2], name=c[3]) for c in rectangles]
-    omega = sdfs[0] & sdfs[1]
-    omega.name = "full"
-
-    h_max = h * 3
-    h_min = h / 2
-    radius = 5
-
-    x = SpatialCoordinate(Space(2))
-    sdf = omega(x)
-
-    def spacing(x, y, epsilon):
-        r_min = epsilon.value
-        r_max = radius * epsilon.value
-        dist = np.abs(sdf((x, y)))
-        if dist <= r_min:
-            return geom.characteristic_length_min
-        elif dist >= r_max:
-            return geom.characteristic_length_max
-        else:
-            # Linear
-            m = (geom.characteristic_length_max - geom.characteristic_length_min) / (
-                r_max - r_min
-            )
-            return m * (dist - r_min) + geom.characteristic_length_min
-
-    if version == "cartesian":
-        domain = cartesianDomain(*domain_range, initial_gridsize)
-        epsilon = get_eps(h)
-
-    elif version == "fitted":
-        with pygmsh.occ.Geometry() as geom:
-            geom.characteristic_length_max = h_max
-            geom.characteristic_length_min = h_min
-            epsilon = get_eps(h_min)
-
-            rec = geom.add_rectangle([0, 0, 0], 1, 0.15)
-
-            geom.set_mesh_size_callback(
-                lambda dim, tag, x, y, z, lc: spacing(x, y, epsilon),
-                ignore_other_mesh_sizes=True,
-            )
-
-            mesh = geom.generate_mesh()
-            points, cells = mesh.points, mesh.cells_dict
-            domain = {
-                "vertices": points[:, :2].astype(float),
-                "simplices": cells["triangle"].astype(int),
-            }
-
-    elif version == "dune_adaptive":
-        gridsize = [int(j * h / h_max) for j in initial_gridsize]
-        domain = cartesianDomain(*domain_range, gridsize)
-
-    elif version == "gmsh_adaptive":
-        with pygmsh.occ.Geometry() as geom:
-            geom.characteristic_length_max = h_max
-            geom.characteristic_length_min = h_min
-            epsilon = get_eps(h_min)
-
-            geom.set_mesh_size_callback(
-                lambda dim, tag, x, y, z, lc: spacing(x, y, epsilon),
-                ignore_other_mesh_sizes=True,
-            )
-
-            geom.add_rectangle(
-                [domain_range[0][0], domain_range[0][1], 0.0],
-                domain_range[1][0] - domain_range[0][0],
-                domain_range[1][1] - domain_range[0][1],
-            )
-
-            mesh = geom.generate_mesh()
-            points, cells = mesh.points, mesh.cells_dict
-            domain = {
-                "vertices": points[:, :2].astype(float),
-                "simplices": cells["triangle"].astype(int),
-            }
-
-    else:
-        raise ValueError("invalid mesh type")
-
-    gridView = adaptiveLeafGridView(leafGridView(domain))
-
-    if version == "dune_adaptive":
-        omega.epsilon = get_eps(h_min)
-        omega.epsilon.value *= radius
-        epsilon_value = omega.epsilon.value
-
-        marker = mark
-
-        refinements = int(2 * np.log2(h_max / h_min))
-
-        region = gridFunction(
-            omega.phi(x) * (1 - omega.phi(x)), gridView=gridView
-        )  # interface
-
-        for j in range(1, refinements + 1):
-
-            omega.epsilon.value = epsilon_value * j / refinements
-            marker(region, 0.00247262315663, maxLevel=refinements)  # 1 epsilon
-
-            adapt(gridView.hierarchicalGrid)
-
-        h_min = h_max * 0.5 ** (j / 2)
-        epsilon = get_eps(h_min)
-
-    omega.propagate_epsilon(epsilon)
-    domain = omega
-
-    domain = DomainDune(omega, x, gridView)
-    # domain.adapt(level=adaptLevels)
-
-    print(f"h={h * 0.5 ** (adaptLevels / 2)}, epsilon={epsilon.value}")
-
-    return gridView, domain