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

ddfem/__init__.py

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

ddfem/base_model.py

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

ddfem/boundary.py

@@ -6,7 +6,6 @@ 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:
@@ -23,9 +22,7 @@ class BndValue(BoundaryCondition):
             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:
+            if num_args == 2:
                 super().__init__(lambda t, x, u: value(t, x))
             elif num_args == 3:
                 super().__init__(value)
@@ -132,7 +129,7 @@ class BoundaryTerms:
         else:
             self.domain = Domain(domainDescription)
 
-        condition = lambda k: isinstance(k, str) or isinstance(k, SDF)
+        condition = lambda k: isinstance(k, str)
         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)}
 
@@ -157,11 +154,6 @@ 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:
@@ -170,7 +162,7 @@ class BoundaryTerms:
 
     def _boundary_extend(self, g, x):
         g_tmp = expand_derivatives(g)
-        return replace(g_tmp, {x: self.domain.boundary_projection(x)})
+        return replace(g_tmp, {x: self.domain.omega.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...
@@ -205,7 +197,6 @@ 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/geometry/__init__.py

@@ -1,12 +1,13 @@
 from .arc import Arc
-from .ball import Ball
 from .box import Box
+from .circle import Circle, Sphere
 from .pie import Pie
-from .plane import Plane
+from .vesica import Vesica
 from .primitive_base import (
     SDF,
     Intersection,
     Invert,
+    Round,
     Rotate,
     Round,
     Scale,
@@ -15,4 +16,3 @@ from .primitive_base import (
     Union,
     Xor,
 )
-from .vesica import Vesica

ddfem/geometry/arc.py

@@ -7,34 +7,32 @@ from .primitive_base import ORIGIN, SDF
 class Arc(SDF):
     """SDF for an arc:
 
-    Provides the signed distance function for an arc given the
-    radius, angle of opening, the width, and the center (which defaults to the origin).
+       Provides the signed distance function for an arc given the
+       radius, angle of opening, the width, and the center (which defaults to the origin).
     """
-
     def __init__(self, radius, angle, width, center=ORIGIN, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.radius = radius
         self.angle = angle  # angle of opening
         self.width = width
 
+        assert len(center) == 2
         if isinstance(center, (list, tuple)):
             center = as_vector(center)
         self.center = center
 
-        super().__init__(*args, **kwargs)
-
     def __repr__(self):
-        return f"Arc({self.radius}, {self.angle}, {self.width}, {self.center}, {self._repr_core()})"
+        return f"Arc({self.radius}, {self.angle}, {self.width}, {self.center})"
 
     def sdf(self, x):
-        # Note: Ignores z
         y0_abs = abs(x[1])
-        coords = as_vector([x[0], y0_abs])
+        coords = as_vector((x[0], y0_abs))
 
         center_radius = self.radius - self.width / 2
 
-        distance = ufl_length(coords) - center_radius
+        distance = ufl_length(x) - center_radius
 
-        edge_point = center_radius * as_vector([cos(self.angle), sin(self.angle)])
+        edge_point = center_radius * as_vector((cos(self.angle), sin(self.angle)))
 
         left_coords = coords - edge_point
 

ddfem/geometry/box.py

@@ -1,4 +1,6 @@
-from ufl import as_vector, conditional, max_value, min_value
+from ufl import as_vector, conditional
+from ufl import max_value as Max
+from ufl import min_value as Min
 
 from .helpers import ufl_length
 from .primitive_base import ORIGIN, SDF
@@ -6,28 +8,27 @@ from .primitive_base import ORIGIN, SDF
 
 class Box(SDF):
     def __init__(self, width, height, center=ORIGIN, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.width = width
         self.height = height
 
+        assert len(center) == 2
         if isinstance(center, (list, tuple)):
             center = as_vector(center)
         self.center = center
 
-        super().__init__(*args, **kwargs)
-
     def __repr__(self):
-        return f"Box({self.width}, {self.height}, {self.center}, {self._repr_core()})"
+        return f"Box({self.width}, {self.height}, {self.center})"
 
     def sdf(self, x):
-        # Note: Ignores z
         # shift x
         center_x = x - self.center
         # aux functions
         w0 = abs(center_x[0]) - self.width / 2
         w1 = abs(center_x[1]) - self.height / 2
 
-        g = max_value(w0, w1)
+        g = Max(w0, w1)
 
-        q = as_vector([max_value(w0, 0), max_value(w1, 0)])
+        q = as_vector((Max(w0, 0), Max(w1, 0)))
 
         return conditional(g > 0, ufl_length(q), g)

ddfem/geometry/circle.py

@@ -0,0 +1,39 @@
+from ufl import as_vector
+
+from .helpers import ufl_length
+from .primitive_base import ORIGIN, SDF
+
+
+class Circle(SDF):
+    def __init__(self, radius, center=ORIGIN, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.radius = radius
+
+        assert len(center) == 2
+        if isinstance(center, (list, tuple)):
+            center = as_vector(center)
+        self.center = center
+
+    def __repr__(self):
+        return f"Circle({self.radius}, {self.center})"
+
+    def sdf(self, x):
+        center_x = x - self.center
+        return ufl_length(center_x) - self.radius
+
+class Sphere(SDF):
+    def __init__(self, radius, center=ORIGIN, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.radius = radius
+
+        if isinstance(center, (list, tuple)):
+            center = as_vector(center)
+        self.center = center
+
+    def __repr__(self):
+        return f"Circle({self.radius}, {self.center})"
+
+    def sdf(self, x):
+        center_x = x - self.center
+        return ufl_length(center_x) - self.radius
+

ddfem/geometry/domain.py

@@ -1,7 +1,5 @@
 from ufl import conditional, dot, grad, sqrt
 
-from .primitive_base import SDF
-
 
 class Domain:
     def __init__(self, omega):
@@ -11,9 +9,6 @@ class Domain:
         tol = 1e-10
         return (1 - tol) * self.omega.phi(x) + tol
 
-    def chi(self, x):
-        return self.omega.chi(x)
-
     def scaled_normal(self, x):
         return -grad(self.phi(x))
 
@@ -25,25 +20,18 @@ class Domain:
         sd = conditional(self.surface_delta(x) > tol, self.surface_delta(x), tol)
         return self.scaled_normal(x) / sd  # grad(self.omega(x))
 
-    def boundary_projection(self, x):
-        return x + self.omega.projection(x)
-
-    def external_projection(self, x):
-        return x + self.omega.projection(x) * (1 - self.chi(x))
-
     def bndSDFs(self, SDFname):
-        if isinstance(SDFname, SDF):
-            SDFname = SDFname.name
-
         sdf = self.omega.search(SDFname)
         if sdf is None:
             raise ValueError(f"No SDF with name {SDFname}")
         return sdf
 
     def bndProjSDFs(self, SDFname):
-        sdf = self.bndSDFs(SDFname)
+        sdf = self.omega.search(SDFname)
+        if sdf is None:
+            raise ValueError(f"No SDF with name {SDFname}")
         return self.generate_projSDF(sdf)
 
     def generate_projSDF(self, sdf):
         w = lambda x: sdf.phi(x) * (1 - sdf.phi(x))
-        return lambda x: w(self.boundary_projection(x))
+        return lambda x: w(self.omega.boundary_projection(x))

ddfem/geometry/domain_dune.py

@@ -13,8 +13,6 @@ class DomainDune(Domain):
         self.gridView = gridView
 
         self._phi = None
-        self._bndProj = None
-        self._extProj = None
         self._bndProjSDFs = {}
 
         self.fullSDF = self.gridFunction(self.omega(self.x), name="full-sdf")
@@ -32,20 +30,6 @@ class DomainDune(Domain):
 
         return self._phi
 
-    def boundary_projection(self, x):
-        if self._bndProj is None:
-            p = super().boundary_projection(self.x)
-            self._bndProj = self.gridFunction(p, "bndproj")
-
-        return self._bndProj
-
-    def external_projection(self, x):
-        if self._extProj is None:
-            p = super().external_projection(self.x)
-            self._extProj = self.gridFunction(p, "extproj")
-
-        return self._extProj
-
     def generate_projSDF(self, sdf):
         projSDF = self._bndProjSDFs.get(sdf.name)
         if projSDF is None:

ddfem/geometry/helpers.py

@@ -1,19 +1,12 @@
-from ufl import conditional, dot, max_value, min_value, sqrt, ln, exp
-
-
-# https://en.wikipedia.org/wiki/Smooth_maximum, https://en.wikipedia.org/wiki/LogSumExp
-def smax_value(a, b, s):
-    return 1 / s * ln(exp(s * a) + exp(s * b))
-
-
-def smin_value(a, b, s):
-    return smax_value(a, b, -s)
+from ufl import conditional, dot, sqrt
+from ufl import max_value as Max
+from ufl import min_value as Min
 
 
 def ufl_length(p):
-    return sqrt(dot(p, p) + 1e-10)
-    # return max_value(sqrt(dot(p, p)), 1e-10)
     # return sqrt(dot(p, p))
+    # return ufl_max(sqrt(dot(p, p) + 1e-10), 1e-10)
+    return sqrt(dot(p, p))
 
 
 def ufl_sign(p):
@@ -27,15 +20,15 @@ def ufl_clamp(p, minimum, maximum):
     if isinstance(p, (float, int)):
         return min(max(p, minimum), maximum)
 
-    # def ufl_max(p1, p2):
-    #     return conditional(p2 < p1, p1, p2)
+    def ufl_max(p1, p2):
+        return conditional(p2 < p1, p1, p2)
 
-    # def ufl_min(p1, p2):
-    #     return conditional(p1 < p2, p1, p2)
+    def ufl_min(p1, p2):
+        return conditional(p1 < p2, p1, p2)
 
-    # return ufl_min(ufl_max(p, minimum), maximum)
-    # # using min_value/max_value, seems to break shape Pie?
-    return min_value(max_value(p, minimum), maximum)
+    return ufl_min(ufl_max(p, minimum), maximum)
+    # using Min/Max, seems to break shape Pie?
+    return Min(Max(p, minimum), maximum)
 
 
 def ufl_cross(p1, p2):

ddfem/geometry/pie.py

@@ -1,4 +1,6 @@
-from ufl import as_vector, cos, dot, max_value, min_value, sin
+from ufl import as_vector, cos, dot, sin
+from ufl import max_value as Max
+from ufl import min_value as Min
 
 from .helpers import ufl_clamp, ufl_cross, ufl_length, ufl_sign
 from .primitive_base import ORIGIN, SDF
@@ -6,18 +8,16 @@ from .primitive_base import ORIGIN, SDF
 
 class Pie(SDF):
     def __init__(self, radius, angle, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.radius = radius
         self.angle = angle  # angle of cicle (not opening)
 
-        super().__init__(*args, **kwargs)
-
     def __repr__(self):
-        return f"Pie({self.radius}, {self.angle}, {self._repr_core()})"
+        return f"Pie({self.radius}, {self.angle})"
 
     def sdf(self, x):
-        # Note: Ignores z
         x0_abs = abs(x[0])
-        coords = as_vector([x0_abs, x[1]])
+        coords = as_vector((x0_abs, x[1]))
 
         circle_dist = ufl_length(coords) - self.radius
 
@@ -28,4 +28,4 @@ class Pie(SDF):
         rejc = coords - proj
         edge_dist = ufl_length(rejc) * ufl_sign(ufl_cross(coords, trig))
 
-        return max_value(circle_dist, edge_dist)
+        return Max(circle_dist, edge_dist)