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

ddfem/transformers/Mix0.py

@@ -0,0 +1,161 @@
+from ufl import grad, outer
+
+from .transformer_base import transformer_base
+
+"""
+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
+"""
+
+
+def Mix0DDM(OriginalModel, domainDescription):
+    Model = transformer_base(OriginalModel, domainDescription)
+
+    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
+
+        if hasattr(Model, "S_e") and hasattr(Model, "F_c"):
+            print("Mix0DDM: 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("Mix0DDM: S_e")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_source(t, x, U, DU)
+
+        elif hasattr(Model, "F_c"):
+            print("Mix0DDM: 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)) ** 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
+
+        if hasattr(Model, "S_i") and hasattr(Model, "F_v"):
+            print("Mix0DDM: 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("Mix0DDM: 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("Mix0DDM: 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("Mix0DDM: F_c")
+
+            def F_c(t, x, U):
+                return DDModel.phi(x) ** 2 * Model.F_c(t, x, U)
+
+        if hasattr(Model, "F_v"):
+            print("Mix0DDM: F_v")
+
+            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,143 @@
+from ufl import as_vector, conditional, dot, grad, sqrt, zero
+
+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^-
+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
+"""
+
+
+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))
+
+        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
+
+        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)
+            )
+
+        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)) * Model.stabFactor / (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
+
+        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))
+
+    return DDModel

ddfem/transformers/NS.py

@@ -0,0 +1,151 @@
+from ufl import as_vector, conditional, dot, grad, outer, sqrt, zero
+
+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^-
+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
+"""
+
+
+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))
+
+        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
+
+        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)
+            )
+
+        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)) * Model.stabFactor / 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
+
+        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)
+                )
+
+        elif hasattr(Model, "F_v"):
+            print("NSDDM: 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("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

@@ -0,0 +1,5 @@
+from .DDM1 import DDM1
+from .Fitted import Fitted
+from .Mix0 import Mix0DDM
+from .NNS import NDDM
+from .NS import NSDDM

ddfem/transformers/transformer_base.py

@@ -0,0 +1,126 @@
+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 transformer_base(Model, domainDescription):
+    class DDBase(Model):
+        BT = BoundaryTerms(Model, domainDescription)
+        boundary = BT.physical
+        domain = BT.domain
+
+        if BT.BndValueExt is not None:
+            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))
+            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.omega.chi(x) < 0.5] = valN
+
+        phi = domain.phi
+        epsilon = domain.omega.epsilon
+        ep = domain.omega.external_projection
+
+        if hasattr(Model, "S_e"):
+
+            def S_e(t, x, U, DU):
+                return replace(
+                    expand_derivatives(Model.S_e(t, x, U, DU)),
+                    {x: DDBase.ep(x)},
+                )
+
+        if hasattr(Model, "S_i"):
+
+            def S_i(t, x, U, DU):
+                return replace(
+                    expand_derivatives(Model.S_i(t, x, U, DU)),
+                    {x: DDBase.ep(x)},
+                )
+
+        if hasattr(Model, "F_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 hasattr(Model, "F_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

ddfem-1.0.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: ddfem
+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
+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
+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-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-0.0.0.dist-info → ddfem-1.0.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-1.0.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,,