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

ddfem/examples/triple_circle.py

@@ -0,0 +1,217 @@
+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.view import adaptiveLeafGridView
+from dune.grid import cartesianDomain
+from dune.ufl import Constant, Space
+from ufl import SpatialCoordinate, sqrt
+
+from ddfem import geometry as gm
+from ddfem.geometry.domain_dune import DomainDune
+
+
+def getDomain(
+    initialRefine, version, inverted, adaptLevels=0, epsFactor=4.5, smoothing=None
+):
+
+    gm.SDF.smoothing = smoothing
+    shiftx, shifty = sqrt(2) * 1e-6, sqrt(3) * 1e-6
+    domain_range = [[-0.5 + shiftx, -0.5 + shifty], [0.5 + shiftx, 0.5 + shifty]]
+    initial_gridsize = [100 * 2**initialRefine] * 2
+    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
+    )
+
+    def get_eps(h):
+        return Constant(epsFactor * h * 0.5 ** (adaptLevels / 2), "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]]
+    sdfs[0].name = "sides"
+    sdfs[1].name = "ends"
+    omega = sdfs[0] & sdfs[1]
+    if inverted:
+        omega = omega.invert()
+    omega.name = "full"
+
+    h_max = h * 3
+    h_min = h / 2
+    radius = 5
+
+    x = SpatialCoordinate(Space(2))
+    sdf = omega(x)
+
+    def spacing(x, y, epsilon):
+        r_min = epsilon.value
+        r_max = radius * epsilon.value
+        dist = np.abs(sdf((x, y)))
+        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]])
+            if inverted:
+                rectangle = geom.add_rectangle(
+                    [domain_range[0][0], domain_range[0][1], 0.0],
+                    domain_range[1][0] - domain_range[0][0],
+                    domain_range[1][1] - domain_range[0][1],
+                )
+                geom.boolean_difference(rectangle, shape)
+
+            geom.set_mesh_size_callback(
+                lambda dim, tag, x, y, z, lc: spacing(x, y, epsilon),
+                ignore_other_mesh_sizes=True,
+            )
+            mesh = geom.generate_mesh()
+            points, cells = mesh.points, mesh.cells_dict
+            domain = {
+                "vertices": points[:, :2].astype(float),
+                "simplices": cells["triangle"].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_rectangle(
+                [domain_range[0][0], domain_range[0][1], 0.0],
+                domain_range[1][0] - domain_range[0][0],
+                domain_range[1][1] - domain_range[0][1],
+            )
+
+            geom.set_mesh_size_callback(
+                lambda dim, tag, x, y, z, lc: spacing(x, y, epsilon),
+                ignore_other_mesh_sizes=True,
+            )
+            mesh = geom.generate_mesh()
+            points, cells = mesh.points, mesh.cells_dict
+            domain = {
+                "vertices": points[:, :2].astype(float),
+                "simplices": cells["triangle"].astype(int),
+            }
+
+    elif version == "gmsh_embedded":
+        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]])
+            rectangle = geom.add_rectangle(
+                [domain_range[0][0], domain_range[0][1], 0.0],
+                domain_range[1][0] - domain_range[0][0],
+                domain_range[1][1] - domain_range[0][1],
+            )
+
+            geom.boolean_fragments(rectangle, shape)
+
+            geom.set_mesh_size_callback(
+                lambda dim, tag, x, y, z, lc: spacing(x, y, epsilon),
+                ignore_other_mesh_sizes=True,
+            )
+            mesh = geom.generate_mesh()
+            points, cells = mesh.points, mesh.cells_dict
+            domain = {
+                "vertices": points[:, :2].astype(float),
+                "simplices": cells["triangle"].astype(int),
+            }
+
+    else:
+        raise ValueError("invalid mesh type")
+
+    gridView = adaptiveLeafGridView(leafGridView(domain))
+
+    if version == "dune_adaptive":
+        omega.epsilon = get_eps(h_min)
+        omega.epsilon.value *= radius
+        epsilon_value = omega.epsilon.value
+
+        marker = mark
+
+        refinements = int(2 * 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):
+
+            omega.epsilon.value = epsilon_value * j / refinements
+            marker(region, 0.00247262315663, maxLevel=refinements)  # 1 epsilon
+
+            adapt(gridView.hierarchicalGrid)
+
+        h_min = h_max * 0.5 ** (j / 2)
+        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 / 2)}, epsilon={epsilon.value}"
+    )
+
+    return gridView, domain

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

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

ddfem/geometry/arc.py

@@ -0,0 +1,48 @@
+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):
+        self.radius = radius
+        self.angle = angle  # angle of opening
+        self.width = width
+
+        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}, {self._repr_core()})"
+
+    def sdf(self, x):
+        # Note: Ignores z
+        y0_abs = abs(x[1])
+        coords = as_vector([x[0], y0_abs])
+
+        center_radius = self.radius - self.width / 2
+
+        distance = ufl_length(coords) - 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/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

@@ -0,0 +1,33 @@
+from ufl import as_vector, conditional, max_value, min_value
+
+from .helpers import ufl_length
+from .primitive_base import ORIGIN, SDF
+
+
+class Box(SDF):
+    def __init__(self, width, height, center=ORIGIN, *args, **kwargs):
+        self.width = width
+        self.height = height
+
+        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}, {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_value(w0, w1)
+
+        q = as_vector([max_value(w0, 0), max_value(w1, 0)])
+
+        return conditional(g > 0, ufl_length(q), g)

ddfem/geometry/domain.py

@@ -0,0 +1,49 @@
+from ufl import conditional, dot, grad, sqrt
+
+from .primitive_base import SDF
+
+
+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 chi(self, x):
+        return self.omega.chi(x)
+
+    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 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.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.boundary_projection(x))

ddfem/geometry/domain_dune.py

@@ -0,0 +1,82 @@
+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._bndProj = None
+        self._extProj = 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 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:
+            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
+        )