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

ddfem/geometry/helpers.py

@@ -0,0 +1,42 @@
+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)
+
+
+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))
+
+
+def ufl_sign(p):
+    if isinstance(p, (float, int)):
+        return 1 if p > 0 else -1
+
+    return conditional(p > 0, 1, -1)
+
+
+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_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)
+
+
+def ufl_cross(p1, p2):
+    return p1[0] * p2[1] - p1[1] * p2[0]

ddfem/geometry/pie.py

@@ -0,0 +1,31 @@
+from ufl import as_vector, cos, dot, max_value, min_value, sin
+
+from .helpers import ufl_clamp, ufl_cross, ufl_length, ufl_sign
+from .primitive_base import ORIGIN, SDF
+
+
+class Pie(SDF):
+    def __init__(self, radius, angle, *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()})"
+
+    def sdf(self, x):
+        # Note: Ignores z
+        x0_abs = abs(x[0])
+        coords = as_vector([x0_abs, x[1]])
+
+        circle_dist = ufl_length(coords) - self.radius
+
+        trig = as_vector([sin(self.angle / 2), cos(self.angle / 2)])
+
+        # projection of coords on to trig, clamped to within circle
+        proj = ufl_clamp(dot(coords, trig), 0, self.radius) * trig
+        rejc = coords - proj
+        edge_dist = ufl_length(rejc) * ufl_sign(ufl_cross(coords, trig))
+
+        return max_value(circle_dist, edge_dist)

ddfem/geometry/plane.py

@@ -0,0 +1,20 @@
+from ufl import as_vector, dot
+
+from .primitive_base import SDF
+
+
+class Plane(SDF):
+    def __init__(self, normal, offset, *args, **kwargs):
+        if isinstance(normal, (list, tuple)):
+            normal = as_vector(normal)
+        self.normal = normal
+
+        self.offset = offset
+
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        return f"Plane({self.normal}, {self.offset}, {self._repr_core()})"
+
+    def sdf(self, x):
+        return dot(x, self.normal) + self.offset

ddfem/geometry/primitive_base.py

