ddfem 1.0.0__tar.gz → 1.0.1__tar.gz

{ddfem-1.0.0 → ddfem-1.0.1}/PKG-INFO

@@ -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.0 → ddfem-1.0.1}/README.md

@@ -2,8 +2,3 @@
 
 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/ddfem/__init__.py

@@ -0,0 +1,4 @@
+from . import geometry
+from . import transformers
+from . import boundary
+from .model2ufl import model2ufl

{ddfem-1.0.0 → ddfem-1.0.1}/ddfem/boundary.py

@@ -6,6 +6,7 @@ from ufl.algorithms.ad import expand_derivatives
 from ufl.core.expr import Expr
 
 from .geometry.domain import Domain
+from .geometry.primitive_base import SDF
 
 
 class BoundaryCondition:
@@ -22,7 +23,9 @@ class BndValue(BoundaryCondition):
             super().__init__(lambda t, x, u: value)
         else:
             num_args = len(inspect.signature(value).parameters)
-            if num_args == 2:
+            if num_args == 1:
+                super().__init__(lambda t, x, u: value(x))
+            elif num_args == 2:
                 super().__init__(lambda t, x, u: value(t, x))
             elif num_args == 3:
                 super().__init__(value)
@@ -129,7 +132,7 @@ class BoundaryTerms:
         else:
             self.domain = Domain(domainDescription)
 
-        condition = lambda k: isinstance(k, str)
+        condition = lambda k: isinstance(k, str) or isinstance(k, SDF)
         self.diffuse = {k: v for k, v in Model.boundary.items() if condition(k)}
         self.physical = {k: v for k, v in Model.boundary.items() if not condition(k)}
 
@@ -154,6 +157,11 @@ class BoundaryTerms:
         if not self.boundary_flux_vs:
             self.BndFlux_vExt = None
 
+    def _dbc_total_weight(self, x):
+        weight = 1e-10
+        for w_func in self.bV_weight:
+            weight += w_func(x)
+        return weight
     def _total_weight(self, x):
         weight = 1e-10  # tol
         for w_func in self.bV_weight + self.bF_weight:
@@ -162,7 +170,7 @@ class BoundaryTerms:
 
     def _boundary_extend(self, g, x):
         g_tmp = expand_derivatives(g)
-        return replace(g_tmp, {x: self.domain.omega.boundary_projection(x)})
+        return replace(g_tmp, {x: self.domain.boundary_projection(x)})
 
     # perhaps switch methods around so that BndValueExt is setup and then
     # jumpD does sum(w)*U - BndValueExt. But then the exception needs to be caught...
@@ -197,6 +205,7 @@ class BoundaryTerms:
             jdf += w_func(x) * (fv_scaled - g_ext * self.domain.surface_delta(x))
 
         return jdf / self._total_weight(x)
+        # return jdf * (self._dbc_total_weight(x) / self._total_weight(x))
 
     def BndFlux_vExt(self, t, x, U, DU):
         # called if self.BndFlux_vExt was not set to None in __init__

ddfem-1.0.1/ddfem/examples/advection_diffusion.py

@@ -0,0 +1,74 @@
+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-1.0.1/ddfem/examples/beam.py

@@ -0,0 +1,147 @@
+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

ddfem-1.0.1/ddfem/examples/cahn_hilliard.py

