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

ddfem/transformers/Fitted.py

@@ -0,0 +1,77 @@
+from functools import reduce
+
+from ufl import conditional, eq, grad, min_value
+
+from ..boundary import BndFlux_c, BndFlux_v, BndValue, boundary_validation
+from ..geometry.domain import Domain
+from ..geometry.primitive_base import SDF
+from .transformer_base import pretransformer
+
+
+def Fitted(OriginalModel, domainDescription):
+
+    if isinstance(domainDescription, Domain):
+        domain = domainDescription
+    else:
+        domain = Domain(domainDescription)
+
+    condition = lambda k: isinstance(k, str) or isinstance(k, SDF)
+
+    class Fitted(OriginalModel):
+        def sigma(t, x, U, DU=None):
+            if DU:
+                return DU
+            return grad(U)
+
+        diffuse = {k: v for k, v in OriginalModel.boundary.items() if condition(k)}
+        boundary = {k: v for k, v in OriginalModel.boundary.items() if not condition(k)}
+
+        bndSDFs = {k: domain.bndSDFs(k) for k in diffuse.keys()}
+
+        boundary_flux_cs, boundary_flux_vs, boundary_values = boundary_validation(
+            OriginalModel, override_boundary_dict=diffuse
+        )
+
+        def make_boundary_function(key, mv, bndSDFs=bndSDFs):
+            sdf = bndSDFs[key]
+            closest_sdf = lambda x: reduce(
+                min_value,
+                ([abs(v(x)) for b, v in bndSDFs.items()]),
+            )
+
+            boundary_map = lambda x: conditional(eq(closest_sdf(x), abs(sdf(x))), 1, 0)
+
+            if isinstance(mv, BndFlux_v):
+                return BndFlux_v(
+                    lambda t, x, u, DU, n: boundary_map(x) * mv(t, x, u, DU, n),
+                )
+
+            elif isinstance(mv, BndFlux_c):
+                return BndFlux_c(
+                    lambda t, x, u, n: boundary_map(x) * mv(t, x, u, n),
+                )
+
+        def make_boundary_conditional(key, bndSDFs=bndSDFs, tol=1e-2):
+            sdf = bndSDFs[key]
+            return lambda x: abs(sdf(x)) < tol
+
+        for bc_key, bc_value in boundary_values.items():
+            boundary[make_boundary_conditional(bc_key)] = bc_value
+
+        for bc_key in boundary_flux_cs.keys() | boundary_flux_vs.keys():
+            if bc_key in boundary_flux_cs and bc_key in boundary_flux_vs:
+                af = make_boundary_function(bc_key, boundary_flux_cs[bc_key])
+                df = make_boundary_function(bc_key, boundary_flux_vs[bc_key])
+                boundary[make_boundary_conditional(bc_key)] = [af, df]
+
+            elif bc_key in boundary_flux_cs and bc_key not in boundary_flux_vs:
+                af = make_boundary_function(bc_key, boundary_flux_cs[bc_key])
+                boundary[make_boundary_conditional(bc_key)] = af
+
+            elif bc_key not in boundary_flux_cs and bc_key in boundary_flux_vs:
+                df = make_boundary_function(bc_key, boundary_flux_vs[bc_key])
+                boundary[make_boundary_conditional(bc_key)] = df
+            else:
+                raise ValueError()
+
+    return Fitted

ddfem/transformers/Mix0.py