@@ -0,0 +1,338 @@
+from ufl import (
+    as_matrix,
+    as_vector,
+    conditional,
+    cos,
+    grad,
+    max_value,
+    min_value,
+    pi,
+    sin,
+    tanh,
+)
+
+from .helpers import smax_value, smin_value, ufl_length
+
+ORIGIN = as_vector([0, 0])
+
+
+class SDF:
+    def __init__(self, epsilon=None, name=None, children=None):
+        self.epsilon = epsilon
+        self.child_sdf = children if children else []
+
+        self.name = name
+        if self.name is None:
+            self.name = repr(self)
+
+    def _repr_core(self):
+        return f"epsilon={self.epsilon}, name={self.name}, children={self.child_sdf}"
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._repr_core()})"
+
+    def sdf(self, x):
+        raise NotImplementedError
+
+    def __call__(self, x):
+        return self.sdf(x)
+
+    def search(self, child_name):
+        if self.name == child_name:
+            return self
+
+        queue = self.child_sdf.copy()
+
+        while queue:
+            current_child = queue.pop(0)
+
+            if current_child.name == child_name:
+                return current_child
+
+            for child in current_child.child_sdf:
+                queue.append(child)
+
+        return None
+
+    def propagate_epsilon(self, epsilon):
+        self.epsilon = epsilon
+        for child in self.child_sdf:
+            child.propagate_epsilon(epsilon)
+
+    def phi(self, x, epsilon=None):
+        if not epsilon:
+            epsilon = self.epsilon
+            assert self.epsilon, "Must define epsilon"
+        return 0.5 * (1 - tanh((3 * self.sdf(x) / epsilon)))
+
+    def chi(self, x):
+        return conditional(self.sdf(x) <= 0, 1, 0)
+
+    def projection(self, x):
+        return -grad(self.sdf(x)) * self.sdf(x)
+
+    def boundary_projection(self, x):
+        return x + self.projection(x)
+
+    def external_projection(self, x):
+        # return self.chi(x) * x + self.boundary_projection(x) * (1 - self.chi(x))
+        return x + self.projection(x) * (1 - self.chi(x))
+
+    def union(self, other):
+        return Union(self, other)
+
+    def subtraction(self, other):
+        return Subtraction(self, other)
+
+    def intersection(self, other):
+        return Intersection(self, other)
+
+    def xor(self, other):
+        return Xor(self, other)
+
+    def scale(self, sc):
+        return Scale(self, sc)
+
+    def invert(self):
+        return Invert(self)
+
+    def rotate(self, angle, radians=True):
+        return Rotate(self, angle, radians)
+
+    def translate(self, vector):
+        return Translate(self, vector)
+
+    def round(self, sc):
+        return Round(self, sc)
+
+    def extrude(self, length, split_ends=False):
+        if split_ends:
+            from .plane import Plane
+
+            ext = Extrusion(self, length * 2, name=f"{self.name}_ext")
+            ext = Translate(ext, [0, 0, -length / 2], name=f"{self.name}_sides")
+            bot = Plane([0, 0, -1], 0, name=f"{self.name}_bot")
+            top = Plane([0, 0, 1], -length, name=f"{self.name}_top")
+            z_interval = bot & top
+            ext = ext & z_interval
+        else:
+            return Extrusion(self, length, name=f"{self.name}_ext")
+        return ext
+
+    def revolve(self, offset=0, axis="x"):
+        return Revolution(self, offset, axis)
+
+    def __or__(self, other):
+        return self.union(other)
+
+    def __and__(self, other):
+        return self.intersection(other)
+
+    def __sub__(self, other):
+        return self.subtraction(other)
+
+    def __xor__(self, other):
+        return self.xor(other)
+
+    def __mul__(self, other):
+        return self.scale(other)
+
+    def __rmul__(self, other):
+        if isinstance(other, (int, float)):
+            return self.scale(other)
+        raise TypeError(f"Cannot multiply a SDF with {type(other)}")
+
+    # possibly use a 'Constant' but then multiple changes will influence previous usage?
+    smoothing = None
+
+    def max_value(a, b):
+        if SDF.smoothing is None:
+            return max_value(a, b)
+        else:
+            return smax_value(a, b, SDF.smoothing)
+
+    def min_value(a, b):
+        if SDF.smoothing is None:
+            return min_value(a, b)
+        else:
+            return smin_value(a, b, SDF.smoothing)
+
+
+class BaseOperator(SDF):
+    def __init__(self, children, epsilon=None, *args, **kwargs):
+
+        if not epsilon and all(child.epsilon for child in children):
+            epsilon = children[0].epsilon
+            for child in children:
+                epsilon = max_value(epsilon, child.epsilon)
+
+        super().__init__(children=children, epsilon=epsilon, *args, **kwargs)
+
+    def __getitem__(self, key):
+        return self.child_sdf[key]
+
+
+class Union(BaseOperator):
+    """Union of two SDFs (OR) - not perfect(negative)"""
+
+    def __init__(self, sdf1, sdf2, *args, **kwargs):
+        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
+
+    def sdf(self, x):
+        return SDF.min_value(self.child_sdf[0].sdf(x), self.child_sdf[1].sdf(x))
+
+
+class Subtraction(BaseOperator):
+    """Subtraction of two SDFs (difference) - not perfect"""
+
+    def __init__(self, sdf1, sdf2, *args, **kwargs):
+        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
+
+    def sdf(self, x):
+        return SDF.max_value(self.child_sdf[0].sdf(x), -self.child_sdf[1].sdf(x))
+
+
+class Intersection(BaseOperator):
+    """Intersection of two SDFs (AND) - not perfect"""
+
+    def __init__(self, sdf1, sdf2, *args, **kwargs):
+        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
+
+    def sdf(self, x):
+        return SDF.max_value(self.child_sdf[0].sdf(x), self.child_sdf[1].sdf(x))
+
+
+class Xor(BaseOperator):
+    """Xor of two SDFs (AND) - perfect"""
+
+    def __init__(self, sdf1, sdf2, *args, **kwargs):
+        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
+
+    def sdf(self, x):
+        a_x = self.child_sdf[0].sdf(x)
+        b_x = self.child_sdf[1].sdf(x)
+        return SDF.max_value(SDF.min_value(a_x, b_x), -SDF.max_value(a_x, b_x))
+
+
+class Invert(BaseOperator):
+    """Inverts SDF"""
+
+    def __init__(self, sdf1, *args, **kwargs):
+        super().__init__(children=[sdf1], *args, **kwargs)
+
+    def sdf(self, x):
+        return -self.child_sdf[0].sdf(x)
+
+
+class Scale(BaseOperator):
+    """Scales SDF"""
+
+    def __init__(self, sdf1, scale, *args, **kwargs):
+        if not isinstance(scale, (int, float)):
+            raise TypeError(f"Cannot scale a SDF with {type(scale)}")
+        elif not scale > 0:
+            raise ValueError("Cannot scale a SDF with nonpositive")
+        else:
+            self.scale = scale
+
+        super().__init__(children=[sdf1], *args, **kwargs)
+
+    def sdf(self, x):
+        return self.child_sdf[0].sdf(x / self.scale) * self.scale
+
+    def __repr__(self):
+        return f"Scale({self.scale}, {self._repr_core()})"
+
+
+class Rotate(BaseOperator):
+    """Rotates SDF, counterclockwise of orgin"""
+
+    def __init__(self, sdf1, angle, radians=True, *args, **kwargs):
+        if not radians:
+            angle *= pi / 180
+        self.angle = angle
+
+        super().__init__(children=[sdf1], *args, **kwargs)
+
+    def sdf(self, x):
+        c = cos(self.angle)
+        s = sin(self.angle)
+
+        r = as_matrix(((c, -s), (s, c)))
+        return self.child_sdf[0].sdf(r.T * x)
+
+    def __repr__(self):
+        return f"Rotate({self.angle}, {self._repr_core()})"
+
+
+class Translate(BaseOperator):
+    """Translates SDF"""
+
+    def __init__(self, sdf1, vec, *args, **kwargs):
+        if isinstance(vec, (list, tuple)):
+            vec = as_vector(vec)
+        self.vec = vec
+
+        super().__init__(children=[sdf1], *args, **kwargs)
+
+    def sdf(self, x):
+        return self.child_sdf[0].sdf(x - self.vec)
+
+    def __repr__(self):
+        return f"Translate({self.vec}, {self._repr_core()})"
+
+
+class Round(BaseOperator):
+    """Rounds SDF"""
+
+    def __init__(self, sdf1, scale, *args, **kwargs):
+        assert scale > 0
+        self._scale = scale  # careful not to overwrite SDF.scale here
+
+        super().__init__(children=[sdf1], *args, **kwargs)
+
+    def sdf(self, x):
+        return self.child_sdf[0].sdf(x) - self._scale
+
+    def __repr__(self):
+        return f"Round({self._scale}, {self._repr_core()})"
+
+
+class Extrusion(BaseOperator):
+    """Extrude SDF"""
+
+    def __init__(self, sdf1, extrude_length, *args, **kwargs):
+        self.extrude_length = extrude_length
+
+        super().__init__(children=[sdf1], *args, **kwargs)
+
+    def sdf(self, x):
+        d = self.child_sdf[0].sdf(as_vector([x[0], x[1]]))
+        w = abs(x[2]) - self.extrude_length
+        return SDF.min_value(SDF.max_value(d, w), 0) + ufl_length(
+            as_vector([SDF.max_value(d, 0), SDF.max_value(w, 0)])
+        )
+
+    def __repr__(self):
+        return f"Extrusion({self.extrude_length}, {self._repr_core()})"
+
+
+class Revolution(BaseOperator):
+    """Revolve SDF"""
+
+    def __init__(self, sdf1, offset, axis, *args, **kwargs):
+        self.offset = offset
+        assert axis in ["x", "y"], "Can only revolve around the x or y axis"
+        self.axis = axis
+
+        super().__init__(children=[sdf1], *args, **kwargs)
+
+    def sdf(self, x):
+        if self.axis == "x":
+            q = as_vector([x[0], ufl_length(as_vector([x[1], x[2]])) - self.offset])
+        elif self.axis == "y":
+            q = as_vector([ufl_length(as_vector([x[0], x[2]])) - self.offset, x[1]])
+        return self.child_sdf[0].sdf(q)
+
+    def __repr__(self):
+        return f"Revolution({self.offset}, {self._repr_core()})"

