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

ddfem/geometry/primitive_base.py

@@ -4,33 +4,27 @@ from ufl import (
     conditional,
     cos,
     grad,
-    max_value,
-    min_value,
     pi,
+    replace,
     sin,
     tanh,
 )
+from ufl import max_value as Max
+from ufl import min_value as Min
 
-from .helpers import smax_value, smin_value, ufl_length
+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 []
 
-        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
 
@@ -54,10 +48,10 @@ class SDF:
 
         return None
 
-    def propagate_epsilon(self, epsilon):
+    def propgate_epsilon(self, epsilon):
         self.epsilon = epsilon
         for child in self.child_sdf:
-            child.propagate_epsilon(epsilon)
+            child.propgate_epsilon(epsilon)
 
     def phi(self, x, epsilon=None):
         if not epsilon:
@@ -105,23 +99,6 @@ class SDF:
     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)
 
@@ -135,39 +112,29 @@ class SDF:
         return self.xor(other)
 
     def __mul__(self, other):
-        return self.scale(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)}")
 
-    # 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):
+    def __init__(self, epsilon, children, *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)
+            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]
 
@@ -175,50 +142,60 @@ class BaseOperator(SDF):
 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 __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 SDF.min_value(self.child_sdf[0].sdf(x), self.child_sdf[1].sdf(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, *args, **kwargs):
-        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
+    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 SDF.max_value(self.child_sdf[0].sdf(x), -self.child_sdf[1].sdf(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, *args, **kwargs):
-        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
+    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 SDF.max_value(self.child_sdf[0].sdf(x), self.child_sdf[1].sdf(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, *args, **kwargs):
-        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
+    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 SDF.max_value(SDF.min_value(a_x, b_x), -SDF.max_value(a_x, b_x))
+        return Max(Min(a_x, b_x), -Max(a_x, b_x))
 
 
 class Invert(BaseOperator):
     """Inverts SDF"""
 
-    def __init__(self, sdf1, *args, **kwargs):
-        super().__init__(children=[sdf1], *args, **kwargs)
+    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)
@@ -227,33 +204,33 @@ class Invert(BaseOperator):
 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 __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({self.scale}, {self._repr_core()})"
+        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, *args, **kwargs):
+    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
 
-        super().__init__(children=[sdf1], *args, **kwargs)
-
     def sdf(self, x):
         c = cos(self.angle)
         s = sin(self.angle)
@@ -262,77 +239,41 @@ class Rotate(BaseOperator):
         return self.child_sdf[0].sdf(r.T * x)
 
     def __repr__(self):
-        return f"Rotate({self.angle}, {self._repr_core()})"
+        return f"Rotate({repr(self.child_sdf[0])}, {self.angle})"
 
 
 class Translate(BaseOperator):
     """Translates SDF"""
 
-    def __init__(self, sdf1, vec, *args, **kwargs):
+    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
 
-        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()})"
+        return f"Translate({repr(self.child_sdf[0])}, {self.vec})"
 
 
 class Round(BaseOperator):
     """Rounds SDF"""
 
-    def __init__(self, sdf1, scale, *args, **kwargs):
+    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
 
-        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()})"
+        return f"Round({repr(self.child_sdf[0])}, {self.scale})"

ddfem/geometry/vesica.py

@@ -15,7 +15,9 @@ class Vesica(SDF):
             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"
+        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
@@ -25,24 +27,21 @@ class Vesica(SDF):
         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()})"
+        return f"Vesica({self.radius}, {self.distance}, {self.smooth_radius})"
 
     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]])
+        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(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

@@ -54,16 +54,14 @@ 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
+        f_c_model = inner(Model.F_c(t, x, u), grad(v)) * dx  # -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)
+            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
@@ -72,10 +70,10 @@ def model_ufl(Model, space, initialTime=0, DirichletBC=DirichletBC):
 
     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
+        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) # (-div F_v + S_i) v
+        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:
@@ -99,10 +97,6 @@ def model_ufl(Model, space, initialTime=0, DirichletBC=DirichletBC):
         [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,

ddfem/transformers/DDM1.py

@@ -1,19 +1,45 @@
 from ufl import grad, zero
 
-from .transformer_base import transformer
+from .transformer_base import transformer_base
 
 
-@transformer
-def DDM1(Model):
+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)
+            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_outside(t, x, U, DU):
-            return -(
+        def S_i_stability(t, x, U, DU):
+            return -Model.stabFactor * (
                 DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**3)
             )
 