@@ -0,0 +1,107 @@
+from ufl import grad, outer
+
+from .transformer_base import transformer
+
+"""
+Diffusion:
+Paper with sigma = grad(phi u) - grad(phi)g
+phi Asigma.(grad(phi v) + grad(phi)v) + 1/4 (Agrad(phi),grad(phi))(u-g)v
+= phi Asigma.(phi grad(v) + 2grad(phi)v) + 1/4 (Agrad(phi),grad(phi))(u-g)v
+= phi^2 Asigma.grad(v) + 2phi Asigma.grad(phi)v + 1/4 (Agrad(phi),grad(phi))(u-g)v
+
+orig.F_v(u,Du) = A Du
+orig.S_i(u,Du) = -div(ADg)
+
+mix0.F_v = phi^2 orig.F_v(u,sigma)
+mix0.S_i = phi^2 orig.S_i(u,sigma) - 2phi orig.F_v(u,sigma).grad(phi) - 1/4 F_v(u,grad(phi)(u-g)).grad(phi)
+
+model = mix0.F_v(u,Du).grad(v) - mix0.S_i(u,Du)v
+      = phi^2 Asigma.grad(v) + phi^2 div(ADg)v + 2phi Asigma.grad(phi)v + 1/4 Agrad(phi)(u-g).grad(phi)
+      = phi Asigma.grad(phi v) - phi Asigma.grad(phi)v + phi^2 div(ADg)v + 2phi Asigma.grad(phi)v
+        + 1/4 Agrad(phi).grad(phi)(u-g)
+      = phi Asigma.(grad(phi v) + grad(phi)v) + phi^2 div(ADg)v + 1/4 Agrad(phi).grad(phi))(u-g)
+
+Advection:
+orig.F_c = bu
+orig.S_e = div(bg)
+
+mix0.F_c(u) = phi^2 orig.F_c(u)
+            = phi^2 bu
+mix0.S_e(u) = phi^2 orig.S_e(u) - phi orig.F_c(u+g).grad(phi)
+            = phi^2 div(bg) + phi (u+g) b.grad(phi)
+
+model = - mix0.F_c(u).grad(v) - mix0.S_e(u)v
+      = - phi^2 u b.grad(v) - phi^2 div(bg)v - phi (u+g) b.grad(phi)v
+      = ( div(phi u phi b) - phi (u+g) b.grad(phi) - phi^2 div(bg) )v
+      = ( phi b.grad(phi u) + phi u div(phi b) - phi (u+g) b.grad(phi) - phi^2 div(bg) )v
+      = ( phi b.(grad(phi u)-g grad(phi))
+          - phi u b.grad(phi) + phi^2 u div(b) + phi u b.grad(phi)
+          - phi^2 b.grad(g) - phi^2 g div(b) )v
+      = ( phi b.(phi sigma) + phi^2 div(b)(u-g) - phi^2 b.grad(g) )v
+      = phi^2 ( b.(sigma - grad(g)) + div(b)(u-g) ) v
+
+paper = phi b . sigma v
+      = phi b . [grad(phi u) - g.grad(phi)] v
+"""
+
+
+@transformer
+def Mix0DDM(Model):
+
+    class DDModel(Model):
+        def sigma(t, x, U, DU=None):
+            if not DU:
+                DU = grad(U)
+            sigma = DU + outer(
+                DDModel.BT.jumpV(t, x, U), grad(DDModel.phi(x))
+            ) / DDModel.phi(x)
+            return sigma
+
+        def S_e_source(t, x, U, DU):
+            return DDModel.phi(x) ** 2 * Model.S_e(t, x, U, DDModel.sigma(t, x, U, DU))
+
+        def S_e_convection(t, x, U, DU):
+            # unsure if using Model.F_c is the right choice here - works in the linear case.
+            convec = (
+                DDModel.phi(x)
+                * Model.F_c(t, x, 2 * U - DDModel.BT.jumpV(t, x, U))
+                * grad(DDModel.phi(x))
+            )
+
+            convec -= DDModel.phi(x) * DDModel.BT.BndFlux_cExt(t, x, U)
+            return convec
+
+        def S_outside(t, x, U, DU):
+            return -(
+                DDModel.BT.jumpV(t, x, U)
+                * (1 - DDModel.phi(x)) ** 2
+                / (DDModel.epsilon**2)
+            )
+
+        def S_i_source(t, x, U, DU):
+            return DDModel.phi(x) ** 2 * Model.S_i(t, x, U, DDModel.sigma(t, x, U, DU))
+
+        def S_i_diffusion(t, x, U, DU):
+            Fv = Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
+            diffusion = 2 * DDModel.phi(x) * Fv * grad(DDModel.phi(x))
+
+            gp = grad(DDModel.phi(x))
+            uogp = outer((DDModel.BT.jumpV(t, x, U)), gp)
+            # use of F_v is probably not correct...
+            diffusion += (
+                # Model.F_v_lin_mult(t, x, U, Mix0DDM.sigma(t,x, U, DU), uogp)
+                Model.F_v(t, x, U, uogp)
+                * gp
+                / 4
+            )
+
+            diffusion += DDModel.phi(x) * DDModel.BT.jumpFv(t, x, U, DU, Fv)
+            return -diffusion
+
+        def F_c(t, x, U):
+            return DDModel.phi(x) ** 2 * Model.F_c(t, x, U)
+
+        def F_v(t, x, U, DU):
+            return DDModel.phi(x) ** 2 * Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
+
+    return DDModel

