phiFEM 0.7.0.dev1__py3-none-any.whl → 0.7.1.dev2__py3-none-any.whl

phifem/mesh_scripts.py

@@ -118,35 +118,31 @@ def _compute_detection_vector(
     detection_denom_form = dfx.fem.form(detection_denom)
     detection_denom_vec = assemble_vector(detection_denom_form)
 
-    imap = dg_0_space.dofmap.index_map
-    detection_vector = dfx.la.vector(imap)
     # detection_denom_vec is not supposed to be zero, this would mean that the levelset is zero at all dofs in a cell.
     # However, in practice it can happen that for a very small cut triangle, detection_denom_vec is of the order of the machine precision.
     # In this case, we set the value of detection_vector to 0.5, meaning we consider the cell as cut.
+    mask = np.where(detection_denom_vec.array > 0.0)
+    detection_vector = np.full_like(detection_num_vec.array, 0.5)
+    detection_vector[mask] = (
+        detection_num_vec.array[mask] / detection_denom_vec.array[mask]
+    )
     if np.any(np.isclose(detection_denom_vec.array, 0.0)):
         warnings.warn(
-            "The levelset function is zero everywhere on a cell. We mark it as 'cut' but this can be incorrect and should be carefully checked.",
+            "The detection function is zero everywhere on a cell. We mark it as 'cut' but this can be incorrect and should be carefully checked.",
             RuntimeWarning,
         )
-    mask = np.where(detection_denom_vec.array > 0.0)
-    detection_vector.array[:] = 0.5
-    detection_vector.array[mask] = (
-        detection_num_vec.array[mask] / detection_denom_vec.array[mask]
-    )
-    detection_vector.scatter_forward()
     return detection_vector
 
 
 def _compute_integration_entities(
-    mesh: Mesh, integration_cells: list[int], integration_facets: list[int], ind: int
-) -> ufl.Measure:
+    mesh: Mesh, integration_cells: list[int], integration_facets: list[int]
+) -> list[int]:
     """Compute the integration entities in order to build a one-sided integral over a set of given edges. This script is inspired from https://github.com/jorgensd/dolfinx-tutorial/issues/158.
 
     Args:
         mesh: the mesh on which we compute the measure.
         integration_cells: list of cells indices from which the integral is computed.
         integration_facets: list of facets indices on which the integral is computed.
-        ind: index used in the measure.
     Returns: the integration entities.
     """
     cdim = mesh.topology.dim
@@ -192,7 +188,7 @@ def _compute_integration_entities(
         np.column_stack((right_side_cells_rep, local_indices))
     ).astype(np.int32)
 
-    return [(ind, integration_entities)]
+    return integration_entities
 
 
 def _reshape_map(connect: AdjacencyList_int32) -> npt.NDArray[np.int32]:
@@ -217,31 +213,71 @@ def _reshape_map(connect: AdjacencyList_int32) -> npt.NDArray[np.int32]:
     return emap, max_offset
 
 
-def _transfer_markers(
-    source_markers: dfx.la.Vector,
+def _transfer_tags(
+    source_mesh_tags: MeshTags,
+    dest_mesh: Mesh,
     cmap: npt.NDArray[Any],
-    edim: int,
-) -> dfx.la.Vector:
+    source_mesh: Mesh = None,
+) -> MeshTags:
     """Given entities tags (cells or facets) from a source mesh, a destination mesh and the source mesh-destination mesh cells mapping, transfers the entities tags to the destination mesh.
 
     Args:
-        source_markers: the markers on the source mesh.
+        source_mesh_tags: the tags on the source mesh.
         dest_mesh: the destination mesh.
         cmap: the source mesh-destination mesh cells mapping.
+        source_mesh: the source mesh mandatory to transfer facets tags.
 
     Returns:
         Cells tags on the destination mesh.
     """