ddfem/geometry/vesica.py

@@ -0,0 +1,49 @@
+from ufl import as_vector, conditional, sqrt
+
+from .helpers import ufl_length, ufl_sign
+from .primitive_base import ORIGIN, SDF
+
+
+class Vesica(SDF):
+    def __init__(self, radius, distance, smooth_radius, *args, **kwargs):
+        """Generates sign distance function and domain coordinates for a Vesica.
+        i.e. Union of two circles.
+        Centred at (0,0)
+
+        Args:
+            radius (float,): Radius of each circle.
+            distance (float): Distance of circle center from y-axis.
+            smooth_radius (float): Smoothing of domain,so no sharp corner when circles connection.
+        """
+        assert distance != 0, "This is a circle, use Ball class"
+        assert distance < radius, "No shape exists, circles cancel each other out"
+        assert (
+            smooth_radius * distance < 0
+        ), "For a smooth edge, smooth_radius needs to be opposite sign of distance"
+
+        self.radius = radius
+        self.distance = distance
+        self.smooth_radius = smooth_radius
+
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        return f"Vesica({self.radius}, {self.distance}, {self.smooth_radius}, {self._repr_core()})"
+
+    def sdf(self, x):
+        # Note: Ignores z
+        x0_abs = abs(x[0])
+        x1_abs = abs(x[1])
+
+        b = sqrt((self.radius + self.smooth_radius) ** 2 - self.distance**2)
+
+        circle_coords = as_vector([x0_abs + self.distance, x[1]])
+
+        return (
+            conditional(
+                (x1_abs - b) * self.distance > x0_abs * b,
+                ufl_length(as_vector([x0_abs, x1_abs - b])) * ufl_sign(self.distance),
+                ufl_length(circle_coords) - self.radius - self.smooth_radius,
+            )
+            + self.smooth_radius
+        )