ddfem/transformers/NNS.py

@@ -0,0 +1,82 @@
+from ufl import as_vector, conditional, dot, grad, sqrt, zero
+
+from .transformer_base import transformer
+
+"""
+Paper: using x^- = 1/2(x-|x|), x^+ = 1/2(x+|x|) so that x = x^+ + x^-, i.e., x^+ - x = - x^-
+the advection b.grad(u)v is replaced with
+phi b.grad(u) v + [b.grad(phi)]^+ (u-g)v
+= div(phi bu)v - div(phi b) uv + [b.grad(phi)]^+ (u-g)v
+= - phi u b.grad(v) - phi div(b) uv - b.grad(phi) uv + [b.grad(phi)]^+ uv - [b.grad(phi)]^+ gv
+= - phi u b.grad(v) - phi div(b) uv + ([b.grad(phi)]^+ - b.grad(phi)) uv - [b.grad(phi)]^+ gv
+= - phi u b.grad(v) - phi div(b) uv - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+
+orig.F_c = bu
+orig.S_e = div(bg)
+
+ddm2.F_c(u) = phi orig.F_c(u)
+            = phi bu
+ddm2.S_e(u) = phi orig.S_e(u) + [b.grad(phi)]^- u
+            = phi div(bg) + [b.grad(phi)]^- u + [b.grad(phi)]^+ gv
+
+model = - ddm2.F_c(u).grad(v) - ddm2.S_e(u)v
+      = - phi u b.grad(v) - phi div(bg)v - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = div(phi u b)v - phi div(b)gv - phi b.grad(g) v - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = phi b.grad(u)v + div(phi b)uv - phi div(b)gv - phi b.grad(g) v - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = phi b.grad(u)v + phi div(b) uv + b.grad(phi)uv - [b.grad(phi)]^- uv - phi div(b)gv - phi b.grad(g) v - [b.grad(phi)]^+ gv
+      = phi b.(grad(u) - grad(g)) v + phi div(b) (u-g)v + b.grad(phi)uv - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = phi b.(grad(u) - grad(g)) v + phi div(b) (u-g)v + [b.grad(phi)]^+ (u-g)v
+"""
+
+
+@transformer
+def NDDM(Model):
+    class DDModel(Model):
+        def S_e_source(t, x, U, DU):
+            return DDModel.phi(x) * Model.S_e(t, x, U, DDModel.sigma(t, x, U, DU))
+
+        def S_e_convection(t, x, U, DU):
+            if DDModel.BT.BndValueExt is not None:
+                direction = Model.F_c_lin_mult(t, x, U, -grad(DDModel.phi(x)))  # fc * n
+                flux_u = Model.F_c(t, x, U) * -grad(DDModel.phi(x))
+                flux_g = Model.F_c(t, x, DDModel.BT.BndValueExt(t, x, U)) * -grad(
+                    DDModel.phi(x)
+                )
+                convec = []
+                for i in range(U.ufl_shape[0]):
+                    convec.append(
+                        conditional(direction[i, i] > 0, flux_u[i], flux_g[i])
+                    )
+                convec = -as_vector(convec)
+            else:
+                convec = zero(U.ufl_shape)
+
+            convec -= DDModel.BT.BndFlux_cExt(t, x, U)
+            return convec
+
+        def S_outside(t, x, U, DU):
+            return -(
+                DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**2)
+            )
+
+        def S_i_source(t, x, U, DU):
+            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)
+            diffusion = beta * (
+                sqrt(dot(grad(DDModel.phi(x)), grad(DDModel.phi(x))))
+                * DDModel.BT.jumpV(t, x, U)
+            )
+            Fv = Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
+            diffusion += Fv * grad(DDModel.phi(x))
+            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)
+
+        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