-    sub_index_map = cmap.sub_topology.index_map(edim)
-    local_entities = np.arange(sub_index_map.size_local + sub_index_map.num_ghosts)
-    emap = cmap.sub_topology_to_topology(
-        local_entities,
-        False,
+    cdim = dest_mesh.topology.dim
+    fdim = cdim - 1
+    edim = source_mesh_tags.dim
+
+    if edim == cdim:
+        emap = cmap
+    elif edim == fdim:
+        if source_mesh is None:
+            raise ValueError("You must pass a source_mesh to transfer facets tags.")
+
+        source_mesh.topology.create_connectivity(cdim, fdim)
+        c2f_connect = source_mesh.topology.connectivity(cdim, fdim)
+        num_facets_per_cell = len(c2f_connect.links(0))
+        source_c2f_map = np.reshape(c2f_connect.array, (-1, num_facets_per_cell))
+        dest_mesh.topology.create_connectivity(cdim, fdim)
+        c2f_connect = dest_mesh.topology.connectivity(cdim, fdim)
+        num_facets_per_cell = len(c2f_connect.links(0))
+        dest_c2f_map = np.reshape(c2f_connect.array, (-1, num_facets_per_cell))
+        source_c2f_dest_map = source_c2f_map[cmap]
+        source_c2f_dest_map = source_c2f_dest_map.reshape(
+            -1,
+        )
+        dest_c2f_map = dest_c2f_map.reshape(
+            -1,
+        )
+        unique_indices, sorted_indices = np.unique(dest_c2f_map, return_index=True)
+        emap = source_c2f_dest_map[sorted_indices]
+    else:
+        raise ValueError("The source_mesh_tags can only be cells tags or facets tags.")
+
+    # TODO: change this line to allow parallel computing
+    source_tags = source_mesh_tags.values
+
+    dest_entities = np.arange(len(emap))
+    dest_tags = source_tags[emap]
+
+    dest_entities_indices = np.hstack(dest_entities).astype(np.int32)
+    dest_entities_markers = np.hstack(dest_tags).astype(np.int32)
+    sorted_indices = np.argsort(dest_entities_indices)
+
+    dest_entities_tags = dfx.mesh.meshtags(
+        dest_mesh,
+        edim,
+        dest_entities_indices[sorted_indices],
+        dest_entities_markers[sorted_indices],
     )
-    dest_markers = dfx.la.vector(sub_index_map)
-    dest_markers.array[:] = source_markers.array[emap]
 
-    return dest_markers
+    return dest_entities_tags
 
 
 def _tag_cells(
@@ -249,7 +285,7 @@ def _tag_cells(
     discrete_levelset: Function,
     detection_degree: int,
     single_layer_cut: bool = False,
-) -> dfx.la.Vector:
+) -> MeshTags:
     """Tag the mesh cells by computing detection = Σ f(dof)/Σ|f(dof)| where 'dof' are coming from a custom quadrature rule with points on the boundary of the cell only.
         Strictly inside cell  => tag 1
         Cut cell              => tag 2
@@ -262,7 +298,7 @@ def _tag_cells(
         single_layer_cut: boolean, if True force a single layer of cut cells.
 
     Returns:
-        The cells markers as a dfx.la.Vector object.
+        The cells tags as a MeshTags object.
     """
     if single_layer_cut:
         cdim = mesh.topology.dim
@@ -304,12 +340,10 @@ def _tag_cells(
         mesh, discrete_levelset, detection_measure
     )
     cut_indices = np.where(
-        np.logical_and(
-            detection_vector.array[:] > -1.0, detection_vector.array[:] < 1.0
-        )
+        np.logical_and(detection_vector > -1.0, detection_vector < 1.0)
     )[0]
-    exterior_indices = np.where(np.isclose(detection_vector.array[:], 1.0))[0]
-    interior_indices = np.where(np.isclose(detection_vector.array[:], -1.0))[0]
+    exterior_indices = np.where(detection_vector == 1.0)[0]
+    interior_indices = np.where(detection_vector == -1.0)[0]
 
     if single_layer_cut:
         neighbor_cells = np.reshape(
@@ -337,21 +371,30 @@ def _tag_cells(
         assert np.logical_not(np.isin(exterior_indices, interior_indices).any()), (
             "The sets of outside cells and inside cells have a non-empty intersection"
         )
-    cells_markers = dfx.la.vector(detection_vector.index_map)
-    cells_markers.array[interior_indices] = 1
-    cells_markers.array[cut_indices] = 2
-    cells_markers.array[exterior_indices] = 3
-    cells_markers.scatter_forward()
 
-    return cells_markers
+    # Create the meshtags from the indices.
+    indices = np.hstack([exterior_indices, interior_indices, cut_indices]).astype(
+        np.int32
+    )
+    interior_marker = np.full_like(interior_indices, 1).astype(np.int32)
+    exterior_marker = np.full_like(exterior_indices, 3).astype(np.int32)
+    cut_marker = np.full_like(cut_indices, 2).astype(np.int32)
+    markers = np.hstack([exterior_marker, interior_marker, cut_marker]).astype(np.int32)
+    sorted_indices = np.argsort(indices)
+
+    cells_tags = dfx.mesh.meshtags(
+        mesh, mesh.topology.dim, indices[sorted_indices], markers[sorted_indices]
+    )
+
+    return cells_tags
 
 
 def _tag_facets(
     mesh: Mesh,
-    cells_markers: dfx.la.Vector,
+    cells_tags: MeshTags,
     discrete_levelset: Function,
     detection_degree: int,
-) -> dfx.la.Vector:
+) -> MeshTags:
     """Tag the mesh facets.
     Strictly interior facets  => tag 1
     Cut facets                => tag 2
@@ -362,13 +405,12 @@ def _tag_facets(
 
     Args:
         mesh: the background mesh.
-        cells_markers: the vector storing the cells markers.
+        cells_tags: the MeshTags object containing cells tags.
         discrete_levelset: the discretization of the levelset.
         detection_degree: the degree of the custom quadrature rule used to detect cut entities.
 
     Returns:
-        The facets markers as a dfx.la.Vector object.
-        The wireframe mesh containing all facets.
+        The facets tags as a MeshTags object.
     """
     cdim = mesh.topology.dim
     fdim = cdim - 1
@@ -379,9 +421,9 @@ def _tag_facets(
     c2f_map = np.reshape(c2f_connect.array, (-1, num_facets_per_cell))
 
     # Get tagged cells
-    interior_cells = np.where(cells_markers.array[:] == 1)
-    cut_cells = np.where(cells_markers.array[:] == 2)
-    exterior_cells = np.where(cells_markers.array[:] == 3)
+    interior_cells = cells_tags.find(1)
+    cut_cells = cells_tags.find(2)
+    exterior_cells = cells_tags.find(3)
 
     # Check which background mesh boundary facets are cut by the interface
     background_mesh_boundary_facets = dfx.mesh.locate_entities_boundary(
@@ -403,7 +445,7 @@ def _tag_facets(
         mesh, discrete_levelset, detection_measure
     )
     mask_cut_indices_cells = np.logical_and(
-        detection_vector.array[:] > -1.0, detection_vector.array[:] < 1.0
+        detection_vector > -1.0, detection_vector < 1.0
     )
     cut_indices_cells = np.where(mask_cut_indices_cells)[0]
     comp_indices_cells = np.where(np.logical_not(mask_cut_indices_cells))[0]
@@ -477,26 +519,52 @@ def _tag_facets(
                         + " have a non-empty intersection!"
                     )
 
-    # Allocate distributed vectors supporting facets markers.
-    all_facets = dfx.mesh.locate_entities(
-        mesh, 1, lambda x: np.ones_like(x[0]).astype(bool)
+    # Create the meshtags from the indices.
+    indices = np.hstack(
+        [
+            exterior_facets,
+            interior_facets,
+            interior_boundary_facets,
+            cut_facets,
+            boundary_facets,
+            direct_interface_facets,
+        ]
+    ).astype(np.int32)
+    interior_marker = np.full_like(interior_facets, 1).astype(np.int32)
+    cut_marker = np.full_like(cut_facets, 2).astype(np.int32)
+    interior_boundary_marker = np.full_like(interior_boundary_facets, 3).astype(
+        np.int32
+    )
+    boundary_marker = np.full_like(boundary_facets, 4).astype(np.int32)
+    exterior_marker = np.full_like(exterior_facets, 5).astype(np.int32)
+    direct_interface_marker = np.full_like(direct_interface_facets, 6).astype(np.int32)
+    markers = np.hstack(
+        [
+            exterior_marker,
+            interior_marker,
+            interior_boundary_marker,
+            cut_marker,
+            boundary_marker,
+            direct_interface_marker,
+        ]
+    ).astype(np.int32)
+    sorted_indices = np.argsort(indices)
+
+    facets_tags = dfx.mesh.meshtags(
+        mesh, fdim, indices[sorted_indices], markers[sorted_indices]
     )
-    wireframe = dfx.mesh.create_submesh(mesh, 1, all_facets)[0]
-    cell_name_wf = wireframe.topology.cell_name()
-    dg0_element_wf = element("DG", cell_name_wf, 0)
-    dg0_space_wf = dfx.fem.functionspace(wireframe, dg0_element_wf)
-    imap = dg0_space_wf.dofmap.index_map
-    facets_markers = dfx.la.vector(imap)
 
-    facets_markers.array[interior_facets] = 1
-    facets_markers.array[cut_facets] = 2
-    facets_markers.array[interior_boundary_facets] = 3
-    facets_markers.array[boundary_facets] = 4
-    facets_markers.array[exterior_facets] = 5
-    facets_markers.array[direct_interface_facets] = 6
-    facets_markers.scatter_forward()
+    return facets_tags
 
-    return facets_markers
+
+def _overwrite_tags(mesh, tags_to_overwrite, new_tags):
+    stack_indices = np.hstack([new_tags.indices, tags_to_overwrite.indices])
+    stack_values = np.hstack([new_tags.values, tags_to_overwrite.values])
+    overwritten_indices, ind = np.unique(stack_indices, return_index=True)
+    overwritten_values = stack_values[ind]
+
+    overwritten_tags = dfx.mesh.meshtags(mesh, tags_to_overwrite.dim, overwritten_indices, overwritten_values)
+    return overwritten_tags
 
 
 def compute_tags_measures(
@@ -505,6 +573,7 @@ def compute_tags_measures(
     detection_degree: int,
     box_mode: bool = False,
     single_layer_cut: bool = False,
+    overwrite_tags: dict[str,MeshTags] | dict = {},
 ) -> Tuple[
     MeshTags,
     MeshTags,
@@ -528,98 +597,71 @@ def compute_tags_measures(
         The boundaries measure.
         Submesh c-map, v-map and n-map.
     """
-    cells_markers = _tag_cells(
+    cells_tags = _tag_cells(
         mesh, discrete_levelset, detection_degree, single_layer_cut=single_layer_cut
     )
-    facets_markers = _tag_facets(
-        mesh, cells_markers, discrete_levelset, detection_degree
-    )
+    facets_tags = _tag_facets(mesh, cells_tags, discrete_levelset, detection_degree)
+
+    if "cells" in overwrite_tags.keys():
+        ow_cells_tags = overwrite_tags["cells"]
+        if np.any(np.isin([1, 2, 3], ow_cells_tags.values)):
+            raise ValueError("Cannot overwrite cells tags with values 1, 2 or 3.")
+        cells_tags = _overwrite_tags(mesh, cells_tags, ow_cells_tags)
+    if "facets" in overwrite_tags.keys():
+        ow_facets_tags = overwrite_tags["facets"]
+        if np.any(np.isin([1, 2, 3, 4, 5, 6], ow_facets_tags.values)):
+            raise ValueError("Cannot overwrite facets tags with values 1, 2, 3, 4, 5, 6, 100 or 101.")
+        facets_tags = _overwrite_tags(mesh, facets_tags, ow_facets_tags)
 
     if box_mode:
         submesh = None
-        integration_cells = np.union1d(
-            np.where(np.isclose(cells_markers.array[:], 2)),
-            np.where(np.isclose(cells_markers.array[:], 1)),
-        )
+        integration_cells = np.union1d(cells_tags.find(2), cells_tags.find(1))
         integration_entities_outside = _compute_integration_entities(
-            mesh,
-            integration_cells,
-            np.where(np.isclose(facets_markers.array[:], 4)),
-            100,
-        )
-        integration_cells = np.union1d(
-            np.where(np.isclose(cells_markers.array[:], 2)),
-            np.where(np.isclose(cells_markers.array[:], 3)),
-        )
+            mesh, integration_cells, facets_tags.find(4))
+        integration_entities_outside = [(100, integration_entities_outside)]
+        integration_cells = np.union1d(cells_tags.find(2), cells_tags.find(3))
         integration_entities_inside = _compute_integration_entities(
-            mesh,
-            integration_cells,
-            np.where(np.isclose(facets_markers.array[:], 3)),
-            101,
-        )
-        combined_integration_entities = (
-            integration_entities_outside + integration_entities_inside
-        )
+            mesh, integration_cells, facets_tags.find(3))
+        integration_entities_inside = [(101, integration_entities_inside)]
+        combined_integration_entities = integration_entities_outside + integration_entities_inside
+
+        non_phifem_mask = ~np.isin(facets_tags.values, [1, 2, 3, 4, 5, 6])
+        fdim = facets_tags.dim
+        boundary_facets = dfx.mesh.locate_entities_boundary(mesh, fdim, lambda x: np.ones_like(x[0]).astype(bool))
+        non_phifem_facets_bdy = np.isin(facets_tags.indices, boundary_facets)
+        non_phifem_mask *= non_phifem_facets_bdy
+        non_phifem_facets_ind = np.arange(len(facets_tags.indices))[non_phifem_mask]
+        non_phifem_facets = facets_tags.indices[non_phifem_facets_ind]
+        non_phifem_facets_tags = np.unique(facets_tags.values[non_phifem_facets_ind])
+        
+        for tag in non_phifem_facets_tags:
+            cdim = mesh.topology.dim
+            fdim = cdim - 1
+            mesh.topology.create_connectivity(fdim, cdim)
+            f2c_connect = mesh.topology.connectivity(fdim, cdim)
+            f2c_map = _reshape_map(f2c_connect)[0]
+
+            non_phifem_facets_cells = f2c_map[non_phifem_facets]
+
+            assert len(non_phifem_facets_cells) == len(non_phifem_facets)
+
+            combined_integration_entities += [(tag, _compute_integration_entities(mesh, non_phifem_facets_cells, facets_tags.find(tag)))]
 
         boundaries_measure = ufl.Measure(
             "ds", domain=mesh, subdomain_data=combined_integration_entities
         )
         submesh_maps = None
-        indices = np.arange(
-            cells_markers.index_map.size_local + cells_markers.index_map.num_ghosts
-        )
-        cells_tags = dfx.mesh.meshtags(
-            mesh, mesh.topology.dim, indices, cells_markers.array[:]
-        )
-        indices = np.arange(
-            facets_markers.index_map.size_local + facets_markers.index_map.num_ghosts
-        )
-        facets_tags = dfx.mesh.meshtags(
-            mesh, mesh.topology.dim - 1, indices, facets_markers.array[:]
-        )
     else:
         # We create the submesh
-        omega_h_cells = np.unique(
-            np.hstack(
-                [
-                    np.where(np.isclose(cells_markers.array[:], 1)),
-                    np.where(np.isclose(cells_markers.array[:], 2)),
-                ]
-            )
-        )
+        omega_h_cells = np.unique(np.hstack([cells_tags.find(1), cells_tags.find(2)]))
         submesh, c_map, v_map, n_map = dfx.mesh.create_submesh(
             mesh, mesh.topology.dim, omega_h_cells
-        )
-        submesh_maps = [c_map, v_map, n_map]
+        )  # type: ignore
 
-        cells_markers_submesh = _transfer_markers(
-            cells_markers, c_map, submesh.topology.dim
-        )
-        submesh.topology.create_entities(submesh.topology.dim - 1)
-        submesh_imap = submesh.topology.index_map(submesh.topology.dim - 1)
-        submesh_facets = np.arange(submesh_imap.size_local + submesh_imap.num_ghosts)
-        wf_submesh, wf_map = dfx.mesh.create_submesh(
-            submesh, submesh.topology.dim - 1, submesh_facets
-        )[:2]
-        wf_submesh.topology.create_entities(wf_submesh.topology.dim)
-        facets_markers_subwf = _transfer_markers(
-            facets_markers, wf_map, submesh.topology.dim - 1
-        )
+        cells_tags = _transfer_tags(cells_tags, submesh, c_map)
+        facets_tags = _transfer_tags(facets_tags, submesh, c_map, source_mesh=mesh)
         boundaries_measure = ufl.Measure("ds", domain=submesh)
-
-        indices = np.arange(
-            cells_markers_submesh.index_map.size_local
-            + cells_markers_submesh.index_map.num_ghosts
-        )
-        cells_tags = dfx.mesh.meshtags(
-            submesh, submesh.topology.dim, indices, cells_markers_submesh.array[:]
-        )
-        facets_tags = dfx.mesh.meshtags(
-            submesh,
-            submesh.topology.dim - 1,
-            submesh_facets,
-            facets_markers_subwf.array[submesh_facets],
-        )
+        submesh_maps = [c_map, v_map, n_map]
 
     return (
         cells_tags,

{phifem-0.7.0.dev1.dist-info → phifem-0.7.1.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phiFEM
-Version: 0.7.0.dev1
+Version: 0.7.1.dev2
 Summary: phiFEM: convenience tools to use the phiFEM immersed boundary finite element method with dolfinx.
 Project-URL: Homepage, https://github.com/PhiFEM/phiFEM
 Project-URL: Issues, https://github.com/PhiFEM/phiFEM/issues
@@ -113,6 +113,16 @@ To run the demos first clone the repository.
   pytest
   ```
 
+## Disclaimer
+
+The author Raphaël Bulle guarantees that his contributions to this project are generative-ai-free.
+
+<p align="center" width="50%">
+    <img width="30%" src="https://github.com/PhiFEM/phiFEM/raw/main/logo/sw_wbg.png">
+</p>
+
+For more information, see [here (in french)](https://doi.org/10.58079/1591s).
+
 ## License
 
 `phiFEM` is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

phifem-0.7.1.dev2.dist-info/RECORD

@@ -0,0 +1,7 @@
+phifem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+phifem/mesh_scripts.py,sha256=NSciUpSeABNaZAHdihEI4yUqYZGSFk-NvjuRkSUqrhk,26963
+phifem-0.7.1.dev2.dist-info/METADATA,sha256=JxTs9hdtq3hgmaVLZM4F8iCUkuSOb4SNkBfmawf01wo,5603
+phifem-0.7.1.dev2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+phifem-0.7.1.dev2.dist-info/licenses/COPYING,sha256=xTplwv1WHIfqq_EHLvXcq4ZTBCvBUwhGX1JBNYXrYnE,35146
+phifem-0.7.1.dev2.dist-info/licenses/COPYING.lesser,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+phifem-0.7.1.dev2.dist-info/RECORD,,

{phifem-0.7.0.dev1.dist-info → phifem-0.7.1.dev2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any

phifem-0.7.0.dev1.dist-info/RECORD

@@ -1,7 +0,0 @@
-phifem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phifem/mesh_scripts.py,sha256=jVRTsIQRmEffTfhWHyJrqiImqtWZoiCBnSpuhW4W-Ho,24614
-phifem-0.7.0.dev1.dist-info/METADATA,sha256=R0NitwqmCfRUTMiH-p907mLfKPWTX1RTEXJaKO-f0YY,5285
-phifem-0.7.0.dev1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-phifem-0.7.0.dev1.dist-info/licenses/COPYING,sha256=xTplwv1WHIfqq_EHLvXcq4ZTBCvBUwhGX1JBNYXrYnE,35146
-phifem-0.7.0.dev1.dist-info/licenses/COPYING.lesser,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-phifem-0.7.0.dev1.dist-info/RECORD,,