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

ddfem/examples/cahn_hilliard.py

@@ -1,67 +0,0 @@
-from dune.ufl import Constant
-from ufl import as_tensor, as_vector, dot, grad, inner, zero
-
-from ddfem.boundary import BndFlux_c, BndFlux_v, BndValue
-
-
-def chModel():
-    class CHModel:
-        dimRange = [1, 1]
-
-        M = Constant(1, name="M")
-        lmbda = Constant(1.0e-02, name="lmbda")  # surface parameter
-        dt = Constant(5.0e-06, name="dt")  # time step
-        theta = Constant(
-            0.5, name="theta"
-        )  # theta=1 -> backward Euler, theta=0.5 -> Crank-Nicolson
-
-        u_h_n = None
-        Du_h_n = None
-
-        def setup(u_h, DDMModel):
-            CHModel.u_h_n = u_h.copy()
-            CHModel.Du_h_n = lambda t, x: DDMModel.sigma(
-                t, x, CHModel.u_h_n, grad(CHModel.u_h_n)
-            )
-
-        def energy(U, DU):
-            C, MU = as_vector([U[0]]), as_vector([U[1]])
-            DC, DMU = as_tensor([DU[0, :]]), as_tensor([DU[1, :]])
-
-            f = 100 * dot(C, C) * dot(as_vector([1]) - C, as_vector([1]) - C)
-
-            return CHModel.lmbda / 2 * inner(DC, DC) + f
-
-        def F_v(t, x, U, DU):
-            C, MU = as_vector([U[0]]), as_vector([U[1]])
-            DC, DMU = as_tensor([DU[0, :]]), as_tensor([DU[1, :]])
-            c_h_n, mu_h_n = as_vector([CHModel.u_h_n[0]]), as_vector([CHModel.u_h_n[1]])
-            Du_h_n = CHModel.Du_h_n(t, x)
-            Dc_h_n, Dmu_h_n = as_vector([Du_h_n[0, :]]), as_vector([Du_h_n[1, :]])
-
-            mu_mid = (1.0 - CHModel.theta) * Dmu_h_n + CHModel.theta * DMU
-            concentration_F_v = CHModel.M * mu_mid
-            potential_F_v = CHModel.lmbda * DC
-
-            return as_tensor([concentration_F_v[0, :], potential_F_v[0, :]])
-
-        def S_i(t, x, U, DU):
-            C, MU = as_vector([U[0]]), as_vector([U[1]])
-            DC, DMU = as_tensor([DU[0, :]]), as_tensor([DU[1, :]])
-            c_h_n, mu_h_n = as_vector([CHModel.u_h_n[0]]), as_vector([CHModel.u_h_n[1]])
-
-            concentration_S_i = -(C - c_h_n) / CHModel.dt
-            potential_S_i = (
-                MU - (200 + 400 * dot(C, C)) * C + as_vector([600 * dot(C, C)])
-            )
-
-            return as_vector([concentration_S_i[0], potential_S_i[0]])
-
-        def valF_v(t, x, MU, DMU, n):
-            return zero(2)
-
-        boundary = {
-            "full": BndFlux_v(valF_v),
-        }
-
-    return CHModel

ddfem/examples/chemical_reaction.py

