ddfem 1.0.0__py3-none-any.whl → 1.0.1__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_base
+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^-
@@ -29,18 +29,9 @@ model = - ddm2.F_c(u).grad(v) - ddm2.S_e(u)v
 """
 
 
-def NDDM(OriginalModel, domainDescription):
-    Model = transformer_base(OriginalModel, domainDescription)
-
+@transformer
+def NDDM(Model):
     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))
 
@@ -60,31 +51,11 @@ def NDDM(OriginalModel, domainDescription):
             else:
                 convec = zero(U.ufl_shape)
 
-            convec += DDModel.BT.BndFlux_cExt(t, x, U)
+            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 * (
+        def S_outside(t, x, U, DU):
+            return -(
                 DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**2)
             )
 
@@ -92,7 +63,7 @@ def NDDM(OriginalModel, domainDescription):
             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)
+            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)
@@ -102,42 +73,10 @@ def NDDM(OriginalModel, domainDescription):
             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_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))
+        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_base
+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^-
@@ -29,18 +29,9 @@ model = - ddm2.F_c(u).grad(v) - ddm2.S_e(u)v
 """
 
 
-def NSDDM(OriginalModel, domainDescription):
-    Model = transformer_base(OriginalModel, domainDescription)
-
+@transformer
+def NSDDM(Model):
     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))
 
@@ -60,31 +51,11 @@ def NSDDM(OriginalModel, domainDescription):
             else:
                 convec = zero(U.ufl_shape)
 
-            convec += DDModel.BT.BndFlux_cExt(t, x, U)
+            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 * (
+        def S_outside(t, x, U, DU):
+            return -(
                 DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**2)
             )
 
@@ -92,7 +63,7 @@ def NSDDM(OriginalModel, domainDescription):
             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
+            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)
@@ -102,50 +73,14 @@ def NSDDM(OriginalModel, domainDescription):
             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)
-                )
+        def F_c(t, x, U):
+            return DDModel.phi(x) * Model.F_c(t, x, U)
 
-        elif 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))
 
-            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
+            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,3 +3,4 @@ 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,22 +1,30 @@
-from ufl import as_matrix, diff, dot, inner, replace, variable, zero
+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 transformer_base(Model, domainDescription):
+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.omega.chi(x) < 0.5] = BndValue(
-                BT.BndValueExt
-            )
+            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:
-            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))
@@ -30,13 +38,18 @@ def transformer_base(Model, domainDescription):
                 valN = valFc
             elif hasFlux_v:
                 valN = valFv
-            boundary[lambda x: DDBase.domain.omega.chi(x) < 0.5] = valN
+            boundary[lambda x: DDBase.domain.chi(x) < 0.5] = valN
 
         phi = domain.phi
         epsilon = domain.omega.epsilon
-        ep = domain.omega.external_projection
+        ep = domain.external_projection
 
-        if hasattr(Model, "S_e"):
+        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(
@@ -44,7 +57,7 @@ def transformer_base(Model, domainDescription):
                     {x: DDBase.ep(x)},
                 )
 
-        if hasattr(Model, "S_i"):
+        if hasSource_i:
 
             def S_i(t, x, U, DU):
                 return replace(
@@ -52,20 +65,20 @@ def transformer_base(Model, domainDescription):
                     {x: DDBase.ep(x)},
                 )
 
