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

ddfem/examples/five_circle_flat.py

@@ -0,0 +1,197 @@
+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,
+    adaptLevels=0,
+    epsFactor=4.5,
+    smoothing=None,
+    *args,
+    **kwargs,
+):
+
+    gm.SDF.smoothing = smoothing
+    shiftx, shifty = sqrt(2) * 1e-6, sqrt(3) * 1e-6
+    domain_range = [[-1.7 + shiftx, -1.3 + shifty], [1.7 + shiftx, 1.3 + shifty]]
+    initial_gridsize = [170 * 2**initialRefine, 130 * 2**initialRefine]
+    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 = [
+        [1, [0, 0], "Center"],
+        [0.5, [0, 0.8], "TopCut"],
+        [0.5, [0, -0.8], "BotCut"],
+        [0.5, [1, 0], "RightAdd"],
+        [0.5, [-1, 0], "LeftAdd"],
+        [1.4, [0, 0], "Cutoff"],
+    ]
+
+    b = [gm.Ball(c[0], c[1], name=c[2]) for c in balls]
+    # omega = (b[0] - b[1] - b[2] | b[3] | b[4]) & b[5]
+
+    bulk = b[0] - b[1] - b[2] | b[3] | b[4]
+    bulk.name = "bulk"
+
+    left_cutoff = b[5] | gm.Plane([-1, 0], -0.4)
+    left_cutoff.name = "left"
+    right_cutoff = b[5] | gm.Plane([1, 0], -0.4)
+    right_cutoff.name = "right"
+
+    cutoff = left_cutoff & right_cutoff  # b[5]
+
+    omega = bulk & cutoff
+    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]
+
+            disk_removed1 = geom.boolean_difference(disks[0], disks[1])
+            disk_removed2 = geom.boolean_difference(disk_removed1, disks[2])
+
+            disk_add = geom.boolean_union([disk_removed2, disks[3], disks[4]])
+            shape = geom.boolean_intersection([disk_add, disks[5]])
+
+            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),
+            }
+    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/forchheimer.py

@@ -0,0 +1,48 @@
+from dune.ufl import Constant
+from ufl import as_vector, div, exp, grad, inner, sqrt
+
+from ddfem.boundary import BndFlux_v, BndValue
+
+
+def fhModel(inverted):
+    class Model:
+        dimRange = 1
+        outFactor_i = Constant(1, "outFactor")
+
+        def initial(x):
+            return 1 / 2 * (x[0] ** 2 + x[1] ** 2) - 1 / 3 * (x[0] ** 3 - x[1] ** 3) + 1
+
+        def exact(t, x):
+            return as_vector([exp(-2 * t) * (Model.initial(x) - 1) + 1])
+
+        def K(U, DU):
+            # DU = exp(-2 * t) * (x[0] - x[0]^2, x[1] + x[1]^2)
+            return 2 / (1 + sqrt(1 + 4 * sqrt(inner(DU, DU))))
+
+        def F_v(t, x, U, DU):
+            return Model.K(U, DU) * DU
+
+        def S_i(t, x, U, DU):
+            return -div(
+                Model.F_v(t, x, Model.exact(t, x), grad(Model.exact(t, x)))
+            ) + as_vector([-2 * exp(-2 * t) * (Model.initial(x) - 1)])
+
+        valD = BndValue(lambda t, x, U: Model.exact(t, x))
+
+        valN = BndFlux_v(
+            lambda t, x, U, DU, n: Model.F_v(
+                t, x, Model.exact(t, x), grad(Model.exact(t, x))
+            )
+            * n
+        )
+
+        boundary = {
+            "sides": valD,
+            "ends": valN,
+        }
+
+        if inverted:
+            for i in range(1, 5):
+                boundary[i] = valD
+
+    return Model

ddfem/examples/hyperelasticity.py

