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

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

@@ -0,0 +1,214 @@
+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
+
+
+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 == 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)
+        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 _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.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...
+    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)
+
+    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/geometry/__init__.py

@@ -0,0 +1,18 @@
+from .arc import Arc
+from .box import Box
+from .circle import Circle, Sphere
+from .pie import Pie
+from .vesica import Vesica
+from .primitive_base import (
+    SDF,
+    Intersection,
+    Invert,
+    Round,
+    Rotate,
+    Round,
+    Scale,
+    Subtraction,
+    Translate,
+    Union,
+    Xor,
+)

ddfem/geometry/arc.py

@@ -0,0 +1,46 @@
+from ufl import as_vector, conditional, cos, sin
+
+from .helpers import ufl_length
+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).
+    """
+    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
+
+    def __repr__(self):
+        return f"Arc({self.radius}, {self.angle}, {self.width}, {self.center})"
+
+    def sdf(self, x):
+        y0_abs = abs(x[1])
+        coords = as_vector((x[0], y0_abs))
+
+        center_radius = self.radius - self.width / 2
+
+        distance = ufl_length(x) - center_radius
+
+        edge_point = center_radius * as_vector((cos(self.angle), sin(self.angle)))
+
+        left_coords = coords - edge_point
+
+        sign_dist = conditional(
+            (sin(self.angle) * x[0]) > (cos(self.angle) * y0_abs),
+            ufl_length(left_coords),
+            abs(distance),
+        )
+
+        sign_dist -= self.width / 2
+        return sign_dist

ddfem/geometry/box.py

@@ -0,0 +1,34 @@
+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
+
+
+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
+
+    def __repr__(self):
+        return f"Box({self.width}, {self.height}, {self.center})"
+
+    def sdf(self, x):
+        # 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(w0, w1)
+
+        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

@@ -0,0 +1,37 @@
+from ufl import conditional, dot, grad, sqrt
+
+
+class Domain:
+    def __init__(self, omega):
+        self.omega = omega
+
+    def phi(self, x):
+        tol = 1e-10
+        return (1 - tol) * self.omega.phi(x) + tol
+
+    def scaled_normal(self, x):
+        return -grad(self.phi(x))
+
+    def surface_delta(self, x):
+        return sqrt(dot(self.scaled_normal(x), self.scaled_normal(x)))
+
+    def normal(self, x):
+        tol = 1e-10
+        sd = conditional(self.surface_delta(x) > tol, self.surface_delta(x), tol)
+        return self.scaled_normal(x) / sd  # grad(self.omega(x))
+
+    def bndSDFs(self, SDFname):
+        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.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.omega.boundary_projection(x))

ddfem/geometry/domain_dune.py

@@ -0,0 +1,66 @@
+import time
+
+import dune.fem
+import dune.grid
+
+from .domain import Domain
+
+
+class DomainDune(Domain):
+    def __init__(self, omega, x, gridView):
+        super().__init__(omega)
+        self.x = x
+        self.gridView = gridView
+
+        self._phi = None
+        self._bndProjSDFs = {}
+
+        self.fullSDF = self.gridFunction(self.omega(self.x), name="full-sdf")
+
+    def gridFunction(self, expr, name):
+        start_ = time.time()
+        gf = dune.fem.function.gridFunction(expr, name=name, gridView=self.gridView)
+        print(f"{name} setup: {time.time() - start_}")
+        return gf
+
+    def phi(self, x):
+        if self._phi is None:
+            p = super().phi(self.x)
+            self._phi = self.gridFunction(p, "phidomain")
+
+        return self._phi
+
+    def generate_projSDF(self, sdf):
+        projSDF = self._bndProjSDFs.get(sdf.name)
+        if projSDF is None:
+            projSDF = super().generate_projSDF(sdf)
+            gf = self.gridFunction(projSDF(self.x), f"sdfproj{sdf.name}")
+            self._bndProjSDFs[sdf.name] = lambda x: gf
+            projSDF = self._bndProjSDFs[sdf.name]
+        return projSDF
+
+    def adapt(self, level, lowerTol=-0.1, upperTol=0.1):
+        for _ in range(level):
+
+            def mark(e):
+                v = self.fullSDF(e, self.gridView.dimension * [1.0 / 3.0])
+                return (
+                    dune.grid.Marker.refine
+                    if v > lowerTol and v < upperTol
+                    else dune.grid.Marker.keep
+                )
+
+            self.gridView.hierarchicalGrid.adapt(mark)
+            print(self.gridView.size(0))
+            lowerTol /= 2
+            upperTol /= 2
+
+    def _filter(self, tolerance=1):
+        sd = self.fullSDF
+        tol = tolerance  # * self.epsilon.value: issue here with epsilon being a UFL expression due to CSG approach
+        phiFilter = (
+            lambda e: sd(e, self.gridView.dimension * [1.0 / 3.0]) < tol
+        )  # bary needs fixing for squares
+        return dune.fem.view.filteredGridView(
+            self.gridView, phiFilter, domainId=1, useFilteredIndexSet=True
+        )

ddfem/geometry/helpers.py

@@ -0,0 +1,35 @@
+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))
+    # return ufl_max(sqrt(dot(p, p) + 1e-10), 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/Max, seems to break shape Pie?
+    return Min(Max(p, minimum), maximum)
+
+
+def ufl_cross(p1, p2):
+    return p1[0] * p2[1] - p1[1] * p2[0]