xfem 2.1.2604.dev2__tar.gz → 2.1.2604.dev10__tar.gz

{xfem-2.1.2604.dev2 → xfem-2.1.2604.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xfem
-Version: 2.1.2604.dev2
+Version: 2.1.2604.dev10
 Summary: (ngs)xfem is an Add-on library to Netgen/NGSolve for unfitted/cut FEM.
 Author-Email: Christoph Lehrenfeld <lehrenfeld@math.uni-goettingen.de>
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)

xfem-2.1.2604.dev10/_ngsolve_deps_provider.py

@@ -0,0 +1,33 @@
+"""
+Custom scikit-build-core metadata provider for the ngsolve dependency.
+
+This module is used instead of ``ngsolve._scikit_build_core_dependencies``
+so that the ngsolve *native* extension module is never imported during the
+build-metadata phase.  The native module requires shared libraries (e.g.
+``libmkl_rt.so.2``) that are not present in standard manylinux build
+containers or in isolated Windows build environments, causing the build to
+fail.
+
+By reading the installed-package metadata via :mod:`importlib.metadata` we
+obtain the exact ngsolve version without loading any C extension.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+
+def dynamic_metadata(
+    field: str,
+    settings: dict | None = None,
+) -> list[str]:
+    if field == "dependencies":
+        ngsolve_version = version("ngsolve")
+        return [f"ngsolve=={ngsolve_version}"]
+    raise ValueError(f"Unknown metadata field: {field!r}")
+
+
+def get_requires_for_dynamic_metadata(
+    settings: dict | None = None,
+) -> list[str]:
+    return ["ngsolve"]

{xfem-2.1.2604.dev2 → xfem-2.1.2604.dev10}/cutint/cutintegral.cpp

@@ -154,7 +154,7 @@ TSCAL CutIntegral :: T_CutIntegrate (const ngcomp::MeshAccess & ma,
     throw Exception("only implemented for 1 dimensional coefficientfunctions");
 
   TSCAL sum = 0.0;
-  ma.IterateElements(VOL, glh, [&] (Ngs_Element el, LocalHeap & lh)
+  ma.IterateElements(dx.vb, glh, [&] (Ngs_Element el, LocalHeap & lh)
   {
     if (defon.Size() && !defon.Test(el.GetIndex()))
       return;

{xfem-2.1.2604.dev2 → xfem-2.1.2604.dev10}/pyproject.toml

@@ -34,8 +34,11 @@ sdist.include = ["python/_version.py"]
 #build-dir = "./build_py/{wheel_tag}" # local build directory - for debugging
 
 experimental = true
-# This adds ngsolve (with exact build-time version) to the dependencies
-metadata.dependencies.provider="ngsolve._scikit_build_core_dependencies"
+# This adds ngsolve (with exact build-time version) to the dependencies.
+# Uses a local provider to avoid importing ngsolve's native module (which
+# requires libmkl_rt / platform DLLs not present in all build environments).
+metadata.dependencies.provider = "_ngsolve_deps_provider"
+metadata.dependencies.provider-path = "."
 
 [tool.setuptools_scm]  # Section required
 write_to = "python/_version.py"
@@ -51,6 +54,7 @@ testpaths = ["tests"]
 #build-verbosity = 1
 manylinux-x86_64-image = "cerbsim/manylinux_2_28_x86_64_cuda_12.8"
 build = "cp310-* cp311-* cp312-* cp313-* cp314-*"
+enable = ["cpython-prerelease"]
 skip = """
   pp*
   *_i686

{xfem-2.1.2604.dev2 → xfem-2.1.2604.dev10}/python/__init__.py