@@ -0,0 +1,67 @@
+from dune.ufl import Constant
+from ufl import as_tensor, as_vector, dot, grad, inner, zero
+
+from ddfem.boundary import BndFlux_c, BndFlux_v, BndValue
+
+
+def chModel():
+    class CHModel:
+        dimRange = [1, 1]
+
+        M = Constant(1, name="M")
+        lmbda = Constant(1.0e-02, name="lmbda")  # surface parameter
+        dt = Constant(5.0e-06, name="dt")  # time step
+        theta = Constant(
+            0.5, name="theta"
+        )  # theta=1 -> backward Euler, theta=0.5 -> Crank-Nicolson
+
+        u_h_n = None
+        Du_h_n = None
+
+        def setup(u_h, DDMModel):
+            CHModel.u_h_n = u_h.copy()
+            CHModel.Du_h_n = lambda t, x: DDMModel.sigma(
+                t, x, CHModel.u_h_n, grad(CHModel.u_h_n)
+            )
+
+        def energy(U, DU):
+            C, MU = as_vector([U[0]]), as_vector([U[1]])
+            DC, DMU = as_tensor([DU[0, :]]), as_tensor([DU[1, :]])
+
+            f = 100 * dot(C, C) * dot(as_vector([1]) - C, as_vector([1]) - C)
+
+            return CHModel.lmbda / 2 * inner(DC, DC) + f
+
+        def F_v(t, x, U, DU):
+            C, MU = as_vector([U[0]]), as_vector([U[1]])
+            DC, DMU = as_tensor([DU[0, :]]), as_tensor([DU[1, :]])
+            c_h_n, mu_h_n = as_vector([CHModel.u_h_n[0]]), as_vector([CHModel.u_h_n[1]])
+            Du_h_n = CHModel.Du_h_n(t, x)
+            Dc_h_n, Dmu_h_n = as_vector([Du_h_n[0, :]]), as_vector([Du_h_n[1, :]])
+
+            mu_mid = (1.0 - CHModel.theta) * Dmu_h_n + CHModel.theta * DMU
+            concentration_F_v = CHModel.M * mu_mid
+            potential_F_v = CHModel.lmbda * DC
+
+            return as_tensor([concentration_F_v[0, :], potential_F_v[0, :]])
+
+        def S_i(t, x, U, DU):
+            C, MU = as_vector([U[0]]), as_vector([U[1]])
+            DC, DMU = as_tensor([DU[0, :]]), as_tensor([DU[1, :]])
+            c_h_n, mu_h_n = as_vector([CHModel.u_h_n[0]]), as_vector([CHModel.u_h_n[1]])
+
+            concentration_S_i = -(C - c_h_n) / CHModel.dt
+            potential_S_i = (
+                MU - (200 + 400 * dot(C, C)) * C + as_vector([600 * dot(C, C)])
+            )
+
+            return as_vector([concentration_S_i[0], potential_S_i[0]])
+
+        def valF_v(t, x, MU, DMU, n):
+            return zero(2)
+
+        boundary = {
+            "full": BndFlux_v(valF_v),
+        }
+
+    return CHModel

ddfem-1.0.1/ddfem/examples/chemical_reaction.py

