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

ddfem/geometry/primitive_base.py

@@ -4,27 +4,33 @@ 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 ufl.algorithms import expand_indices
-from ufl.algorithms.apply_algebra_lowering import apply_algebra_lowering
-from ufl.algorithms.apply_derivatives import apply_derivatives
+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.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
 
@@ -48,10 +54,10 @@ class SDF:
 
         return None
 
-    def propgate_epsilon(self, epsilon):
+    def propagate_epsilon(self, epsilon):
         self.epsilon = epsilon
         for child in self.child_sdf:
-            child.propgate_epsilon(epsilon)
+            child.propagate_epsilon(epsilon)
 
     def phi(self, x, epsilon=None):
         if not epsilon:
@@ -99,6 +105,23 @@ 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)
 
@@ -112,29 +135,39 @@ class SDF:
         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)}")
+        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, epsilon, children, *args, **kwargs):
+    def __init__(self, children, epsilon=None, *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])
+            epsilon = children[0].epsilon
+            for child in children:
+                epsilon = max_value(epsilon, child.epsilon)
 
         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]
 
@@ -142,60 +175,50 @@ class BaseOperator(SDF):
 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 __init__(self, sdf1, sdf2, *args, **kwargs):
+        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
 
     def sdf(self, x):
-        return Min(self.child_sdf[0].sdf(x), self.child_sdf[1].sdf(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, 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 __init__(self, sdf1, sdf2, *args, **kwargs):
+        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
 
     def sdf(self, x):
-        return Max(self.child_sdf[0].sdf(x), -self.child_sdf[1].sdf(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, 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 __init__(self, sdf1, sdf2, *args, **kwargs):
+        super().__init__(children=[sdf1, sdf2], *args, **kwargs)
 
     def sdf(self, x):
-        return Max(self.child_sdf[0].sdf(x), self.child_sdf[1].sdf(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, 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 __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 Max(Min(a_x, b_x), -Max(a_x, b_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, 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 __init__(self, sdf1, *args, **kwargs):
+        super().__init__(children=[sdf1], *args, **kwargs)
 
     def sdf(self, x):
         return -self.child_sdf[0].sdf(x)
@@ -204,33 +227,33 @@ class Invert(BaseOperator):
 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 __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({repr(self.child_sdf[0])}, {self.scale})"
+        return f"Scale({self.scale}, {self._repr_core()})"
 
 
 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})"
-
+    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)
@@ -239,41 +262,77 @@ class Rotate(BaseOperator):
         return self.child_sdf[0].sdf(r.T * x)
 
     def __repr__(self):
-        return f"Rotate({repr(self.child_sdf[0])}, {self.angle})"
+        return f"Rotate({self.angle}, {self._repr_core()})"
 
 
 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})"
-
+    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({repr(self.child_sdf[0])}, {self.vec})"
+        return f"Translate({self.vec}, {self._repr_core()})"
 
 
 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})"
-
+    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({repr(self.child_sdf[0])}, {self.scale})"
+        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

@@ -15,9 +15,7 @@ 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.
         """
-        super().__init__(*args, **kwargs)
-
-        assert distance != 0, "This is a circle, use Circle class"
+        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
@@ -27,21 +25,24 @@ 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})"
+        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]))
+        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,14 +54,16 @@ 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
+        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) * dx
+            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
@@ -70,10 +72,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)) * dx  # -div F_v 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) * dx  # (-div F_v + S_i) v
+        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:
@@ -97,6 +99,10 @@ 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,45 +1,19 @@
 from ufl import grad, zero
 
-from .transformer_base import transformer_base
+from .transformer_base import transformer
 
 
-def DDM1(OriginalModel, domainDescription):
-    Model = transformer_base(OriginalModel, domainDescription)
-
+@transformer
+def DDM1(Model):
     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)
+            return -DDModel.BT.BndFlux_cExt(t, x, U)
 
-        def S_i_stability(t, x, U, DU):
-            return -Model.stabFactor * (
+        def S_outside(t, x, U, DU):
+            return -(
                 DDModel.BT.jumpV(t, x, U) * (1 - DDModel.phi(x)) / (DDModel.epsilon**3)
             )
 
@@ -53,42 +27,10 @@ def DDM1(OriginalModel, domainDescription):
                 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_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))
+        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,27 +1,41 @@
 from functools import reduce
 
-from ufl import Min, conditional, eq, grad
+from ufl import conditional, eq, grad, min_value
 
 from ..boundary import BndFlux_c, BndFlux_v, BndValue, boundary_validation
-from .transformer_base import transformer_base
+from ..geometry.domain import Domain
+from ..geometry.primitive_base import SDF
+from .transformer_base import pretransformer
 
 
 def Fitted(OriginalModel, domainDescription):
-    Model = transformer_base(OriginalModel, domainDescription)
 
-    class Fitted(Model):
+    if isinstance(domainDescription, Domain):
+        domain = domainDescription
+    else:
+        domain = Domain(domainDescription)
+
+    condition = lambda k: isinstance(k, str) or isinstance(k, SDF)
+
+    class Fitted(OriginalModel):
         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()}
+        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
+        )
 
         def make_boundary_function(key, mv, bndSDFs=bndSDFs):
             sdf = bndSDFs[key]
             closest_sdf = lambda x: reduce(
-                Min,
+                min_value,
                 ([abs(v(x)) for b, v in bndSDFs.items()]),
             )
 
@@ -37,11 +51,7 @@ def Fitted(OriginalModel, domainDescription):
                     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):
+        def make_boundary_conditional(key, bndSDFs=bndSDFs, tol=1e-2):
             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_base
+from .transformer_base import transformer
 
 """
 Diffusion:
@@ -45,8 +45,8 @@ paper = phi b . sigma v
 """
 
 
-def Mix0DDM(OriginalModel, domainDescription):
-    Model = transformer_base(OriginalModel, domainDescription)
+@transformer
+def Mix0DDM(Model):
 
     class DDModel(Model):
         def sigma(t, x, U, DU=None):
@@ -68,31 +68,11 @@ def Mix0DDM(OriginalModel, domainDescription):
                 * 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
 
-        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 * (
+        def S_outside(t, x, U, DU):
+            return -(
                 DDModel.BT.jumpV(t, x, U)
                 * (1 - DDModel.phi(x)) ** 2
                 / (DDModel.epsilon**2)
@@ -118,44 +98,10 @@ def Mix0DDM(OriginalModel, domainDescription):
             diffusion += DDModel.phi(x) * DDModel.BT.jumpFv(t, x, U, DU, Fv)
             return -diffusion
 
-        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_c(t, x, U):
+            return DDModel.phi(x) ** 2 * Model.F_c(t, x, U)
 
-            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