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

ddfem/geometry/pie.py

@@ -0,0 +1,31 @@
+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
+
+
+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)
+
+    def __repr__(self):
+        return f"Pie({self.radius}, {self.angle})"
+
+    def sdf(self, x):
+        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(circle_dist, edge_dist)

ddfem/geometry/primitive_base.py

@@ -0,0 +1,279 @@
+from ufl import (
+    as_matrix,
+    as_vector,
+    conditional,
+    cos,
+    grad,
+    pi,
+    replace,
+    sin,
+    tanh,
+)
+from ufl import max_value as Max
+from ufl import min_value as Min
+
+from ufl.algorithms import expand_indices
+from ufl.algorithms.apply_algebra_lowering import apply_algebra_lowering
+from ufl.algorithms.apply_derivatives import apply_derivatives
+
+ORIGIN = as_vector([0, 0])
+
+
+class SDF:
+    def __init__(self, epsilon=None, name=None, children=None):
+        self.name = name
+        self.epsilon = epsilon
+        self.child_sdf = children if children else []
+
+    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 propgate_epsilon(self, epsilon):
+        self.epsilon = epsilon
+        for child in self.child_sdf:
+            child.propgate_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 __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):
+        if isinstance(other, (int, float)):
+            return self.scale(other)
+        raise TypeError(f"Cannot multiply a SDF with {type(other)}")
+
+    def __rmul__(self, other):
+        if isinstance(other, (int, float)):
+            return self.scale(other)
+        raise TypeError(f"Cannot multiply a SDF with {type(other)}")
+
+class BaseOperator(SDF):
+    def __init__(self, epsilon, children, *args, **kwargs):
+
+        if not epsilon and all(child.epsilon for child in children):
+            if len(children) == 1:
+                epsilon = children[0].epsilon
+            else:
+                epsilon = Min(*[child.epsilon for child in children])
+
+        super().__init__(children=children, epsilon=epsilon, *args, **kwargs)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({', '.join(map(repr, self.child_sdf))})"
+
+    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, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1, sdf2], *args, **kwargs)
+        if self.name is None:
+            self.name = f"({sdf1.name}|{sdf2.name})"
+
+    def sdf(self, x):
+        return Min(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, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1, sdf2], *args, **kwargs)
+        if self.name is None:
+            self.name = f"({sdf1.name}-{sdf2.name})"
+
+    def sdf(self, x):
+        return Max(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, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1, sdf2], *args, **kwargs)
+        if self.name is None:
+            self.name = f"({sdf1.name}&{sdf2.name})"
+
+    def sdf(self, x):
+        return Max(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, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1, sdf2], *args, **kwargs)
+        if self.name is None:
+            self.name = f"({sdf1.name}^{sdf2.name})"
+
+    def sdf(self, x):
+        a_x = self.child_sdf[0].sdf(x)
+        b_x = self.child_sdf[1].sdf(x)
+        return Max(Min(a_x, b_x), -Max(a_x, b_x))
+
+
+class Invert(BaseOperator):
+    """Inverts SDF"""
+
+    def __init__(self, sdf1, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1], *args, **kwargs)
+        if self.name is None:
+            self.name = f"(-{sdf1.name})"
+
+    def sdf(self, x):
+        return -self.child_sdf[0].sdf(x)
+
+
+class Scale(BaseOperator):
+    """Scales SDF"""
+
+    def __init__(self, sdf1, scale, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1], *args, **kwargs)
+        self.scale = scale
+        if self.name is None:
+            self.name = f"({scale}*{sdf1.name})"
+
+    def sdf(self, x):
+        return self.child_sdf[0].sdf(x / self.scale) * self.scale
+
+    def __repr__(self):
+        return f"Scale({repr(self.child_sdf[0])}, {self.scale})"
+
+
+class Rotate(BaseOperator):
+    """Rotates SDF, counterclockwise of orgin"""
+
+    def __init__(
+        self, sdf1, angle, radians=True, epsilon=None, name=None, *args, **kwargs
+    ):
+        super().__init__(epsilon=epsilon, children=[sdf1], *args, **kwargs)
+        if self.name is None:
+            self.name = f"({angle}@{sdf1.name})"
+
+        if not radians:
+            angle *= pi / 180
+        self.angle = angle
+
+    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({repr(self.child_sdf[0])}, {self.angle})"
+
+
+class Translate(BaseOperator):
+    """Translates SDF"""
+
+    def __init__(self, sdf1, vec, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1], *args, **kwargs)
+        if self.name is None:
+            self.name = f"({vec}+{sdf1.name})"
+
+        if isinstance(vec, (list, tuple)):
+            vec = as_vector(vec)
+        self.vec = vec
+
+    def sdf(self, x):
+        return self.child_sdf[0].sdf(x - self.vec)
+
+    def __repr__(self):
+        return f"Translate({repr(self.child_sdf[0])}, {self.vec})"
+
+
+class Round(BaseOperator):
+    """Rounds SDF"""
+
+    def __init__(self, sdf1, scale, epsilon=None, name=None, *args, **kwargs):
+        super().__init__(epsilon=epsilon, children=[sdf1], *args, **kwargs)
+        if self.name is None:
+            self.name = f"({scale}~{sdf1.name})"
+
+        assert scale > 0
+        self._scale = scale  # careful not to overwrite SDF.scale here
+
+    def sdf(self, x):
+        return self.child_sdf[0].sdf(x) - self._scale
+
+    def __repr__(self):
+        return f"Round({repr(self.child_sdf[0])}, {self.scale})"

