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

ddfem/__init__.py

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

ddfem/boundary.py

@@ -0,0 +1,223 @@
+import inspect
+
+import ufl
+from ufl import replace, zero
+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:
+    def __init__(self, value):
+        self.value = value
+
+    def __call__(self, *args, **kwds):
+        return self.value(*args, **kwds)
+
+
+class BndValue(BoundaryCondition):
+    def __init__(self, value):
+        if isinstance(value, ufl.core.expr.Expr):
+            super().__init__(lambda t, x, u: value)
+        else:
+            num_args = len(inspect.signature(value).parameters)
+            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)
+            # elif num_args == 4:
+            #     self.SPLIT = True
+            #     super().__init__(lambda t, x, u: value(t, x, u, n, n))
+            else:
+                raise ValueError(f"Boundary has {num_args} arguments.")
+
+
+class BndFlux_v(BoundaryCondition):
+    pass
+
+
+class BndFlux_c(BoundaryCondition):
+    pass
+
+
+def classify_boundary(boundary_dict):
+
+    boundary_flux_cs = {}  # Fluxes for the advection term
+    boundary_flux_vs = {}  # Fluxes for the diffusion term
+    boundary_values = {}  # Boundary values for Dirichlet
+
+    for k, f in boundary_dict.items():
+
+        if isinstance(k, (Expr, str)):
+            ids = [k]
+        elif callable(k):
+            ids = [k]
+        else:
+            try:
+                ids = []
+                for kk in k:
+                    ids += [kk]
+            except TypeError:
+                ids = [k]
+
+        if isinstance(f, (tuple, list)):
+            assert len(f) == 2, "too many boundary fluxes provided"
+            if isinstance(f[0], BndFlux_v) and isinstance(f[1], BndFlux_c):
+                boundary_flux_vs.update([(kk, f[0]) for kk in ids])
+                boundary_flux_cs.update([(kk, f[1]) for kk in ids])
+
+            elif isinstance(f[0], BndFlux_c) and isinstance(f[1], BndFlux_v):
+                boundary_flux_vs.update([(kk, f[1]) for kk in ids])
+                boundary_flux_cs.update([(kk, f[0]) for kk in ids])
+
+            else:
+                raise ValueError("Need AFlux and DFlux")
+
+        elif isinstance(f, BndFlux_v):
+            boundary_flux_vs.update([(kk, f) for kk in ids])
+
+        elif isinstance(f, BndFlux_c):
+            boundary_flux_cs.update([(kk, f) for kk in ids])
+
+        elif isinstance(f, BndValue):
+            boundary_values.update([(kk, f) for kk in ids])
+
+        else:
+            print(type(k), type(f))
+            raise NotImplementedError(f"unknown boundary type {k} : {f}")
+
+    return boundary_flux_cs, boundary_flux_vs, boundary_values
+
+
+def boundary_validation(Model, override_boundary_dict=None):
+    if override_boundary_dict is not None:
+        boundary_dict = override_boundary_dict
+    else:
+        boundary_dict = Model.boundary
+
+    hasFlux_c = hasattr(Model, "F_c")
+    hasFlux_v = hasattr(Model, "F_v")
+
+    boundary_flux_cs, boundary_flux_vs, boundary_values = classify_boundary(
+        boundary_dict
+    )
+
+    if hasFlux_c and hasFlux_v:
+        assert len(boundary_flux_cs) == len(
+            boundary_flux_vs
+        ), "two bulk fluxes given, but one boundary fluxes provided"
+
+    if not hasFlux_c:
+        assert len(boundary_flux_cs) == 0, "No bulk Advection, but boundary flux given"
+
+    if not hasFlux_v:
+        assert len(boundary_flux_vs) == 0, "No bulk diffusion, but boundary flux given"
+
+    assert boundary_values.keys().isdisjoint(boundary_flux_cs)
+    assert boundary_values.keys().isdisjoint(boundary_flux_vs)
+
+    return boundary_flux_cs, boundary_flux_vs, boundary_values
+
+
+class BoundaryTerms:
+    def __init__(self, Model, domainDescription):
+        self.Model = Model
+
+        if isinstance(domainDescription, Domain):
+            self.domain = domainDescription
+        else:
+            self.domain = Domain(domainDescription)
+
+        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)}
+
+        self.boundary_flux_cs, self.boundary_flux_vs, self.boundary_values = (
+            boundary_validation(self.Model, override_boundary_dict=self.diffuse)
+        )
+
+        self.bV_weight = []
+        self.bF_weight = []
+
+        for model_key in self.boundary_values.keys():
+            phi_i_proj = self.domain.bndProjSDFs(model_key)
+            self.bV_weight.append(phi_i_proj)
+
+        for model_key in {*self.boundary_flux_cs.keys(), *self.boundary_flux_vs.keys()}:
+            phi_i_proj = self.domain.bndProjSDFs(model_key)
+            self.bF_weight.append(phi_i_proj)
+
+        if not self.boundary_values:
+            self.BndValueExt = None
+
+        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:
+            weight += w_func(x)
+        return weight
+
+    def _boundary_extend(self, g, x):
+        g_tmp = expand_derivatives(g)
+        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...
+    def jumpV(self, t, x, U, U1=None):
+        jdv = zero(U.ufl_shape)
+
+        if U1 is None:
+            U1 = U
+
+        for g_func, w_func in zip(self.boundary_values.values(), self.bV_weight):
+            g_tmp = g_func(t, x, U)  # g_func is a callable from self.boundary_values
+            g_ext = self._boundary_extend(g_tmp, x)
+            jdv += w_func(x) * (U1 - g_ext)
+
+        return jdv / self._total_weight(x)
+
+    def BndValueExt(self, t, x, U):
+        # called if self.BndValueExt was not set to None in __init__
+        z = zero(U.ufl_shape)
+        return -self.jumpV(t, x, U, z)
+
+    def jumpFv(self, 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 * self.domain.scaled_normal(x)
+        for g_func, w_func in zip(self.boundary_flux_vs.values(), self.bF_weight):
+            g_tmp = g_func(t, x, U, DU, self.domain.normal(x))
+            g_ext = self._boundary_extend(g_tmp, x)
+            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__
+        z = zero(DU.ufl_shape)
+        return -self.jumpFv(t, x, U, DU, z)
+
+    def BndFlux_cExt(self, t, x, U):
+        jda = zero(U.ufl_shape)
+
+        for g_func, w_func in zip(self.boundary_flux_cs.values(), self.bF_weight):
+            g_tmp = g_func(t, x, U, self.domain.normal(x))
+            g_ext = self._boundary_extend(g_tmp, x)
+            jda += w_func(x) * -g_ext * self.domain.surface_delta(x)
+
+        return -jda / self._total_weight(x)

ddfem/dune.py

@@ -0,0 +1,3 @@
+import geometry
+from geometry import dunedomain
+geometry.domain = 

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/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/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/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/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