@@ -0,0 +1,86 @@
+from ufl import as_vector, conditional, dot, grad, outer, sqrt, zero
+
+from .transformer_base import transformer
+
+"""
+Paper: using x^- = 1/2(x-|x|), x^+ = 1/2(x+|x|) so that x = x^+ + x^-, i.e., x^+ - x = - x^-
+the advection b.grad(u)v is replaced with
+phi b.grad(u) v + [b.grad(phi)]^+ (u-g)v
+= div(phi bu)v - div(phi b) uv + [b.grad(phi)]^+ (u-g)v
+= - phi u b.grad(v) - phi div(b) uv - b.grad(phi) uv + [b.grad(phi)]^+ uv - [b.grad(phi)]^+ gv
+= - phi u b.grad(v) - phi div(b) uv + ([b.grad(phi)]^+ - b.grad(phi)) uv - [b.grad(phi)]^+ gv
+= - phi u b.grad(v) - phi div(b) uv - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+
+orig.F_c = bu
+orig.S_e = div(bg)
+
+ddm2.F_c(u) = phi orig.F_c(u)
+            = phi bu
+ddm2.S_e(u) = phi orig.S_e(u) + [b.grad(phi)]^- u
+            = phi div(bg) + [b.grad(phi)]^- u + [b.grad(phi)]^+ gv
+
+model = - ddm2.F_c(u).grad(v) - ddm2.S_e(u)v
+      = - phi u b.grad(v) - phi div(bg)v - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = div(phi u b)v - phi div(b)gv - phi b.grad(g) v - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = phi b.grad(u)v + div(phi b)uv - phi div(b)gv - phi b.grad(g) v - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = phi b.grad(u)v + phi div(b) uv + b.grad(phi)uv - [b.grad(phi)]^- uv - phi div(b)gv - phi b.grad(g) v - [b.grad(phi)]^+ gv
+      = phi b.(grad(u) - grad(g)) v + phi div(b) (u-g)v + b.grad(phi)uv - [b.grad(phi)]^- uv - [b.grad(phi)]^+ gv
+      = phi b.(grad(u) - grad(g)) v + phi div(b) (u-g)v + [b.grad(phi)]^+ (u-g)v
+"""
+
+
+@transformer
+def NSDDM(Model):
+    class DDModel(Model):
+        def S_e_source(t, x, U, DU):
+            return DDModel.phi(x) * Model.S_e(t, x, U, DDModel.sigma(t, x, U, DU))
+
+        def S_e_convection(t, x, U, DU):
+            if DDModel.BT.BndValueExt is not None:
+                direction = Model.F_c_lin_mult(t, x, U, -grad(DDModel.phi(x)))  # fc * n
+                flux_u = Model.F_c(t, x, U) * -grad(DDModel.phi(x))
+                flux_g = Model.F_c(t, x, DDModel.BT.BndValueExt(t, x, U)) * -grad(
+                    DDModel.phi(x)
+                )
+                convec = []
+                for i in range(U.ufl_shape[0]):
+                    convec.append(
+                        conditional(direction[i, i] > 0, flux_u[i], flux_g[i])
+                    )
+                convec = -as_vector(convec)
+            else:
+                convec = zero(U.ufl_shape)
+
+            convec -= DDModel.BT.BndFlux_cExt(t, x, U)
+            return convec
+
+        def S_outside(t, x, U, DU):
+            return -(
+                DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**2)
+            )
+
+        def S_i_source(t, x, U, DU):
+            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
+            diffusion = beta * (
+                sqrt(dot(grad(DDModel.phi(x)), grad(DDModel.phi(x))))
+                * DDModel.BT.jumpV(t, x, U)
+            )
+            Fv = Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
+            diffusion += Fv * grad(DDModel.phi(x))
+            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)
+
+        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