@@ -1,88 +0,0 @@
-from dune.ufl import Constant
-from ufl import as_vector, conditional, dot, grad, outer, zero
-
-from ddfem.boundary import BndFlux_c, BndFlux_v, BndValue
-
-
-def crModel():
-    class PotentialModel:
-        dimRange = 1
-        outFactor_i = Constant(1, "outFactor")
-
-        def F_v(t, x, U, DU):
-            return DU
-
-        def S_e(t, x, U, DU):
-            return as_vector([-1])
-
-        def valD(t, x, U):
-            return zero(1)
-
-        boundary = {
-            "full": BndValue(valD),
-        }
-
-    class ChemModel:
-        dimRange = 3
-
-        dt = Constant(0.05, "dt")
-        diff = Constant(1e-3, "diff")  # this is about the boundary for stability
-        # outFactor_i = diff
-
-        P1 = as_vector([-0.25, -0.25])  # midpoint of first source (close to boundary)
-        P2 = as_vector([0.25, 0.25])  # midpoint of second source (close to boundary)
-
-        u_h_n = None
-        dpsi_h = None
-
-        def setup(u_h, DDMPotentialModel, psi_h):
-            ChemModel.u_h_n = u_h.copy(name="u_h_n")
-            ChemModel.u_h_n.interpolate(zero(ChemModel.dimRange))
-
-            ChemModel.dpsi_h = lambda x: DDMPotentialModel.sigma(
-                0, x, psi_h, grad(psi_h)
-            )
-
-        def f1(x):
-            q = x - ChemModel.P1
-            return conditional(dot(q, q) < 0.04**2, 5, 0)
-
-        def f2(x):
-            q = x - ChemModel.P2
-            return conditional(dot(q, q) < 0.04**2, 5, 0)
-
-        def f(t, x):
-            return conditional(
-                t < 10,
-                as_vector([ChemModel.f1(x), ChemModel.f2(x), 0]),
-                as_vector([0, 0, 0]),
-            )
-
-        def r(U):
-            return 10 * as_vector([U[0] * U[1], U[0] * U[1], -2 * U[0] * U[1]])
-
-        def F_v(t, x, U, DU):
-            return ChemModel.diff * DU
-
-        def velocity(x):
-            return as_vector([-ChemModel.dpsi_h(x)[0, 1], ChemModel.dpsi_h(x)[0, 0]])
-
-        def F_c(t, x, U):
-            return outer(U, ChemModel.velocity(x))
-
-        def S_i(t, x, U, DU):
-            return -(U - ChemModel.u_h_n) / ChemModel.dt
-
-        def S_e(t, x, U, DU):
-            return ChemModel.f(t, x) - ChemModel.r(ChemModel.u_h_n)
-
-        # boundary = {"full": BndValue(lambda t, x, U: zero(3))}
-
-        boundary = {
-            "full": [
-                BndFlux_c(lambda t, x, U, n: zero(ChemModel.dimRange)),
-                BndFlux_v(lambda t, x, U, DU, n: zero(ChemModel.dimRange)),
-            ]
-        }
-
-    return PotentialModel, ChemModel

ddfem/examples/constant.py

@@ -1,46 +0,0 @@
-from dune.ufl import Constant
-from ufl import as_vector, conditional, div, dot, exp, grad, inner, sqrt, outer, zero
-import ufl
-from ddfem.boundary import AFluxBC, DFluxBC, ValueBC
-
-def CModel(inverted):
-    withAdv = False
-
-    class Model:
-        dimRange = 1
-        stabFactor = Constant(1)
-
-        def initial(x):
-            return 2
-
-        def exact(t, x):
-            return as_vector((2+x[0]-x[0],))   # better way of avoiding 'Cannot determine geometric dimension from expression'
-
-        def K(U, DU):
-            return 1e-2
-
-        def F_v(t, x, U, DU):
-            return Model.K(U, DU) * DU
-
-        if withAdv:
-            def F_c(t, x, U):
-                return outer(U, as_vector([-2,0.5]) )
-  
-        if withAdv:
-            bndFlux = [ AFluxBC( lambda t,x,U,n: Model.F_c(t,x,U)*n ),
-                        DFluxBC( lambda t,x,U,DU,n: Model.F_v(t,x,U,DU)*n ) ]
-        else:
-            # this works: bndFlux = DFluxBC( lambda t,x,U,DU,n: zero(U.ufl_shape)
-            bndFlux = DFluxBC( lambda t,x,U,DU,n: Model.F_v(t,x,U,DU)*n )
-        boundary = {
-            # "full": ValueBC( lambda t,x,U: as_vector([2.]) ),
-            "full": bndFlux
-            # "sides": ValueBC( lambda t,x,U: as_vector([2.]) ),
-            # "ends": [AFluxBC( lambda t,x,U,n: Model.F_c(t,x,U)*n ),
-            #          DFluxBC( lambda t,x,U,DU,n: Model.F_v(t,x,U,DU)*n )]
-        }
-
-        if inverted:
-            boundary[range(1,5)] = ValueBC( lambda t,x,U: as_vector([2.]) )
-
-    return Model

ddfem/examples/five_circle_flat.py

@@ -1,197 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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