@@ -27,10 +53,42 @@ def DDM1(Model):
                 diffusion = zero(U.ufl_shape)
             return diffusion
 
-        def F_c(t, x, U):
-            return DDModel.phi(x) * Model.F_c(t, x, U)
+        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))
+            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

@@ -1,41 +1,27 @@
 from functools import reduce
 
-from ufl import conditional, eq, grad, min_value
+from ufl import Min, conditional, eq, grad
 
 from ..boundary import BndFlux_c, BndFlux_v, BndValue, boundary_validation
-from ..geometry.domain import Domain
-from ..geometry.primitive_base import SDF
-from .transformer_base import pretransformer
+from .transformer_base import transformer_base
 
 
 def Fitted(OriginalModel, domainDescription):
+    Model = transformer_base(OriginalModel, domainDescription)
 
-    if isinstance(domainDescription, Domain):
-        domain = domainDescription
-    else:
-        domain = Domain(domainDescription)
-
-    condition = lambda k: isinstance(k, str) or isinstance(k, SDF)
-
-    class Fitted(OriginalModel):
+    class Fitted(Model):
         def sigma(t, x, U, DU=None):
             if DU:
                 return DU
             return grad(U)
 
-        diffuse = {k: v for k, v in OriginalModel.boundary.items() if condition(k)}
-        boundary = {k: v for k, v in OriginalModel.boundary.items() if not condition(k)}
-
-        bndSDFs = {k: domain.bndSDFs(k) for k in diffuse.keys()}
-
-        boundary_flux_cs, boundary_flux_vs, boundary_values = boundary_validation(
-            OriginalModel, override_boundary_dict=diffuse
-        )
+        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_value,
+                Min,
                 ([abs(v(x)) for b, v in bndSDFs.items()]),
             )
 
@@ -51,7 +37,11 @@ def Fitted(OriginalModel, domainDescription):
                     lambda t, x, u, n: boundary_map(x) * mv(t, x, u, n),
                 )
 
-        def make_boundary_conditional(key, bndSDFs=bndSDFs, tol=1e-2):
+        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
 

ddfem/transformers/Mix0.py

@@ -1,6 +1,6 @@
 from ufl import grad, outer
 
-from .transformer_base import transformer
+from .transformer_base import transformer_base
 
 """
 Diffusion:
@@ -45,8 +45,8 @@ paper = phi b . sigma v
 """
 
 
-@transformer
-def Mix0DDM(Model):
+def Mix0DDM(OriginalModel, domainDescription):
+    Model = transformer_base(OriginalModel, domainDescription)
 
     class DDModel(Model):
         def sigma(t, x, U, DU=None):
@@ -68,11 +68,31 @@ def Mix0DDM(Model):
                 * grad(DDModel.phi(x))
             )
 
-            convec -= DDModel.phi(x) * DDModel.BT.BndFlux_cExt(t, x, U)
+            convec += DDModel.phi(x) * DDModel.BT.BndFlux_cExt(t, x, U)
             return convec
 
-        def S_outside(t, x, U, DU):
-            return -(
+        if hasattr(Model, "S_e") and hasattr(Model, "F_c"):
+            print("Mix0DDM: 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("Mix0DDM: S_e")
+
+            def S_e(t, x, U, DU):
+                return DDModel.S_e_source(t, x, U, DU)
+
+        elif hasattr(Model, "F_c"):
+            print("Mix0DDM: 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)) ** 2
                 / (DDModel.epsilon**2)
@@ -98,10 +118,44 @@ def Mix0DDM(Model):
             diffusion += DDModel.phi(x) * DDModel.BT.jumpFv(t, x, U, DU, Fv)
             return -diffusion
 
-        def F_c(t, x, U):
-            return DDModel.phi(x) ** 2 * Model.F_c(t, x, U)
+        if hasattr(Model, "S_i") and hasattr(Model, "F_v"):
+            print("Mix0DDM: 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("Mix0DDM: 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("Mix0DDM: 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("Mix0DDM: F_c")
+
+            def F_c(t, x, U):
+                return DDModel.phi(x) ** 2 * Model.F_c(t, x, U)
+
+        if hasattr(Model, "F_v"):
+            print("Mix0DDM: F_v")
 
-        def F_v(t, x, U, DU):
-            return DDModel.phi(x) ** 2 * Model.F_v(t, x, U, DDModel.sigma(t, x, U, DU))
+            def F_v(t, x, U, DU):
+                return DDModel.phi(x) ** 2 * Model.F_v(
+                    t, x, U, DDModel.sigma(t, x, U, DU)
+                )
 
     return DDModel