@@ -0,0 +1,6 @@
+from .DDM1 import DDM1
+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

@@ -0,0 +1,213 @@
+from ufl import as_matrix, diff, dot, grad, inner, replace, variable, zero
+from ufl.algorithms.ad import expand_derivatives
+
+from ..boundary import BndFlux_c, BndFlux_v, BndValue, BoundaryTerms
+
+
+def pretransformer(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"
+        else:
+
+            if hasFlux_c:
+                valFc = BndFlux_c(lambda t, x, U, n: -DDBase.BT.BndFlux_cExt(t, x, U))
+            if hasFlux_v:
+                valFv = BndFlux_v(
+                    lambda t, x, U, DU, n: DDBase.BT.BndFlux_vExt(t, x, U, DU)
+                )
+            if hasFlux_c and hasFlux_v:
+                valN = [valFc, valFv]
+            elif hasFlux_c:
+                valN = valFc
+            elif hasFlux_v:
+                valN = valFv
+            boundary[lambda x: DDBase.domain.chi(x) < 0.5] = valN
+
+        phi = domain.phi
+        epsilon = domain.omega.epsilon
+        ep = domain.external_projection
+
+        def sigma(t, x, U, DU=None):
+            if DU:
+                return DU
+            return grad(U)
+
+        if hasSource_e:
+
+            def S_e(t, x, U, DU):
+                return replace(
+                    expand_derivatives(Model.S_e(t, x, U, DU)),
+                    {x: DDBase.ep(x)},
+                )
+
+        if hasSource_i:
+
+            def S_i(t, x, U, DU):
+                return replace(
+                    expand_derivatives(Model.S_i(t, x, U, DU)),
+                    {x: DDBase.ep(x)},
+                )
+
+        if hasFlux_c:
+
+            def F_c(t, 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:
+
+            def F_v(t, x, U, DU):
+                # return Model.F_v(t, DDBase.ep(x), U, DU)
+
+                return replace(
+                    expand_derivatives(Model.F_v(t, x, U, DU)),
+                    {x: DDBase.ep(x)},
+                )
+
+        # U_t + div[F_c(x,t,U) - F_v(x,t,U,grad[U]) ] = S(x,t,U, grad[U]).
+
+        def F_c_lin(t, x, U):
+            U = variable(U)
+            d = diff(Model.F_c(t, x, U), U)
+            d = expand_derivatives(d)
+            return d
+
+        # U.ufl_shape == (1,)
+        # F_c(U).ufl_shape == (1, 2,)
+        # diff(F_c(U), U).ufl_shape == (1, 2, 1)
+        # n.ufl_shape == (2,)
+        #
+        # s, t = F_c(U).ufl_shape
+        # f_c = as_matrix([[dot(d[i, j, :], U) for j in range(t)] for i in range(s)])
+        #
+        # w, = U.ufl_shape
+        # convec = as_vector([dot([f_c[w, :], n) for i in range(w)]) # f_c * n
+        #
+        # switch order
+
+        def F_c_lin_mult(t, x, U, n):
+            G = DDBase.F_c_lin(t, x, U)
+            # try:
+            #     d = dot(G, n)
+            #     print("F_c dot")
+            #     return d
+            # except:
+            m, d, m_ = G.ufl_shape
+            return as_matrix(
+                [[dot(G[i, :, k], n) for k in range(m_)] for i in range(m)]
+            )
+
+        def F_v_lin(t, x, U, DU):
+            DU = variable(DU)
+            d = diff(Model.F_v(t, x, U, DU), DU)
+            d = expand_derivatives(d)
+            return d
+
+        def F_v_lin_mult(t, x, U, DU, v):
+            G = DDBase.F_v_lin(t, x, U, DU)
+            # try:
+            #     d = dot(G, v)
+            #     print("F_v dot")
+            #     return d
+            # except:
+            m, d = v.ufl_shape
+            return as_matrix(
+                [[inner(G[i, k, :, :], v) for k in range(d)] for i in range(m)]
+            )
+
+    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/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: ddfem
+Version: 0.9.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
+Project-URL: Homepage, https://...
+Project-URL: Issues, https://...
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+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
+
+This is a package for solving complex PDEs based on the diffuse domain idea.
+
+Build package by running
+
+```bash
+python3 -m build
+```

ddfem-0.9.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+ddfem/__init__.py,sha256=N860erjFVjXifNwEQ_ejRF99ub195M6eC9GIOqeIhyU,106
+ddfem/boundary.py,sha256=qpvvjRBBUZHZULIRovuz1h8U30KQRtYERIJxN5O251c,7570
+ddfem/dune.py,sha256=oU4bKiG4AndEhMVhAi1Nnmo9cEhjceTW3X2ptv6ombU,67
+ddfem/model2ufl.py,sha256=lEEmMmZWbcxprHD9pRWwZfIdiLg3ScQkR7V_N48qqAw,4265
+ddfem/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ddfem/examples/advection_diffusion.py,sha256=9UPILICF3Sfh3SA7zJk6iDabXmvIa4GowJd62qaWOd8,2081
+ddfem/examples/beam.py,sha256=awZvrgw92ANJgD1MGhhEVZ0eBsSNmhuwegpS8AHiiPk,4687
+ddfem/examples/cahn_hilliard.py,sha256=-T6p5-BY98sQ5y9Vcd2YVokamQQ66nA7uUqJDRQjzB0,2308
+ddfem/examples/chemical_reaction.py,sha256=9zNgGuCT25Z0Z_ru8pNoK1MOOrYA8r3UkfGvmNRQXpw,2488
+ddfem/examples/constant.py,sha256=6wFiKnsbjMKk9hInJwnCa8d7Thp7uPZGJ-1805V243Y,1508
+ddfem/examples/five_circle_flat.py,sha256=NbNmmz8jMwfFa7ZfEDUq0g5BF94z_ivvbPA2jVLs6PM,6049
+ddfem/examples/forchheimer.py,sha256=3mpdYVzRn9tmtq7kQBP-vlx9L7HmAHdqbVVRABRd2TY,1311
+ddfem/examples/hyperelasticity.py,sha256=YyoZhruTMpTfUIL4ioOkwe9FFPf_ffCMHsMsBV4SZ_w,2373
+ddfem/examples/linear_elasticity.py,sha256=N3wpzzhD4wRpBqmEYFV39_Nx7RuNgfeEMsTWpdzIdgk,1164
+ddfem/examples/plaplace.py,sha256=yiuYdJpDrFHl1oLG7WWtAs26x2s9vjSXlTsijXTPBxc,751
+ddfem/examples/single_circle.py,sha256=m3tg7frVTLnP8Cxfx_6fbvoUb2mJ3ltgNnrX5URAwRw,4601
+ddfem/examples/triple_circle.py,sha256=bo8ZD1B7biXe1HwVDv97O6B5EVsku5TCft3Oqamay7E,7089
+ddfem/examples/triple_circle_beam.py,sha256=J9_U2MuRBGnhUT1w_IimuyfTLzds_XD2CCv9o4nWD_w,6607
+ddfem/geometry/__init__.py,sha256=ePmkipwfdhM88qrStE__n0VFKqvl8AKK4VjsAsivt4Y,295
+ddfem/geometry/arc.py,sha256=ouK8gxkd2f8RtpAK33p6-zU5RoyMejxEge2IEcCOtR4,1381
+ddfem/geometry/ball.py,sha256=Q_ped9ay3KypU8sKutAXPH9XkEFJx5hIK7qTCy1Y26E,679
+ddfem/geometry/box.py,sha256=ecXUMI2a17-hZZyUXol08z7wk3IZn1yHE_CV9YIyR18,915
+ddfem/geometry/domain.py,sha256=n4Cu1sFy19ONUuQec2EICtoSBYzS-H_sLB2YxU5dads,1363
+ddfem/geometry/domain_dune.py,sha256=2ArzeRU42o4-TS21DXajPSCXj_3SlgGdehgN7QJhQzc,2600
+ddfem/geometry/helpers.py,sha256=kunsuciuJJwkcZgDn8A7wbKYSqIAYjdvhei_YfjvVtk,1049
+ddfem/geometry/pie.py,sha256=WjgYPI6YvkcxPTQB1SjdN22dFQHV0X8kSO6QcXDLBSU,1003
+ddfem/geometry/plane.py,sha256=hCRLa06yXfXzfms2JIbAusdPf5qFUy9DrjNDfZ-0TGA,500
+ddfem/geometry/primitive_base.py,sha256=gq3s2CIXk1qBnOEGys217yd_zXQr_UXrDXRpagQ3oiY,9419
+ddfem/geometry/vesica.py,sha256=g28RxdoDpUiq9QR9sHUJkO05-F3YTDOTOxcNm1tyV4E,1747
+ddfem/transformers/DDM1.py,sha256=73TW_mCPjdvRGo65D9uMUiw7ygYZCQuGFPIPvEmz43o,1092
+ddfem/transformers/Fitted.py,sha256=GdaA0znMfw_U_QNAngZSYJB3ZJgH_BAnvrL_viZqals,2908
+ddfem/transformers/Mix0.py,sha256=ZYeL6jrIIFCvVjCt_evB7sOG0ES3tmm5j-6W8gjK11k,3816
+ddfem/transformers/NNS.py,sha256=lGQVCd1x6KrzVyOEAIttaDXBFjP9nLBIj9wnp_fvYtg,3416
+ddfem/transformers/NS.py,sha256=fsih358oeayvmovhTAuddjbx7O0K_faF5qTAMQdHH8s,3612
+ddfem/transformers/__init__.py,sha256=okno6aFZoIPaJRi_Nw7cM63jpy18rS2yHsSuG7Vb4Og,195
+ddfem/transformers/transformer_base.py,sha256=Ey6iGk203lnzJOhLjMxyQNgKbclba_RIPpMW22OT7zQ,6347
+ddfem-0.9.0.dist-info/licenses/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+ddfem-0.9.0.dist-info/METADATA,sha256=opemBPw8Y5D8ZSGNGoyYo2t0yosVrtwZqr5_i81_U8E,718
+ddfem-0.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ddfem-0.9.0.dist-info/top_level.txt,sha256=LF2T9-5A2Bak81PqbCcsAex8d5Xrla2Wq8yrlQi-ZtY,6
+ddfem-0.9.0.dist-info/RECORD,,

{ddfem-0.0.0.dist-info → ddfem-0.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ddfem-0.9.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ddfem-0.0.0.dist-info/METADATA

@@ -1,5 +0,0 @@
-Metadata-Version: 2.2
-Name: ddfem
-Version: 0.0.0
-Summary: Coming soon
-Author-email: Luke Benfield <luke.benfield@warwick.ac.uk>, Andreas Dedner <a.s.dedner@warwick.ac.uk>

ddfem-0.0.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-ddfem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ddfem-0.0.0.dist-info/METADATA,sha256=L2owp_gZwgOsfVmOwLKaADCMA6yiPSplXAJFHUyt6-g,171
-ddfem-0.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ddfem-0.0.0.dist-info/top_level.txt,sha256=LF2T9-5A2Bak81PqbCcsAex8d5Xrla2Wq8yrlQi-ZtY,6
-ddfem-0.0.0.dist-info/RECORD,,