@@ -791,10 +791,24 @@ def dCut(levelset, domain_type, order=None, subdivlvl=None, time_order=-1,
         and no isoparametric mapping is used.
     definedon : Region
         Domain description on where the integrator is defined.
+        When vb=BND, pass mesh.Boundaries("name") to restrict to a
+        specific boundary label.
     vb : {VOL, BND, BBND}
-        Integration on mesh volume or its (B)boundary. Default: VOL
-        (if combined with skeleton=True VOL refers to interior facets
-                                        BND refers to boundary facets)
+        Integration on mesh volume or its (B)boundary. Default: VOL.
+        Use vb=BND to integrate over the portion of the mesh boundary
+        where the level set satisfies the given domain_type condition.
+        This enables imposing different BCs on parts of the same boundary
+        label separated by the level set interface (Nitsche approach).
+        Example::
+
+            # Integrate over the NEG part of the bottom boundary
+            ds_neg = dCut(lset_p1, NEG, vb=BND,
+                          definedon=mesh.Boundaries("bottom"))
+            a += -grad(u).Trace()*n*v*ds_neg - u*grad(v).Trace()*n*ds_neg
+            a += (lam/h) * u*v * ds_neg
+
+        (if combined with skeleton=True, VOL refers to interior facets
+                                         BND refers to boundary facets)
     element_boundary : bool
         Integration on each element boundary. Default: False
     element_vb : {VOL, BND, BBND}
@@ -808,6 +822,8 @@ def dCut(levelset, domain_type, order=None, subdivlvl=None, time_order=-1,
     definedonelements : ngsolve.BitArray
         Allows integration only on elements or facets (if skeleton=True)
         that are marked True. Default: None.
+        For vb=BND, a BitArray of cut boundary elements can be obtained via
+        CutInfo(mesh, lset).GetElementsOfType(HASNEG, BND).
     time_order : int
         Order in time that is used in the space-time integration.
         Default: time_order=-1 means that no space-time rule will be

{xfem-2.1.2604.dev2 → xfem-2.1.2604.dev10}/python/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.2604.dev2'
-__version_tuple__ = version_tuple = (2, 1, 2604, 'dev2')
+__version__ = version = '2.1.2604.dev10'
+__version_tuple__ = version_tuple = (2, 1, 2604, 'dev10')
 
-__commit_id__ = commit_id = 'gf016cdefe'
+__commit_id__ = commit_id = 'g881a82a53'

{xfem-2.1.2604.dev2 → xfem-2.1.2604.dev10}/tests/CMakeLists.txt

@@ -35,6 +35,9 @@ add_test(NAME py_demo_unfitted_poisson COMMAND ${NETGEN_PYTHON_EXECUTABLE}
 add_test(NAME py_demo_spacetime_unfitted_DG COMMAND ${NETGEN_PYTHON_EXECUTABLE} 
   "${PROJECT_SOURCE_DIR}/demos/spacetime/spacetimeDG_unfitted.py" "testmode")
 
+add_test(NAME py_demo_bnd_cut COMMAND ${NETGEN_PYTHON_EXECUTABLE} 
+  "${PROJECT_SOURCE_DIR}/demos/bnd_cut.py" "testmode")
+
 add_test(NAME pytests_simd_lfblf COMMAND ${NETGEN_PYTHON_EXECUTABLE} -m pytest
   "${PROJECT_SOURCE_DIR}/tests/pytests/test_simd_lf_blf.py" WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/tests")
 
@@ -107,6 +110,9 @@ add_test(NAME pytests_utils COMMAND ${NETGEN_PYTHON_EXECUTABLE} -m pytest
 add_test(NAME pytests_memory COMMAND ${NETGEN_PYTHON_EXECUTABLE} -m pytest
   "${PROJECT_SOURCE_DIR}/tests/pytests/test_memory_usage.py" WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/tests")
 
+add_test(NAME pytests_bndcut COMMAND ${NETGEN_PYTHON_EXECUTABLE} -m pytest
+  "${PROJECT_SOURCE_DIR}/tests/pytests/test_bndcut.py" WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/tests")
+
 add_test(NAME pytests_aggregates COMMAND ${NETGEN_PYTHON_EXECUTABLE} -m pytest
   "${PROJECT_SOURCE_DIR}/tests/pytests/test_aggregates.py" WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/tests")
 

xfem-2.1.2604.dev10/tests/pytests/test_bndcut.py

@@ -0,0 +1,186 @@
+"""Tests for boundary cut integration: dCut(lset, NEG/POS/IF, vb=BND).
+
+Issue #8: integrate over the part of the boundary defined by a level set.
+"""
+import pytest
+import numpy as np
+from ngsolve import *
+from xfem import *
+ngsglobals.msg_level = 0
+
+
+# ---------------------------------------------------------------------------
+# 2-D helpers
+# ---------------------------------------------------------------------------
+
+def make_2d_mesh(maxh=0.15):
+    from netgen.geom2d import unit_square
+    return Mesh(unit_square.GenerateMesh(maxh=maxh))
+
+
+def make_3d_mesh(maxh=0.3):
+    from netgen.csg import unit_cube
+    return Mesh(unit_cube.GenerateMesh(maxh=maxh))
+
+
+# ---------------------------------------------------------------------------
+# Scalar Integrate tests
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("cut", [0.3, 0.5, 0.7])
+def test_integrate_bnd_2d(cut):
+    """Integrate(1 * dCut(lset, NEG, vb=BND)) over the unit-square boundary.
+
+    With lset = x - cut the NEG region is the left part (x < cut).
+    The boundary of the unit square has four edges:
+      bottom (y=0, x in [0,1]),  top (y=1, x in [0,1])
+      left   (x=0, y in [0,1]),  right (x=1, y in [0,1])
+    NEG portion lengths:
+      bottom: cut,  top: cut,  left: 1,  right: 0  →  total = 2*cut + 1
+    """
+    mesh = make_2d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    val = Integrate(CoefficientFunction(1) * dCut(lset, NEG, vb=BND), mesh)
+    expected = 2 * cut + 1.0
+    assert abs(val - expected) < 1e-10, f"Expected {expected}, got {val}"
+
+
+@pytest.mark.parametrize("cut", [0.3, 0.7])
+def test_integrate_bnd_2d_definedon(cut):
+    """dCut with definedon=mesh.Boundaries restricts to a single edge."""
+    mesh = make_2d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    val = Integrate(CoefficientFunction(1) * dCut(lset, NEG, vb=BND,
+                    definedon=mesh.Boundaries("bottom")), mesh)
+    assert abs(val - cut) < 1e-10, f"Expected {cut}, got {val}"
+
+
+def test_integrate_bnd_2d_pos():
+    """Integrate over POS part of boundary."""
+    cut = 0.4
+    mesh = make_2d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    neg = Integrate(CoefficientFunction(1) * dCut(lset, NEG, vb=BND), mesh)
+    pos = Integrate(CoefficientFunction(1) * dCut(lset, POS, vb=BND), mesh)
+    total = Integrate(CoefficientFunction(1), mesh, BND)
+    assert abs(neg + pos - total) < 1e-10, "NEG + POS should equal full boundary"
+
+
+def test_integrate_bnd_3d(cut=0.3):
+    """3-D: integrate over BND faces of unit cube where x < cut."""
+    mesh = make_3d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    val = Integrate(CoefficientFunction(1) * dCut(lset, NEG, vb=BND), mesh)
+    # NEG faces: left (x=0, area 1), bottom (z=0) * cut portion, top, front, back
+    # left face (x=0): area = 1  (fully NEG)
+    # right face (x=1): area = 0  (fully POS)
+    # four side faces (y=0, y=1, z=0, z=1): each has NEG area = cut * 1 = cut → 4*cut
+    expected = 1.0 + 4.0 * cut
+    assert abs(val - expected) < 1e-10, f"Expected {expected}, got {val}"
+
+
+# ---------------------------------------------------------------------------
+# BFI assembly tests
+# ---------------------------------------------------------------------------
+
+def test_bfi_assembly_2d():
+    """Bilinear form on boundary cut domain equals NGSolve's ds on the same region."""
+    cut = 0.4
+    mesh = make_2d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    V = H1(mesh, order=1)
+    u, v = V.TnT()
+
+    gfu = GridFunction(V)
+    gfu.Set(sin(x) * cos(y))
+
+    # Pure-NEG boundary (left edge) using dCut
+    a_cut = BilinearForm(V, check_unused=False)
+    a_cut += u * v * dCut(lset, NEG, vb=BND, definedon=mesh.Boundaries("left"))
+    a_cut.Assemble()
+
+    # Reference: left edge is fully NEG, so dCut == ds("left")
+    a_ref = BilinearForm(V, check_unused=False)
+    a_ref += u * v * ds("left")
+    a_ref.Assemble()
+
+    w_cut = a_cut.mat * gfu.vec
+    w_ref = a_ref.mat * gfu.vec
+    diff = Norm(w_cut - w_ref)
+    assert diff < 1e-10, f"Matrix-vector product difference too large: {diff}"
+
+
+def test_lfi_assembly_2d():
+    """Linear form on boundary cut domain."""
+    cut = 0.4
+    mesh = make_2d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    V = H1(mesh, order=1)
+    v = V.TestFunction()
+
+    f_cut = LinearForm(V)
+    f_cut += v * dCut(lset, NEG, vb=BND, definedon=mesh.Boundaries("left"))
+    f_cut.Assemble()
+
+    f_ref = LinearForm(V)
+    f_ref += v * ds("left")
+    f_ref.Assemble()
+
+    diff = Norm(f_cut.vec - f_ref.vec)
+    assert diff < 1e-10, f"Vector difference too large: {diff}"
+
+
+def test_bfi_assembly_2d_partial():
+    """On bottom edge with cut at 0.4: dCut(NEG) captures only the left portion."""
+    cut = 0.4
+    mesh = make_2d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    V = H1(mesh, order=1)
+    v = V.TestFunction()
+
+    f_cut = LinearForm(V)
+    f_cut += CoefficientFunction(1) * v * dCut(lset, NEG, vb=BND,
+              definedon=mesh.Boundaries("bottom"))
+    f_cut.Assemble()
+
+    # Sum of assembled vector == integral of test function (=1 * v_j)  ≈  cut length
+    val = sum(f_cut.vec)
+    assert abs(val - cut) < 1e-2, f"Expected ~{cut}, got {val}"
+
+
+def test_bfi_definedon_bitarray():
+    """definedon can be supplied as a BitArray of boundary elements."""
+    cut = 0.4
+    mesh = make_2d_mesh()
+    lset = GridFunction(H1(mesh, order=1))
+    InterpolateToP1(x - cut, lset)
+
+    ci = CutInfo(mesh, lset)
+    hasneg_bnd = ci.GetElementsOfType(HASNEG, BND)
+
+    V = H1(mesh, order=1)
+    v = V.TestFunction()
+
+    f_cut = LinearForm(V)
+    f_cut += CoefficientFunction(1) * v * dCut(lset, NEG, vb=BND,
+              definedonelements=hasneg_bnd)
+    f_cut.Assemble()
+
+    val = Integrate(CoefficientFunction(1) * dCut(lset, NEG, vb=BND), mesh)
+    # Both should give the same total; assert consistent
+    val2 = sum(f_cut.vec)
+    assert abs(val2 - val) < 1e-2, f"definedonelements mismatch: {val2} vs {val}"