@@ -0,0 +1,88 @@
+from dune.ufl import Constant
+from ufl import (
+    Identity,
+    as_vector,
+    conditional,
+    det,
+    diff,
+    div,
+    dot,
+    grad,
+    ln,
+    nabla_div,
+    nabla_grad,
+    outer,
+    replace,
+    sym,
+    tr,
+    variable,
+    zero,
+)
+from ufl.algorithms.ad import expand_derivatives
+
+from ddfem.boundary import BndFlux_v, BndValue
+
+
+def hyModel():
+    # https://jsdokken.com/dolfinx-tutorial/chapter2/hyperelasticity.html
+    class Model:
+        dimRange = 2
+        rho = Constant(1000, name="density")  # kg/m3
+        g = Constant(9.8, name="gravity")  # m/s2
+
+        body = Constant([0.0, -rho * g], "body")  # N/m3
+        vd = Constant([0, 0], "fixedboundary")
+        T = Constant([0, 0], "traction")  # Pa
+
+        outFactor_i = Constant(1, "outFactor")
+
+        # Elasticity parameters
+        # https://www.efunda.com/formulae/solid_mechanics/mat_mechanics/calc_elastic_constants.cfm
+        E = 1e7  # Young modulus ; Pa
+        nu = 0.4  # Poisson ratio ;
+        lamb = Constant(E * nu / ((1 + nu) * (1 - 2 * nu)), name="Lame_1")  # Pa
+        mu = Constant(E / (2 * (1 + nu)), name="Lame_2")  # i.e. Shear modulus ; Pa
+
+        def P(U, DU):
+            I = Identity(Model.dimRange)
+            # Stress
+            # Hyper-elasticity, (compressible neo-Hookean model)
+            F = variable(I + grad(U))  # Deformation gradient
+            C = F.T * F  # Right Cauchy-Green tensor
+            J = det(F)
+            Ic = tr(C)  # First Invariant
+            mu = Model.mu
+            lamb = Model.lamb
+            psi = (mu / 2) * (Ic - 3) - mu * ln(J) + (lamb / 2) * (ln(J)) ** 2
+
+            p = diff(psi, F)
+            p = expand_derivatives(p)
+            p = replace(p, {F: I + DU})
+            # p = replace(p, {F: I + grad(U)})
+
+            # Linear-elasticity
+            # p = lamb * tr(sym(DU)) * I + 2 * mu * sym(DU)
+
+            return p
+
+        def F_v(t, x, U, DU):
+            return Model.P(U, DU)
+
+        def S_i(t, x, U, DU):
+            return Model.body
+
+        valD = lambda t, x, U: Model.vd
+
+        valN = lambda t, x, U, DU, n: Model.T
+
+        boundary = {
+            "left": BndValue(valD),
+            "other": BndFlux_v(valN),
+        }
+        # boundary = {
+        #     "left": BndValue(valD),
+        #     "right": BndFlux_v(valN),
+        #     "bulk": BndFlux_v(valN),
+        # }
+
+    return Model

ddfem/examples/linear_elasticity.py

@@ -0,0 +1,45 @@
+from dune.ufl import Constant
+from ufl import Identity, as_vector, div, grad, sym, tr, zero
+
+from ddfem.boundary import BndFlux_v, BndValue
+
+
+def leModel():
+    class Model:
+        dimRange = 2
+        lamb = Constant(0.1, name="Lame_1")
+        mu = Constant(1, name="Lame_2")
+        rho = Constant(1 / 1000, name="density")
+        g = Constant(9.8, name="gravity")
+
+        outFactor_i = Constant(1, "outFactor")
+
+        vd = Constant([0, 0], "stationary")
+        vn = Constant([0, 0], "traction")
+
+        I = Identity(dimRange)
+
+        def sigma(U, DU):
+            return Model.lamb * tr(sym(DU)) * Model.I + 2 * Model.mu * sym(DU)
+
+        def F_v(t, x, U, DU):
+            return Model.sigma(U, DU)
+
+        def S_i(t, x, U, DU):
+            return as_vector([0.0, -Model.rho * Model.g])
+
+        valD = lambda t, x, U: Model.vd
+
+        valN = lambda t, x, U, DU, n: Model.vn
+
+        # boundary = {
+        #     "left": BndValue(valD),
+        #     "other": BndFlux_v(valN),
+        # }
+        boundary = {
+            "left": BndValue(valD),
+            "right": BndFlux_v(valN),
+            "bulk": BndFlux_v(valN),
+        }
+
+    return Model