@@ -0,0 +1,88 @@
+from dune.ufl import Constant
+from ufl import as_vector, conditional, dot, grad, outer, zero
+
+from ddfem.boundary import BndFlux_c, BndFlux_v, BndValue
+
+
+def crModel():
+    class PotentialModel:
+        dimRange = 1
+        outFactor_i = Constant(1, "outFactor")
+
+        def F_v(t, x, U, DU):
+            return DU
+
+        def S_e(t, x, U, DU):
+            return as_vector([-1])
+
+        def valD(t, x, U):
+            return zero(1)
+
+        boundary = {
+            "full": BndValue(valD),
+        }
+
+    class ChemModel:
+        dimRange = 3
+
+        dt = Constant(0.05, "dt")
+        diff = Constant(1e-3, "diff")  # this is about the boundary for stability
+        # outFactor_i = diff
+
+        P1 = as_vector([-0.25, -0.25])  # midpoint of first source (close to boundary)
+        P2 = as_vector([0.25, 0.25])  # midpoint of second source (close to boundary)
+
+        u_h_n = None
+        dpsi_h = None
+
+        def setup(u_h, DDMPotentialModel, psi_h):
+            ChemModel.u_h_n = u_h.copy(name="u_h_n")
+            ChemModel.u_h_n.interpolate(zero(ChemModel.dimRange))
+
+            ChemModel.dpsi_h = lambda x: DDMPotentialModel.sigma(
+                0, x, psi_h, grad(psi_h)
+            )
+
+        def f1(x):
+            q = x - ChemModel.P1
+            return conditional(dot(q, q) < 0.04**2, 5, 0)
+
+        def f2(x):
+            q = x - ChemModel.P2
+            return conditional(dot(q, q) < 0.04**2, 5, 0)
+
+        def f(t, x):
+            return conditional(
+                t < 10,
+                as_vector([ChemModel.f1(x), ChemModel.f2(x), 0]),
+                as_vector([0, 0, 0]),
+            )
+
+        def r(U):
+            return 10 * as_vector([U[0] * U[1], U[0] * U[1], -2 * U[0] * U[1]])
+
+        def F_v(t, x, U, DU):
+            return ChemModel.diff * DU
+
+        def velocity(x):
+            return as_vector([-ChemModel.dpsi_h(x)[0, 1], ChemModel.dpsi_h(x)[0, 0]])
+
+        def F_c(t, x, U):
+            return outer(U, ChemModel.velocity(x))
+
+        def S_i(t, x, U, DU):
+            return -(U - ChemModel.u_h_n) / ChemModel.dt
+
+        def S_e(t, x, U, DU):
+            return ChemModel.f(t, x) - ChemModel.r(ChemModel.u_h_n)
+
+        # boundary = {"full": BndValue(lambda t, x, U: zero(3))}
+
+        boundary = {
+            "full": [
+                BndFlux_c(lambda t, x, U, n: zero(ChemModel.dimRange)),
+                BndFlux_v(lambda t, x, U, DU, n: zero(ChemModel.dimRange)),
+            ]
+        }
+
+    return PotentialModel, ChemModel

ddfem-1.0.1/ddfem/examples/constant.py

@@ -0,0 +1,46 @@
+from dune.ufl import Constant
+from ufl import as_vector, conditional, div, dot, exp, grad, inner, sqrt, outer, zero
+import ufl
+from ddfem.boundary import AFluxBC, DFluxBC, ValueBC
+
+def CModel(inverted):
+    withAdv = False
+
+    class Model:
+        dimRange = 1
+        stabFactor = Constant(1)
+
+        def initial(x):
+            return 2
+
+        def exact(t, x):
+            return as_vector((2+x[0]-x[0],))   # better way of avoiding 'Cannot determine geometric dimension from expression'
+
+        def K(U, DU):
+            return 1e-2
+
+        def F_v(t, x, U, DU):
+            return Model.K(U, DU) * DU
+
+        if withAdv:
+            def F_c(t, x, U):
+                return outer(U, as_vector([-2,0.5]) )
+  
+        if withAdv:
+            bndFlux = [ AFluxBC( lambda t,x,U,n: Model.F_c(t,x,U)*n ),
+                        DFluxBC( lambda t,x,U,DU,n: Model.F_v(t,x,U,DU)*n ) ]
+        else:
+            # this works: bndFlux = DFluxBC( lambda t,x,U,DU,n: zero(U.ufl_shape)
+            bndFlux = DFluxBC( lambda t,x,U,DU,n: Model.F_v(t,x,U,DU)*n )
+        boundary = {
+            # "full": ValueBC( lambda t,x,U: as_vector([2.]) ),
+            "full": bndFlux
+            # "sides": ValueBC( lambda t,x,U: as_vector([2.]) ),
+            # "ends": [AFluxBC( lambda t,x,U,n: Model.F_c(t,x,U)*n ),
+            #          DFluxBC( lambda t,x,U,DU,n: Model.F_v(t,x,U,DU)*n )]
+        }
+
+        if inverted:
+            boundary[range(1,5)] = ValueBC( lambda t,x,U: as_vector([2.]) )
+
+    return Model