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

ddfem/examples/triple_circle_beam.py

@@ -0,0 +1,208 @@
+import numpy as np
+
+try:
+    import pygmsh
+except ImportError:
+    pygmsh = None
+
+try:
+    import dune
+except ImportError:
+    print(
+        """
+Example code requires dune to run. To install run
+pip install dune-fem
+    """
+    )
+
+from dune.alugrid import aluConformGrid as leafGridView
+from dune.fem import adapt, mark, markNeighbors
+from dune.fem.function import gridFunction
+from dune.fem.space import lagrange
+from dune.fem.utility import gridWidth
+from dune.fem.view import adaptiveLeafGridView
+from dune.grid import cartesianDomain
+from dune.ufl import Constant, Space
+from ufl import SpatialCoordinate, as_vector, sqrt
+
+from ddfem import geometry as gm
+from ddfem.geometry.domain_dune import DomainDune
+
+
+def getDomain(initialRefine, version, adaptLevels=0, epsFactor=4.5, dirichlet=True):
+
+    # gm.SDF.smoothing = 50
+
+    shiftx, shifty = sqrt(2) * 1e-6, sqrt(3) * 1e-6
+
+    if dirichlet:
+        domain_range = [
+            [-0.8 + shiftx, -0.8 + shifty, 0.1],  # -0.5
+            [0.8 + shiftx, 0.8 + shifty, 3.3],  #  3.2
+        ]
+        initial_gridsize = [60, 60, 60]
+    else:
+        domain_range = [
+            [-0.8 + shiftx, -0.8 + shifty, 0.0 - 0.5],
+            [0.8 + shiftx, 0.8 + shifty, 3.2 + 0.5],
+        ]
+        initial_gridsize = [60, 60, 80]
+    initial_gridsize = [i * 2**initialRefine for i in initial_gridsize]
+    h = sqrt(
+        ((domain_range[1][0] - domain_range[0][0]) / initial_gridsize[0]) ** 2
+        + ((domain_range[1][1] - domain_range[0][1]) / initial_gridsize[1]) ** 2
+        + ((domain_range[1][2] - domain_range[0][2]) / initial_gridsize[2]) ** 2
+    )
+
+    def get_eps(h):
+        return Constant(epsFactor * h * 0.5 ** (adaptLevels / 3), "epsilon")
+
+    balls = [
+        [0.3, [0.15, 0.15], "b1"],
+        [0.3, [-0.15, -0.15], "b2"],
+        [0.4, [0, 0], "b3"],
+    ]
+
+    b = [gm.Ball(c[0], c[1], name=c[2]) for c in balls]
+    sdfs = [b[0] | b[1], b[2]]
+    face_2d = sdfs[0] & sdfs[1]
+
+    face_2d.name = "beam"
+
+    if dirichlet:
+        length = 4
+    else:
+        length = 3.2
+    omega = face_2d.extrude(length, True)
+    omega.name = "full"
+
+    h_max = h * 3
+    h_min = h / 2
+    radius = 3
+
+    x = SpatialCoordinate(Space(3))
+    sdf = omega(x)
+
+    def spacing(x, y, z, epsilon):
+        r_min = epsilon.value
+        r_max = radius * epsilon.value
+        dist = np.abs(sdf((x, y, z)))
+        if dist <= r_min:
+            return geom.characteristic_length_min
+        elif dist >= r_max:
+            return geom.characteristic_length_max
+        else:
+            # Linear
+            m = (geom.characteristic_length_max - geom.characteristic_length_min) / (
+                r_max - r_min
+            )
+            return m * (dist - r_min) + geom.characteristic_length_min
+
+    if version == "cartesian":
+        domain = cartesianDomain(*domain_range, initial_gridsize)
+        epsilon = get_eps(h)
+
+    elif version == "fitted":
+        if pygmsh is None:
+            raise AttributeError("'fitted' requires install pygmsh")
+        with pygmsh.occ.Geometry() as geom:
+            geom.characteristic_length_max = h_max
+            geom.characteristic_length_min = h_min
+            epsilon = get_eps(h_min)
+
+            disks = [geom.add_disk([c[1][0], c[1][1], 0.0], c[0]) for c in balls]
+
+            ds = geom.boolean_union([disks[0], disks[1]])
+            shape = geom.boolean_intersection([ds, disks[2]])
+            geom.extrude(shape, [0, 0, length])
+
+            geom.set_mesh_size_callback(
+                lambda dim, tag, x, y, z, lc: spacing(x, y, z, epsilon),
+                ignore_other_mesh_sizes=True,
+            )
+            mesh = geom.generate_mesh()
+            points, cells = mesh.points, mesh.cells_dict
+            domain = {
+                "vertices": points[:,].astype(float),
+                "simplices": cells["tetra"].astype(int),
+            }
+
+    elif version == "dune_adaptive":
+        gridsize = [int(j * h / h_max) for j in initial_gridsize]
+        domain = cartesianDomain(*domain_range, gridsize)
+
+    elif version == "gmsh_adaptive":
+        if pygmsh is None:
+            raise AttributeError("'gmsh_adaptive' requires install pygmsh")
+        with pygmsh.occ.Geometry() as geom:
+            geom.characteristic_length_max = h_max
+            geom.characteristic_length_min = h_min
+            epsilon = get_eps(h_min)
+
+            geom.add_box(
+                [0.0, 0.0, 0.0],
+                [
+                    domain_range[1][0] - domain_range[0][0],
+                    domain_range[1][1] - domain_range[0][1],
+                    domain_range[1][2] - domain_range[0][2],
+                ],
+            )
+
+            geom.set_mesh_size_callback(
+                lambda dim, tag, x, y, z, lc: spacing(x, y, z, epsilon),
+                ignore_other_mesh_sizes=True,
+            )
+            mesh = geom.generate_mesh()
+            points, cells = mesh.points, mesh.cells_dict
+            domain = {
+                "vertices": points[:,].astype(float),
+                "simplices": cells["tetra"].astype(int),
+            }
+    else:
+        raise ValueError("invalid mesh type")
+
+    gridView = adaptiveLeafGridView(leafGridView(domain))
+    # return gridView, None
+
+    if version == "dune_adaptive":
+        # omega.epsilon = get_eps(h)
+        omega.epsilon = get_eps(h_min)
+        omega.epsilon.value *= radius
+        epsilon_value = omega.epsilon.value
+
+        marker = mark
+
+        refinements = int(3 * np.log2(h_max / h_min))
+        region = gridFunction(
+            omega.phi(x) * (1 - omega.phi(x)), gridView=gridView
+        )  # interface
+
+        for j in range(1, refinements + 1):
+            print("refining:", j, gridView.size(2), flush=True)
+            if gridView.size(2) > 5e5:
+                assert j == refinements
+                j -= 1
+                break
+            omega.epsilon.value = epsilon_value * j / refinements
+            marker(region, 0.00247262315663, maxLevel=refinements)  # epsilon
+            adapt(gridView.hierarchicalGrid)
+
+            # markNeighbors(region, 0.1, maxLevel=refinements)
+            # marker(region, 0.2, maxLevel=refinements)
+            # adapt(gridView.hierarchicalGrid)
+            # omega.epsilon.value = omega.epsilon.value * 2**(-1/3)
+
+        h_min = h_max * 0.5 ** (j / 3)
+        epsilon = get_eps(h_min)
+
+    omega.propagate_epsilon(epsilon)
+    domain = omega
+
+    domain = DomainDune(omega, x, gridView)
+    # domain.adapt(level=adaptLevels)
+
+    print(
+        f"h_max={h_max}, h_min={h_min * 0.5 ** (adaptLevels / 3)}, epsilon={epsilon.value}"
+    )
+
+    return gridView, domain