ddfem/geometry/vesica.py

@@ -0,0 +1,48 @@
+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.
+        """
+        super().__init__(*args, **kwargs)
+
+        assert distance != 0, "This is a circle, use Circle 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
+
+    def __repr__(self):
+        return f"Vesica({self.radius}, {self.distance}, {self.smooth_radius})"
+
+    def sdf(self, x):
+        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,145 @@
+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)) * dx  # -div F_c v
+    if hasattr(Model, "S_e"):
+        se = (
+            inner(as_vector(Model.S_e(t, x, u, grad(u))), v) * dx
+        )  # (-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)) * dx  # -div F_v v
+
+    if hasattr(Model, "S_i"):
+        si = inner(as_vector(Model.S_i(t, x, u, grad(u))), v) * dx  # (-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
+
+    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,94 @@
+from ufl import grad, zero
+
+from .transformer_base import transformer_base
+
+
+def DDM1(OriginalModel, domainDescription):
+    Model = transformer_base(OriginalModel, domainDescription)
+
+    class DDModel(Model):
+        def sigma(t, x, U, DU=None):
+            if DU:
+                return DU
+            return grad(U)
+
+        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)
+
+        if hasattr(Model, "S_e") and hasattr(Model, "F_c"):
+            print("DDM1: 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("DDM1: S_e")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_source(t, x, U, DU)
+
+        elif hasattr(Model, "F_c"):
+            print("DDM1: 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 * (
+                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
+
+        if hasattr(Model, "S_i") and hasattr(Model, "F_v"):
+            print("DDM1: 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("DDM1: 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("DDM1: 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("DDM1: F_c")
+
+            def F_c(t, x, U):
+                return DDModel.phi(x) * Model.F_c(t, x, U)
+
+        if hasattr(Model, "F_v"):
+            print("DDM1: F_v")
+
+            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/Fitted.py

@@ -0,0 +1,67 @@
+from functools import reduce
+
+from ufl import Min, conditional, eq, grad
+
+from ..boundary import BndFlux_c, BndFlux_v, BndValue, boundary_validation
+from .transformer_base import transformer_base
+
+
+def Fitted(OriginalModel, domainDescription):
+    Model = transformer_base(OriginalModel, domainDescription)
+
+    class Fitted(Model):
+        def sigma(t, x, U, DU=None):
+            if DU:
+                return DU
+            return grad(U)
+
+        boundary = Model.BT.physical
+        bndSDFs = {k: Model.domain.bndSDFs(k) for k in Model.BT.diffuse.keys()}
+
+        def make_boundary_function(key, mv, bndSDFs=bndSDFs):
+            sdf = bndSDFs[key]
+            closest_sdf = lambda x: reduce(
+                Min,
+                ([abs(v(x)) for b, v in bndSDFs.items()]),
+            )
+
+            boundary_map = lambda x: conditional(eq(closest_sdf(x), abs(sdf(x))), 1, 0)
+
+            if isinstance(mv, BndFlux_v):
+                return BndFlux_v(
+                    lambda t, x, u, DU, n: boundary_map(x) * mv(t, x, u, DU, n),
+                )
+
+            elif isinstance(mv, BndFlux_c):
+                return BndFlux_c(
+                    lambda t, x, u, n: boundary_map(x) * mv(t, x, u, n),
+                )
+
+        boundary_flux_cs, boundary_flux_vs, boundary_values = boundary_validation(
+            Model, override_boundary_dict=Model.BT.diffuse
+        )
+
+        def make_boundary_conditional(key, bndSDFs=bndSDFs, tol=0.01):
+            sdf = bndSDFs[key]
+            return lambda x: abs(sdf(x)) < tol
+
+        for bc_key, bc_value in boundary_values.items():
+            boundary[make_boundary_conditional(bc_key)] = bc_value
+
+        for bc_key in boundary_flux_cs.keys() | boundary_flux_vs.keys():
+            if bc_key in boundary_flux_cs and bc_key in boundary_flux_vs:
+                af = make_boundary_function(bc_key, boundary_flux_cs[bc_key])
+                df = make_boundary_function(bc_key, boundary_flux_vs[bc_key])
+                boundary[make_boundary_conditional(bc_key)] = [af, df]
+
+            elif bc_key in boundary_flux_cs and bc_key not in boundary_flux_vs:
+                af = make_boundary_function(bc_key, boundary_flux_cs[bc_key])
+                boundary[make_boundary_conditional(bc_key)] = af
+
+            elif bc_key not in boundary_flux_cs and bc_key in boundary_flux_vs:
+                df = make_boundary_function(bc_key, boundary_flux_vs[bc_key])
+                boundary[make_boundary_conditional(bc_key)] = df
+            else:
+                raise ValueError()
+
+    return Fitted