-        if hasattr(Model, "F_c"):
+        if hasFlux_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 hasattr(Model, "F_v"):
+        if hasFlux_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)),
@@ -124,3 +137,77 @@ def transformer_base(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-1.0.0.dist-info → ddfem-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddfem
-Version: 1.0.0
+Version: 1.0.1
 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,14 +12,10 @@ 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-1.0.1.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-1.0.1.dist-info/licenses/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+ddfem-1.0.1.dist-info/METADATA,sha256=_jSNqnAB71Fb33U16dUgV6jGoSyb1kLlpYGGbZaJv88,663
+ddfem-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ddfem-1.0.1.dist-info/top_level.txt,sha256=LF2T9-5A2Bak81PqbCcsAex8d5Xrla2Wq8yrlQi-ZtY,6
+ddfem-1.0.1.dist-info/RECORD,,

ddfem/base_model.py

@@ -1,200 +0,0 @@
-import inspect
-
-import ufl
-from ufl import as_matrix, as_vector, diff, dot, inner, outer, variable, zero
-from ufl.algorithms.ad import expand_derivatives
-from ufl.algorithms.apply_derivatives import apply_derivatives
-
-
-class BaseModel:
-    boundary = {}
-
-    @staticmethod
-    def function(self, *args, **kwargs):
-        uh = self._function(*args, **kwargs)
-        uh.boundary = self.boundary
-        return uh
-
-    # U_t + div[F_c(x,t,U) - F_v(x,t,U,grad[U]) ] = S(x,t,U, grad[U]).
-
-    @classmethod
-    def F_c_lin(cls, t, x, U):
-        U = variable(U)
-        d = diff(cls.F_c(t, x, U), U)
-        d = apply_derivatives(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
-
-    @classmethod
-    def F_c_lin_mult(cls, t, x, U, n):
-        G = cls.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)])
-
-    @classmethod
-    def F_v_lin(cls, t, x, U, DU):
-        DU = variable(DU)
-        d = diff(cls.F_v(t, x, U, DU), DU)
-        d = apply_derivatives(expand_derivatives(d))
-        return d
-
-    @classmethod
-    def F_v_lin_mult(cls, t, x, U, DU, v):
-        G = cls.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)]
-        )
-
-    # avoid issue with variable capturing in lambdas in the for loop below
-    # https://www.geeksforgeeks.org/why-do-python-lambda-defined-in-a-loop-with-different-values-all-return-the-same-result/
-    def _createV(v, U=None):
-        if U is None:
-            return lambda t, x, u: v  # classify
-        return lambda t, x: v(t, x, U)  # jumpV
-
-    def _createF(v, U=None, DU=None, N=None):
-        if U is None and DU is None and N is None:
-            return lambda t, x, u, _, n: v(t, x, u, n)  # classify
-        elif U and N and DU is None:
-            return lambda t, x: v(t, x, U, N)  # jumpAF
-        elif U and N and DU:
-            return lambda t, x: v(t, x, U, DU, N)  # jumpDF
-
-    @staticmethod
-    def classify_boundary(Model):
-        boundaryDict = getattr(Model, "boundary_d", {})
-
-        boundaryAFlux = {}  # Fluxes for the advection term
-        boundaryDFlux = {}  # Fluxes for the diffusion term
-        boundaryValue = {}  # Boundary values for Dirichlet
-
-        hasAdvFlux = hasattr(Model, "F_c")
-        hasDiffFlux = hasattr(Model, "F_v")
-
-        for k, f in boundaryDict.items():
-            if isinstance(f, (tuple, list)):
-                assert (
-                    hasAdvFlux and hasDiffFlux
-                ), "two boundary fluxes provided but only one bulk flux given"
-                boundaryAFlux[k], boundaryDFlux[k] = f
-                # (f[0](t, x, u, n), f[1](t, x, u, grad(u), n))
-
-            elif isinstance(f, ufl.core.expr.Expr):
-                boundaryValue[k] = BaseModel._createV(f)
-
-            else:
-                num_args = len(inspect.signature(f).parameters)
-
-                if num_args == 3:
-                    boundaryValue[k] = f  # f(t, x, u)
-
-                elif num_args == 4:
-                    if hasAdvFlux and not hasDiffFlux:
-                        boundaryAFlux[k] = f  # f(t, x, u, n)
-                    elif not hasAdvFlux and hasDiffFlux:
-                        boundaryDFlux[k] = BaseModel._createF(f)
-                    else:
-                        assert not (
-                            hasAdvFlux and hasDiffFlux
-                        ), "one boundary fluxes provided but two bulk fluxes given"
-
-                else:
-                    raise NotImplementedError(f"boundary function {num_args} arguments")
-
-        return boundaryAFlux, boundaryDFlux, boundaryValue
-
-    @staticmethod
-    def boundaryTerms(Model, domain):
-        boundaryAFlux, boundaryDFlux, boundaryValue = BaseModel.classify_boundary(Model)
-        bd_weight = []
-        bN_weight = []
-
-        for model_key in boundaryValue.keys():
-            phi_i_proj = domain.bndProjSDFs(model_key)
-            bd_weight.append(phi_i_proj)
-
-        for model_key in {*boundaryAFlux.keys(), *boundaryDFlux.keys()}:
-            phi_i_proj = domain.bndProjSDFs(model_key)
-            bN_weight.append(phi_i_proj)
-
-        def total_weight(t, x):
-            weight = 1e-10  # tol
-            for w in bd_weight + bN_weight:
-                weight += w(t, x)
-            return weight
-
-        # perhaps switch methods around so that gExt is setup and then
-        # jumpD does sum(w)*U - gExt. But then the exception needs to be caught...
-        def jumpV(t, x, U, U1=None):
-            jdv = zero(U.ufl_shape)
-
-            if U1 is None:
-                U1 = U
-
-            for g, w in zip(boundaryValue.values(), bd_weight):
-                g_tmp = BaseModel._createV(v=g, U=U)
-                g_ext = domain.omega.boundary_extend(g_tmp)
-
-                jdv += w(t, x) * (U1 - g_ext(t, x))
-
-            return jdv / total_weight(t, x)
-
-        if len(boundaryValue) == 0:
-            gExt = None
-        else:
-
-            def gExt(t, x, U):
-                z = zero(U.ufl_shape)
-                return -jumpV(t, x, U, z)
-
-        # the models expect to be provided with a unit normal in the boundary fluxes
-        def jumpDF(t, x, U, DU, Fv):
-            # (sigma.n-gN)*ds(N) = - wN ( sigma.Dphi + gN|Dphi| )
-            #   = wN ( (-sigma.Dphi) - gN(t,x,-Dphi/|Dphi|)|Dphi| )
-            #   = wN ( sigma.sn - gN(t,x,sn) ) with sn = -Dphi
-            jdf = zero(U.ufl_shape)
-
-            fv_scaled = Fv * domain.scaledNormal(x)
-            for g, w in zip(boundaryDFlux.values(), bN_weight):
-                g_tmp = BaseModel._createF(v=g, U=U, DU=DU, N=domain.scaledNormal(x))
-                g_ext = domain.omega.boundary_extend(g_tmp)
-
-                jdf += w(t, x) * (fv_scaled - g_ext(t, x))
-
-            return jdf / total_weight(t, x)
-
-        def jumpAF(t, x, U):
-            jda = zero(U.ufl_shape)
-
-            for g, w in zip(boundaryAFlux.values(), bN_weight):
-                g_tmp = BaseModel._createF(v=g, U=U, N=domain.scaledNormal(x))
-                g_ext = domain.omega.boundary_extend(g_tmp)
-
-                jda += -w(t, x) * g_ext(t, x)
-
-            return jda / total_weight(t, x)
-
-        return jumpV, gExt, jumpDF, jumpAF