ddfem/model2ufl.py

@@ -0,0 +1,151 @@
+from ufl import (
+    FacetNormal,
+    SpatialCoordinate,
+    TestFunction,
+    TrialFunction,
+    as_vector,
+    ds,
+    dx,
+    grad,
+    inner,
+)
+
+from .boundary import boundary_validation
+
+
+def boundaries_ufl(Model, space, t):
+    boundary_flux_cs, boundary_flux_vs, boundary_values = boundary_validation(Model)
+
+    u = TrialFunction(space)
+    n = FacetNormal(space.cell())
+    x = SpatialCoordinate(space.cell())
+
+    boundary_flux_cs = {
+        (k(x) if callable(k) else k): f(t, x, u, n) for k, f in boundary_flux_cs.items()
+    }
+    boundary_flux_vs = {
+        (k(x) if callable(k) else k): f(t, x, u, grad(u), n)
+        for k, f in boundary_flux_vs.items()
+    }
+    boundary_values = {
+        (k(x) if callable(k) else k): f(t, x, u) for k, f in boundary_values.items()
+    }
+    hasBoundaryValue = {k: True for k in boundary_values.keys()}
+
+    return (
+        boundary_flux_cs,
+        boundary_flux_vs,
+        boundary_values,
+        hasBoundaryValue,
+    )
+
+
+class DirichletBC:
+    def __init__(self, space, value, domain=None):
+        self.space = space
+        self.value = value
+        self.domain = domain
+
+    def __str__(self):
+        return str(self.value) + str(self.domain)
+
+
+def model_ufl(Model, space, initialTime=0, DirichletBC=DirichletBC):
+    u = TrialFunction(space)
+    v = TestFunction(space)
+    x = SpatialCoordinate(space.cell())
+
+    t = initialTime
+
+    f_c_model = None
+    if hasattr(Model, "F_c"):
+        f_c_model = inner(Model.F_c(t, x, u), grad(v)) # -div F_c v
+    if hasattr(Model, "S_e"):
+        # there is an issue with S_e returning 'zero' and zero*dx leading to UFL error
+        se = (
+            inner(as_vector(Model.S_e(t, x, u, grad(u))), v)
+        )  # (-div F_c + S_e) * v
+        if f_c_model is not None:
+            f_c_model += se
+        else:
+            f_c_model = se
+
+    f_v_model = None
+    if hasattr(Model, "F_v"):
+        f_v_model = inner(Model.F_v(t, x, u, grad(u)), grad(v)) # -div F_v v
+
+    if hasattr(Model, "S_i"):
+        si = inner(as_vector(Model.S_i(t, x, u, grad(u))), v) # (-div F_v + S_i) v
+        if f_v_model is not None:
+            f_v_model += si
+        else:
+            f_v_model = si
+
+    # need to extract boundary information from Model
+    (
+        boundary_flux_cs,
+        boundary_flux_vs,
+        boundary_values,
+        hasBoundaryValue,
+    ) = boundaries_ufl(Model, space, t)
+
+    dirichletBCs = [
+        DirichletBC(space, item[1], item[0]) for item in boundary_values.items()
+    ]
+    boundary_flux_vs = -sum(
+        [inner(item[1], v) * ds(item[0]) for item in boundary_flux_vs.items()]
+    )  # keep all forms on left hand side
+    boundary_flux_cs = -sum(
+        [inner(item[1], v) * ds(item[0]) for item in boundary_flux_cs.items()]
+    )  # keep all forms on left hand side
+
+    if f_c_model:
+        f_c_model = f_c_model * dx
+    if f_v_model:
+        f_v_model = f_v_model * dx
+    return (
+        f_c_model,
+        f_v_model,
+        {
+            "dirichletBCs": dirichletBCs,
+            "boundary_flux_cs": boundary_flux_cs,
+            "boundary_flux_vs": boundary_flux_vs,
+            "hasBoundaryValue": hasBoundaryValue,
+        },
+    )
+
+
+def model2ufl(
+    Model, space, initialTime=0, DirichletBC=DirichletBC, *, returnFull=False
+):
+    class M(Model):
+        if hasattr(Model, "S_e"):
+
+            def S_e(t, x, U, DU):
+                return -Model.S_e(t, x, U, DU)
+
+        if hasattr(Model, "S_i"):
+
+            def S_i(t, x, U, DU):
+                return -Model.S_i(t, x, U, DU)
+
+        if hasattr(Model, "F_c"):
+
+            def F_c(t, x, U):
+                return -Model.F_c(t, x, U)
+
+    f_c_model, f_v_model, boundary_model = model_ufl(M, space, initialTime, DirichletBC)
+    boundary_model["boundary_flux_cs"] = -boundary_model["boundary_flux_cs"]
+    form = boundary_model["boundary_flux_cs"] + boundary_model["boundary_flux_vs"]
+    if f_c_model is not None:
+        form += f_c_model
+    if f_v_model is not None:
+        form += f_v_model
+
+    if not returnFull:
+        return [form == 0, *boundary_model["dirichletBCs"]]
+    else:
+        boundary_model["f_c_model"] = f_c_model
+        boundary_model["f_v_model"] = f_v_model
+        boundary_model["form"] = form
+        return boundary_model

ddfem/transformers/DDM1.py

@@ -0,0 +1,36 @@
+from ufl import grad, zero
+
+from .transformer_base import transformer
+
+
+@transformer
+def DDM1(Model):
+    class DDModel(Model):
+        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):
+            return -DDModel.BT.BndFlux_cExt(t, x, U)
+
+        def S_outside(t, x, U, DU):
+            return -(
+                DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**3)
+            )
+
+        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):
+            if DDModel.BT.BndFlux_vExt is not None:
+                diffusion = DDModel.BT.BndFlux_vExt(t, x, U, DU)
+            else:
+                diffusion = zero(U.ufl_shape)
+            return diffusion
+
+        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))
+
+    return DDModel