ddfem/examples/plaplace.py

@@ -0,0 +1,29 @@
+from dune.ufl import Constant
+from ufl import grad, inner
+
+from ddfem.boundary import BndValue
+
+
+def pModel(power):
+    class Model:
+        dimRange = 1
+        ep = Constant(1e-5, name="ep")
+        f = Constant([1], name="f")
+        g = Constant([0], name="g")
+        p = Constant(power, name="p")  # p for p-Laplacian
+        assert p.value > 1 and p.value < 2**16
+        outFactor_i = Constant(1, "outFactor")
+
+        def K(u):
+            return (Model.ep**2 + inner(grad(u), grad(u))) ** ((Model.p - 2) / 2)
+
+        def F_v(t, x, U, DU):
+            return Model.K(U) * DU
+
+        def S_i(t, x, U, DU):
+            return Model.f - U
+
+        bc = BndValue(g)
+        boundary = {1: bc, 2: bc, 3: bc, 4: bc, "full": bc}
+
+    return Model

ddfem/examples/single_circle.py

@@ -0,0 +1,135 @@
+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 ddfem import geometry as gm
+from ddfem.geometry.domain_dune import DomainDune
+
+from dune.alugrid import aluConformGrid as leafGridView
+from dune.fem.view import adaptiveLeafGridView
+from dune.grid import cartesianDomain
+from dune.ufl import Constant, Space
+
+from ufl import SpatialCoordinate, sqrt
+
+def getDomain(initialRefine, version, inverted, adaptLevels=0, epsFactor=4.5):
+
+    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 = [75 * 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
+    )
+    epsilon = Constant(epsFactor * h * 0.5 ** (adaptLevels / 2), "epsilon")
+
+    print(f"h={h * 0.5 ** (adaptLevels / 2)}, epsilon={epsilon.value}")
+
+    circles = [
+        [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], epsilon=epsilon, name=c[2]) for c in circles]
+    sdfs = [b[0] | b[1], b[2]]
+    sdfs[0].name = "sides"
+    sdfs[1].name = "ends"
+    omega = b[2] # sdfs[0] & sdfs[1]
+    if inverted:
+        omega = omega.invert()
+    omega.name = "full"
+
+    x = SpatialCoordinate(Space(2))
+    sdf = omega(x)
+
+    def spacing(x, y):
+        r_min = 2*epsilon.value
+        r_max = 32 * 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)
+
+    elif version == "fitted":
+        if pygmsh is None:
+            raise AttributeError("'fitted' requires install pygmsh")
+        with pygmsh.occ.Geometry() as geom:
+            geom.characteristic_length_max = h
+            geom.characteristic_length_min = h
+
+            disks = geom.add_disk([circles[2][1][0], circles[2][1][1], 0.0], circles[2][0])
+                    # [geom.add_disk([c[1][0], c[1][1], 0.0], c[0]) for c in circles]
+
+            # ds = geom.boolean_union([disks[0], disks[1]])
+            shape = disks # 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),
+                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 == "adaptive":
+        if pygmsh is None:
+            raise AttributeError("'adaptive' requires install pygmsh")
+        with pygmsh.occ.Geometry() as geom:
+            geom.characteristic_length_max = h
+            geom.characteristic_length_min = h
+
+            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),
+                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),
+            }
+
+    gridView = adaptiveLeafGridView(leafGridView(domain))
+
+    domain = DomainDune(omega, x, gridView)
+    domain.adapt(level=adaptLevels)
+    gridView.plot()
+
+    return gridView, domain