ddfem/geometry/__init__.py

@@ -1,13 +1,12 @@
 from .arc import Arc
+from .ball import Ball
 from .box import Box
-from .circle import Circle, Sphere
 from .pie import Pie
-from .vesica import Vesica
+from .plane import Plane
 from .primitive_base import (
     SDF,
     Intersection,
     Invert,
-    Round,
     Rotate,
     Round,
     Scale,
@@ -16,3 +15,4 @@ from .primitive_base import (
     Union,
     Xor,
 )
+from .vesica import Vesica

ddfem/geometry/arc.py

@@ -7,32 +7,34 @@ 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).
+    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
 
+        super().__init__(*args, **kwargs)
+
     def __repr__(self):
-        return f"Arc({self.radius}, {self.angle}, {self.width}, {self.center})"
+        return f"Arc({self.radius}, {self.angle}, {self.width}, {self.center}, {self._repr_core()})"
 
     def sdf(self, x):
+        # Note: Ignores z
         y0_abs = abs(x[1])
-        coords = as_vector((x[0], y0_abs))
+        coords = as_vector([x[0], y0_abs])
 
         center_radius = self.radius - self.width / 2
 
-        distance = ufl_length(x) - center_radius
+        distance = ufl_length(coords) - center_radius
 
-        edge_point = center_radius * as_vector((cos(self.angle), sin(self.angle)))
+        edge_point = center_radius * as_vector([cos(self.angle), sin(self.angle)])
 
         left_coords = coords - edge_point
 

ddfem/geometry/ball.py

@@ -0,0 +1,24 @@
+from ufl import as_vector
+
+from .helpers import ufl_length
+from .primitive_base import ORIGIN, SDF
+
+
+class Ball(SDF):
+    def __init__(self, radius, center=ORIGIN, *args, **kwargs):
+        self.radius = radius
+
+        if isinstance(center, (list, tuple)):
+            center = as_vector(center)
+        self.center = center
+
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        return f"Ball({self.radius}, {self.center}, {self._repr_core()})"
+
+    def sdf(self, x):
+        # Note ignore z, if center 2d
+        xx = as_vector([x[i] for i in range(len(self.center))])
+        center_x = xx - self.center
+        return ufl_length(center_x) - self.radius

ddfem/geometry/box.py

@@ -1,6 +1,4 @@
-from ufl import as_vector, conditional
-from ufl import max_value as Max
-from ufl import min_value as Min
+from ufl import as_vector, conditional, max_value, min_value
 
 from .helpers import ufl_length
 from .primitive_base import ORIGIN, SDF
@@ -8,27 +6,28 @@ 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
 
+        super().__init__(*args, **kwargs)
+
     def __repr__(self):
-        return f"Box({self.width}, {self.height}, {self.center})"
+        return f"Box({self.width}, {self.height}, {self.center}, {self._repr_core()})"
 
     def sdf(self, x):
+        # Note: Ignores z
         # 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)
+        g = max_value(w0, w1)
 
-        q = as_vector((Max(w0, 0), Max(w1, 0)))
+        q = as_vector([max_value(w0, 0), max_value(w1, 0)])
 
         return conditional(g > 0, ufl_length(q), g)

ddfem/geometry/domain.py

@@ -1,5 +1,7 @@
 from ufl import conditional, dot, grad, sqrt
 
+from .primitive_base import SDF
+
 
 class Domain:
     def __init__(self, omega):
@@ -9,6 +11,9 @@ class Domain:
         tol = 1e-10
         return (1 - tol) * self.omega.phi(x) + tol
 
+    def chi(self, x):
+        return self.omega.chi(x)
+
     def scaled_normal(self, x):
         return -grad(self.phi(x))
 
@@ -20,18 +25,25 @@ class Domain:
         sd = conditional(self.surface_delta(x) > tol, self.surface_delta(x), tol)
         return self.scaled_normal(x) / sd  # grad(self.omega(x))
 
+    def boundary_projection(self, x):
+        return x + self.omega.projection(x)
+
+    def external_projection(self, x):
+        return x + self.omega.projection(x) * (1 - self.chi(x))
+
     def bndSDFs(self, SDFname):
+        if isinstance(SDFname, SDF):
+            SDFname = SDFname.name
+
         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}")
+        sdf = self.bndSDFs(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))
+        return lambda x: w(self.boundary_projection(x))

ddfem/geometry/domain_dune.py

@@ -13,6 +13,8 @@ class DomainDune(Domain):
         self.gridView = gridView
 
         self._phi = None
+        self._bndProj = None
+        self._extProj = None
         self._bndProjSDFs = {}
 
         self.fullSDF = self.gridFunction(self.omega(self.x), name="full-sdf")
@@ -30,6 +32,20 @@ class DomainDune(Domain):
 
         return self._phi
 
+    def boundary_projection(self, x):
+        if self._bndProj is None:
+            p = super().boundary_projection(self.x)
+            self._bndProj = self.gridFunction(p, "bndproj")
+
+        return self._bndProj
+
+    def external_projection(self, x):
+        if self._extProj is None:
+            p = super().external_projection(self.x)
+            self._extProj = self.gridFunction(p, "extproj")
+
+        return self._extProj
+
     def generate_projSDF(self, sdf):
         projSDF = self._bndProjSDFs.get(sdf.name)
         if projSDF is None:

ddfem/geometry/helpers.py

@@ -1,12 +1,19 @@
-from ufl import conditional, dot, sqrt
-from ufl import max_value as Max
-from ufl import min_value as Min
+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))
-    # return ufl_max(sqrt(dot(p, p) + 1e-10), 1e-10)
-    return sqrt(dot(p, p))
 
 
 def ufl_sign(p):
@@ -20,15 +27,15 @@ 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_max(p1, p2):
+    #     return conditional(p2 < p1, p1, p2)
 
-    def ufl_min(p1, p2):
-        return conditional(p1 < p2, 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)
+    # 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):

ddfem/geometry/pie.py

@@ -1,6 +1,4 @@
-from ufl import as_vector, cos, dot, sin
-from ufl import max_value as Max
-from ufl import min_value as Min
+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
@@ -8,16 +6,18 @@ 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)
 
+        super().__init__(*args, **kwargs)
+
     def __repr__(self):
-        return f"Pie({self.radius}, {self.angle})"
+        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]))
+        coords = as_vector([x0_abs, x[1]])
 
         circle_dist = ufl_length(coords) - self.radius
 
@@ -28,4 +28,4 @@ class Pie(SDF):
         rejc = coords - proj
         edge_dist = ufl_length(rejc) * ufl_sign(ufl_cross(coords, trig))
 
-        return Max(circle_dist, edge_dist)
+        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