cad-to-dagmc 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.10.0'
-__version_tuple__ = version_tuple = (0, 10, 0)
+__version__ = version = '0.11.0'
+__version_tuple__ = version_tuple = (0, 11, 0)
 
 __commit_id__ = commit_id = None

cad_to_dagmc/__init__.py

@@ -11,6 +11,7 @@ except PackageNotFoundError:
 
     __version__ = get_version(root="..", relative_to=__file__)
 
-__all__ = ["__version__"]
+__all__ = ["__version__", "PyMoabNotFoundError"]
 
 from .core import *
+from .core import PyMoabNotFoundError

cad_to_dagmc/core.py

@@ -4,7 +4,6 @@ import cadquery as cq
 import gmsh
 import numpy as np
 from cadquery import importers
-from pymoab import core, types
 import tempfile
 import warnings
 from typing import Iterable
@@ -12,7 +11,25 @@ from cad_to_dagmc import __version__
 import cadquery_direct_mesh_plugin
 
 
-def define_moab_core_and_tags() -> tuple[core.Core, dict]:
+class PyMoabNotFoundError(ImportError):
+    """Raised when pymoab is not installed but the pymoab backend is requested."""
+
+    def __init__(self, message=None):
+        if message is None:
+            message = (
+                "pymoab is not installed. pymoab/MOAB is not available on PyPI so it "
+                "cannot be included as a dependency of cad-to-dagmc.\n\n"
+                "You can install pymoab via one of these methods:\n"
+                "  1. From conda-forge: conda install -c conda-forge moab\n"
+                "  2. From extra index: pip install --extra-index-url https://shimwell.github.io/wheels moab\n"
+                "  3. From source: https://bitbucket.org/fathomteam/moab\n\n"
+                "Alternatively, use the h5py backend (the default) which does not require pymoab:\n"
+                "  export_dagmc_h5m_file(..., h5m_backend='h5py')"
+            )
+        super().__init__(message)
+
+
+def define_moab_core_and_tags():
     """Creates a MOAB Core instance which can be built up by adding sets of
     triangles to the instance
 
@@ -20,6 +37,10 @@ def define_moab_core_and_tags() -> tuple[core.Core, dict]:
         (pymoab Core): A pymoab.core.Core() instance
         (pymoab tag_handle): A pymoab.core.tag_get_handle() instance
     """
+    try:
+        from pymoab import core, types
+    except ImportError as e:
+        raise PyMoabNotFoundError() from e
 
     # create pymoab instance
     moab_core = core.Core()
@@ -68,21 +89,55 @@ def define_moab_core_and_tags() -> tuple[core.Core, dict]:
 
 def vertices_to_h5m(
     vertices: list[tuple[float, float, float]] | list["cadquery.occ_impl.geom.Vector"],
-    triangles_by_solid_by_face: list[list[tuple[int, int, int]]],
+    triangles_by_solid_by_face: dict[int, dict[int, list[list[int]]]],
     material_tags: list[str],
     h5m_filename: str = "dagmc.h5m",
     implicit_complement_material_tag: str | None = None,
+    method: str = "h5py",
 ):
     """Converts vertices and triangle sets into a tagged h5m file compatible
     with DAGMC enabled neutronics simulations
 
     Args:
-        vertices:
-        triangles:
-        material_tags:
-        h5m_filename:
-        implicit_complement_material_tag:
+        vertices: List of vertex coordinates as (x, y, z) tuples or CadQuery vectors
+        triangles_by_solid_by_face: Dict mapping solid_id -> face_id -> list of triangles
+        material_tags: List of material tag names, one per solid
+        h5m_filename: Output filename for the h5m file
+        implicit_complement_material_tag: Optional material tag for implicit complement
+        method: Backend to use for writing h5m file ('pymoab' or 'h5py')
     """
+    if method == "pymoab":
+        return _vertices_to_h5m_pymoab(
+            vertices=vertices,
+            triangles_by_solid_by_face=triangles_by_solid_by_face,
+            material_tags=material_tags,
+            h5m_filename=h5m_filename,
+            implicit_complement_material_tag=implicit_complement_material_tag,
+        )
+    elif method == "h5py":
+        return _vertices_to_h5m_h5py(
+            vertices=vertices,
+            triangles_by_solid_by_face=triangles_by_solid_by_face,
+            material_tags=material_tags,
+            h5m_filename=h5m_filename,
+            implicit_complement_material_tag=implicit_complement_material_tag,
+        )
+    else:
+        raise ValueError(f"method must be 'pymoab' or 'h5py', not '{method}'")
+
+
+def _vertices_to_h5m_pymoab(
+    vertices: list[tuple[float, float, float]] | list["cadquery.occ_impl.geom.Vector"],
+    triangles_by_solid_by_face: dict[int, dict[int, list[list[int]]]],
+    material_tags: list[str],
+    h5m_filename: str = "dagmc.h5m",
+    implicit_complement_material_tag: str | None = None,
+):
+    """PyMOAB backend for vertices_to_h5m."""
+    try:
+        from pymoab import types
+    except ImportError as e:
+        raise PyMoabNotFoundError() from e
 
     if len(material_tags) != len(triangles_by_solid_by_face):
         msg = f"The number of material_tags provided is {len(material_tags)} and the number of sets of triangles is {len(triangles_by_solid_by_face)}. You must provide one material_tag for every triangle set"
@@ -221,6 +276,442 @@ def vertices_to_h5m(
     return h5m_filename
 
 
+def _vertices_to_h5m_h5py(
+    vertices: list[tuple[float, float, float]] | list["cadquery.occ_impl.geom.Vector"],
+    triangles_by_solid_by_face: dict[int, dict[int, list[list[int]]]],
+    material_tags: list[str],
+    h5m_filename: str = "dagmc.h5m",
+    implicit_complement_material_tag: str | None = None,
+):
+    """H5PY backend for vertices_to_h5m.
+
+    Creates an h5m file compatible with DAGMC using h5py directly,
+    without requiring pymoab.
+    """
+    import h5py
+    from datetime import datetime
+
+    if len(material_tags) != len(triangles_by_solid_by_face):
+        msg = f"The number of material_tags provided is {len(material_tags)} and the number of sets of triangles is {len(triangles_by_solid_by_face)}. You must provide one material_tag for every triangle set"
+        raise ValueError(msg)
+
+    # Convert CadQuery vectors to floats if needed
+    if (
+        hasattr(vertices[0], "x")
+        and hasattr(vertices[0], "y")
+        and hasattr(vertices[0], "z")
+    ):
+        vertices_floats = [(vert.x, vert.y, vert.z) for vert in vertices]
+    else:
+        vertices_floats = vertices
+
+    # Build face_ids_with_solid_ids to track shared faces
+    face_ids_with_solid_ids = {}
+    for solid_id, triangles_on_each_face in triangles_by_solid_by_face.items():
+        for face_id in triangles_on_each_face.keys():
+            if face_id in face_ids_with_solid_ids:
+                face_ids_with_solid_ids[face_id].append(solid_id)
+            else:
+                face_ids_with_solid_ids[face_id] = [solid_id]
+
+    # Collect all unique faces and their triangles
+    all_faces = {}  # face_id -> list of triangles
+    for solid_id, triangles_on_each_face in triangles_by_solid_by_face.items():
+        for face_id, triangles_on_face in triangles_on_each_face.items():
+            if face_id not in all_faces:
+                all_faces[face_id] = triangles_on_face
+
+    # Convert vertices to numpy array
+    vertices_arr = np.asarray(vertices_floats, dtype=np.float64)
+    num_vertices = len(vertices_arr)
+
+    # Collect all triangles
+    all_triangles = []
+    for face_id in sorted(all_faces.keys()):
+        all_triangles.extend(all_faces[face_id])
+    all_triangles = np.asarray(all_triangles, dtype=np.int64)
+    num_triangles = len(all_triangles)
+
+    # Create the h5m file
+    # makes the folder if it does not exist
+    if Path(h5m_filename).parent:
+        Path(h5m_filename).parent.mkdir(parents=True, exist_ok=True)
+
+    with h5py.File(h5m_filename, "w") as f:
+        tstt = f.create_group("tstt")
+
+        # Global ID counter - starts at 1
+        global_id = 1
+
+        # === NODES ===
+        nodes_group = tstt.create_group("nodes")
+        coords = nodes_group.create_dataset("coordinates", data=vertices_arr)
+        coords.attrs.create("start_id", global_id)
+        global_id += num_vertices
+
+        # Node tags
+        node_tags = nodes_group.create_group("tags")
+        node_tags.create_dataset("GLOBAL_ID", data=np.full(num_vertices, -1, dtype=np.int32))
+
+        # === ELEMENTS ===
+        elements = tstt.create_group("elements")
+
+        # Element type enum
+        elems = {
+            "Edge": 1, "Tri": 2, "Quad": 3, "Polygon": 4, "Tet": 5,
+            "Pyramid": 6, "Prism": 7, "Knife": 8, "Hex": 9, "Polyhedron": 10,
+        }
+        tstt["elemtypes"] = h5py.enum_dtype(elems)
+
+        # History
+        now = datetime.now()
+        tstt.create_dataset(
+            "history",
+            data=[
+                "cad_to_dagmc".encode("ascii"),
+                __version__.encode("ascii"),
+                now.strftime("%m/%d/%y").encode("ascii"),
+                now.strftime("%H:%M:%S").encode("ascii"),
+            ],
+        )
+
+        # Triangles
+        tri3_group = elements.create_group("Tri3")
+        tri3_group.attrs.create("element_type", elems["Tri"], dtype=tstt["elemtypes"])
+
+        # Node indices are 1-based in h5m
+        connectivity = tri3_group.create_dataset(
+            "connectivity",
+            data=all_triangles + 1,
+            dtype=np.uint64,
+        )
+        triangle_start_id = global_id
+        connectivity.attrs.create("start_id", triangle_start_id)
+        global_id += num_triangles
+
+        # Triangle tags
+        tags_tri3 = tri3_group.create_group("tags")
+        tags_tri3.create_dataset("GLOBAL_ID", data=np.full(num_triangles, -1, dtype=np.int32))
+
+        # === SETS ===
+        # Plan out the entity set structure:
+        # For each solid: 1 volume set, N surface sets (one per face), 1 group set (material)
+        # Plus: 1 file set at the end, optionally 1 implicit complement group
+
+        solid_ids = list(triangles_by_solid_by_face.keys())
+        num_solids = len(solid_ids)
+
+        # Assign set IDs
+        sets_start_id = global_id
+
+        # Map solid_id -> volume_set_id
+        volume_set_ids = {}
+        # Map face_id -> surface_set_id
+        surface_set_ids = {}
+        # Map solid_id -> group_set_id
+        group_set_ids = {}
+
+        current_set_id = sets_start_id
+
+        # First, assign IDs to all surfaces (one per unique face)
+        for face_id in sorted(all_faces.keys()):
+            surface_set_ids[face_id] = current_set_id
+            current_set_id += 1
+
+        # Then assign IDs to volumes
+        for solid_id in solid_ids:
+            volume_set_ids[solid_id] = current_set_id
+            current_set_id += 1
+
+        # Then assign IDs to groups (materials)
+        for solid_id in solid_ids:
+            group_set_ids[solid_id] = current_set_id
+            current_set_id += 1
+
+        # Implicit complement group (if requested)
+        implicit_complement_set_id = None
+        if implicit_complement_material_tag:
+            implicit_complement_set_id = current_set_id
+            current_set_id += 1
+
+        # File set
+        file_set_id = current_set_id
+        current_set_id += 1
+
+        global_id = current_set_id
+
+        # === TAGS ===
+        tstt_tags = tstt.create_group("tags")
+
+        # Collect tagged set IDs for CATEGORY (all entities)
+        # and GEOM_DIMENSION (only surfaces and volumes - not groups, to match pymoab)
+        category_set_ids = []
+        categories = []
+        geom_dim_set_ids = []
+        geom_dimensions = []
+
+        # Volumes first (to match pymoab ordering)
+        for solid_id in solid_ids:
+            category_set_ids.append(volume_set_ids[solid_id])
+            categories.append("Volume")
+            geom_dim_set_ids.append(volume_set_ids[solid_id])
+            geom_dimensions.append(3)
+
+        # Groups (CATEGORY only - pymoab doesn't set geom_dimension on groups)
+        # Note: Groups COULD have geom_dimension=4 set, but pymoab doesn't do this
+        for solid_id in solid_ids:
+            category_set_ids.append(group_set_ids[solid_id])
+            categories.append("Group")
+
+        # Surfaces
+        for face_id in sorted(all_faces.keys()):
+            category_set_ids.append(surface_set_ids[face_id])
+            categories.append("Surface")
+            geom_dim_set_ids.append(surface_set_ids[face_id])
+            geom_dimensions.append(2)
+
+        # Implicit complement (CATEGORY only)
+        if implicit_complement_material_tag:
+            category_set_ids.append(implicit_complement_set_id)
+            categories.append("Group")
+
+        # CATEGORY tag
+        # Note: We use opaque dtype (|V32) to match pymoab output exactly.
+        # A string dtype (|S32) would also work and be more readable in h5dump,
+        # but we match pymoab for maximum compatibility.
+        cat_group = tstt_tags.create_group("CATEGORY")
+        cat_group.attrs.create("class", 1, dtype=np.int32)
+        cat_group.create_dataset("id_list", data=np.array(category_set_ids, dtype=np.uint64))
+        # Create opaque 32-byte type to match pymoab's H5T_OPAQUE
+        opaque_dt = h5py.opaque_dtype(np.dtype("V32"))
+        cat_group["type"] = opaque_dt
+        # Encode category strings as 32-byte null-padded values
+        cat_values = np.array([s.encode("ascii").ljust(32, b"\x00") for s in categories], dtype="V32")
+        cat_group.create_dataset("values", data=cat_values)
+
+        # GEOM_DIMENSION tag
+        # Note: We only tag surfaces (dim=2) and volumes (dim=3), not groups.
+        # Groups COULD have geom_dimension=4, but pymoab doesn't set this.
+        geom_group = tstt_tags.create_group("GEOM_DIMENSION")
+        geom_group["type"] = np.dtype("i4")
+        geom_group.attrs.create("class", 1, dtype=np.int32)
+        geom_group.attrs.create("default", -1, dtype=geom_group["type"])
+        geom_group.attrs.create("global", -1, dtype=geom_group["type"])
+        geom_group.create_dataset("id_list", data=np.array(geom_dim_set_ids, dtype=np.uint64))
+        geom_group.create_dataset("values", data=np.array(geom_dimensions, dtype=np.int32))
+
+        # GEOM_SENSE_2 tag (only for surfaces)
+        surface_ids_list = [surface_set_ids[fid] for fid in sorted(all_faces.keys())]
+        gs2_group = tstt_tags.create_group("GEOM_SENSE_2")
+        gs2_dtype = np.dtype("(2,)u8")
+        gs2_group["type"] = gs2_dtype
+        gs2_group.attrs.create("class", 1, dtype=np.int32)
+        gs2_group.attrs.create("is_handle", 1, dtype=np.int32)
+        gs2_group.create_dataset("id_list", data=np.array(surface_ids_list, dtype=np.uint64))
+
+        # Build sense data for each surface
+        sense_values = []
+        for face_id in sorted(all_faces.keys()):
+            solids_for_face = face_ids_with_solid_ids[face_id]
+            if len(solids_for_face) == 2:
+                # Shared face - both volumes
+                vol1 = volume_set_ids[solids_for_face[0]]
+                vol2 = volume_set_ids[solids_for_face[1]]
+                sense_values.append([vol1, vol2])
+            else:
+                # Single volume
+                vol = volume_set_ids[solids_for_face[0]]
+                sense_values.append([vol, 0])
+
+        if sense_values:
+            gs2_values = np.zeros((len(sense_values),), dtype=[("f0", "<u8", (2,))])
+            gs2_values["f0"] = np.array(sense_values, dtype=np.uint64)
+            gs2_space = h5py.h5s.create_simple((len(sense_values),))
+            gs2_arr_type = h5py.h5t.array_create(h5py.h5t.NATIVE_UINT64, (2,))
+            gs2_dset = h5py.h5d.create(gs2_group.id, b"values", gs2_arr_type, gs2_space)
+            gs2_dset.write(h5py.h5s.ALL, h5py.h5s.ALL, gs2_values, mtype=gs2_arr_type)
+            gs2_dset.close()
+
+        # GLOBAL_ID tag - store as sparse tag with id_list and values
+        # This stores the user-facing IDs for surfaces and volumes
+        gid_ids = []
+        gid_values = []
+        # Surfaces get their face_id as global_id
+        for face_id in sorted(all_faces.keys()):
+            gid_ids.append(surface_set_ids[face_id])
+            gid_values.append(face_id)
+        # Volumes get their solid_id as global_id
+        for solid_id in solid_ids:
+            gid_ids.append(volume_set_ids[solid_id])
+            gid_values.append(solid_id)
+        # Groups also get the solid_id
+        for solid_id in solid_ids:
+            gid_ids.append(group_set_ids[solid_id])
+            gid_values.append(solid_id)
+
+        gid_group = tstt_tags.create_group("GLOBAL_ID")
+        gid_group["type"] = np.dtype("i4")
+        gid_group.attrs.create("class", 2, dtype=np.int32)
+        gid_group.attrs.create("default", -1, dtype=gid_group["type"])
+        gid_group.attrs.create("global", -1, dtype=gid_group["type"])
+        gid_group.create_dataset("id_list", data=np.array(gid_ids, dtype=np.uint64))
+        gid_group.create_dataset("values", data=np.array(gid_values, dtype=np.int32))
+
+        # NAME tag (for groups - material names)
+        name_ids = []
+        name_values = []
+        for solid_id, mat_tag in zip(solid_ids, material_tags):
+            name_ids.append(group_set_ids[solid_id])
+            name_values.append(f"mat:{mat_tag}")
+        if implicit_complement_material_tag:
+            name_ids.append(implicit_complement_set_id)
+            name_values.append(f"mat:{implicit_complement_material_tag}_comp")
+
+        name_group = tstt_tags.create_group("NAME")
+        name_group.attrs.create("class", 1, dtype=np.int32)
+        name_group.create_dataset("id_list", data=np.array(name_ids, dtype=np.uint64))
+        name_group["type"] = h5py.opaque_dtype(np.dtype("S32"))
+        name_group.create_dataset("values", data=name_values, dtype=name_group["type"])
+
+        # Other standard tags (empty but needed)
+        for tag_name in ["DIRICHLET_SET", "MATERIAL_SET", "NEUMANN_SET"]:
+            tag_grp = tstt_tags.create_group(tag_name)
+            tag_grp["type"] = np.dtype("i4")
+            tag_grp.attrs.create("class", 1, dtype=np.int32)
+            tag_grp.attrs.create("default", -1, dtype=tag_grp["type"])
+            tag_grp.attrs.create("global", -1, dtype=tag_grp["type"])
+
+        # === SETS structure ===
+        sets_group = tstt.create_group("sets")
+
+        # Build contents, parents, children, and list arrays
+        contents = []
+        list_rows = []
+        parents_list = []
+        children_list = []
+
+        # Track triangle ranges per face
+        tri_offset = 0
+        face_triangle_ranges = {}
+        for face_id in sorted(all_faces.keys()):
+            tris = all_faces[face_id]
+            face_triangle_ranges[face_id] = (tri_offset, len(tris))
+            tri_offset += len(tris)
+
+        # Track vertices per face
+        face_vertex_sets = {}
+        for face_id, tris in all_faces.items():
+            verts = set()
+            for tri in tris:
+                verts.update(tri)
+            face_vertex_sets[face_id] = sorted(verts)
+
+        contents_end = -1
+        children_end = -1
+        parents_end = -1
+
+        # Surface sets
+        for face_id in sorted(all_faces.keys()):
+            # Content: vertices + triangles for this face
+            verts = face_vertex_sets[face_id]
+            tri_start, tri_count = face_triangle_ranges[face_id]
+
+            # Add individual vertex handles (1-based IDs)
+            # Don't assume vertices are contiguous - store each one
+            for v in verts:
+                contents.append(v + 1)  # 1-based vertex ID
+
+            # Add individual triangle handles
+            for i in range(tri_count):
+                contents.append(triangle_start_id + tri_start + i)
+
+            contents_end = len(contents) - 1
+
+            # Parent-child: surface is child of volume(s)
+            solids_for_face = face_ids_with_solid_ids[face_id]
+            for solid_id in solids_for_face:
+                parents_list.append(volume_set_ids[solid_id])
+            parents_end = len(parents_list) - 1
+
+            # flags: 2 = MESHSET_SET (handles, not ranges)
+            list_rows.append([contents_end, children_end, parents_end, 2])
+
+        # Volume sets (empty contents, but have surface children)
+        for solid_id in solid_ids:
+            # Volumes have no direct content
+            # Children are the surfaces
+            faces_in_solid = list(triangles_by_solid_by_face[solid_id].keys())
+            for face_id in faces_in_solid:
+                children_list.append(surface_set_ids[face_id])
+            children_end = len(children_list) - 1
+
+            # flags: 2 = handle-based (0b0010)
+            list_rows.append([contents_end, children_end, parents_end, 2])
+
+        # Group sets (contain volume handles)
+        for solid_id in solid_ids:
+            contents.append(volume_set_ids[solid_id])
+            contents_end = len(contents) - 1
+            list_rows.append([contents_end, children_end, parents_end, 2])
+
+        # Implicit complement group
+        if implicit_complement_material_tag:
+            # Add the last volume to the implicit complement group
+            contents.append(volume_set_ids[solid_ids[-1]])
+            contents_end = len(contents) - 1
+            list_rows.append([contents_end, children_end, parents_end, 2])
+
+        # File set (contains everything)
+        contents.extend([1, file_set_id - 1])  # range of all entities
+        contents_end = len(contents) - 1
+        list_rows.append([contents_end, children_end, parents_end, 10])
+
+        # Write sets datasets
+        sets_group.create_dataset("contents", data=np.array(contents, dtype=np.uint64))
+        if children_list:
+            sets_group.create_dataset("children", data=np.array(children_list, dtype=np.uint64))
+        else:
+            sets_group.create_dataset("children", data=np.array([], dtype=np.uint64))
+        if parents_list:
+            sets_group.create_dataset("parents", data=np.array(parents_list, dtype=np.uint64))
+        else:
+            sets_group.create_dataset("parents", data=np.array([], dtype=np.uint64))
+
+        lst = sets_group.create_dataset("list", data=np.array(list_rows, dtype=np.int64))
+        lst.attrs.create("start_id", sets_start_id)
+
+        # Set tags (GLOBAL_ID for each set)
+        sets_tags = sets_group.create_group("tags")
+        set_global_ids = []
+
+        # Surface global IDs
+        for face_id in sorted(all_faces.keys()):
+            set_global_ids.append(face_id)
+
+        # Volume global IDs
+        for solid_id in solid_ids:
+            set_global_ids.append(solid_id)
+
+        # Group global IDs
+        for solid_id in solid_ids:
+            set_global_ids.append(solid_id)
+
+        # Implicit complement
+        if implicit_complement_material_tag:
+            set_global_ids.append(-1)
+
+        # File set
+        set_global_ids.append(-1)
+
+        sets_tags.create_dataset("GLOBAL_ID", data=np.array(set_global_ids, dtype=np.int32))
+
+        # Max ID attribute
+        tstt.attrs.create("max_id", np.uint64(global_id - 1))
+
+    print(f"written DAGMC file {h5m_filename}")
+    return h5m_filename
+
+
 def get_volumes(gmsh, assembly, method="file", scale_factor=1.0):
 
     if method == "in memory":
@@ -444,6 +935,7 @@ def export_gmsh_object_to_dagmc_h5m_file(
     material_tags: list[str] | None = None,
     implicit_complement_material_tag: str | None = None,
     filename: str = "dagmc.h5m",
+    h5m_backend: str = "h5py",
 ) -> str:
     """
     Exports a GMSH object to a DAGMC-compatible h5m file. Note gmsh should
@@ -454,6 +946,7 @@ def export_gmsh_object_to_dagmc_h5m_file(
         material_tags: A list of material tags corresponding to the volumes in the GMSH object.
         implicit_complement_material_tag: The material tag for the implicit complement (void space).
         filename: The name of the output h5m file. Defaults to "dagmc.h5m".
+        h5m_backend: Backend for writing h5m file, 'pymoab' or 'h5py'. Defaults to 'h5py'.
 
     Returns:
         str: The filename of the generated DAGMC h5m file.
@@ -481,6 +974,7 @@ def export_gmsh_object_to_dagmc_h5m_file(
         material_tags=material_tags,
         h5m_filename=filename,
         implicit_complement_material_tag=implicit_complement_material_tag,
+        method=h5m_backend,
     )
 
     return h5m_filename
@@ -508,11 +1002,13 @@ def export_gmsh_file_to_dagmc_h5m_file(
     material_tags: list[str] | None = None,
     implicit_complement_material_tag: str | None = None,
     dagmc_filename: str = "dagmc.h5m",
+    h5m_backend: str = "h5py",
 ) -> str:
     """Saves a DAGMC h5m file of the geometry GMsh file. This function
     initializes and finalizes Gmsh.
 
     Args:
+        gmsh_filename (str): the filename of the GMSH mesh file.
         material_tags (list[str]): the names of the DAGMC
             material tags to assign. These will need to be in the same
             order as the volumes in the GMESH mesh and match the
@@ -520,7 +1016,9 @@ def export_gmsh_file_to_dagmc_h5m_file(
         implicit_complement_material_tag (str | None, optional):
             the name of the material tag to use for the implicit
             complement (void space). Defaults to None which is a vacuum.
-        dagmc_filename (str, optional): _description_. Defaults to "dagmc.h5m".
+        dagmc_filename (str, optional): Output filename. Defaults to "dagmc.h5m".
+        h5m_backend (str, optional): Backend for writing h5m file, 'pymoab' or 'h5py'.
+            Defaults to 'h5py'.
 
     Returns:
         str: The filename of the generated DAGMC h5m file.
@@ -553,6 +1051,7 @@ def export_gmsh_file_to_dagmc_h5m_file(
         material_tags=material_tags,
         h5m_filename=dagmc_filename,
         implicit_complement_material_tag=implicit_complement_material_tag,
+        method=h5m_backend,
     )
 
     return h5m_filename
@@ -898,6 +1397,8 @@ class CadToDagmc:
                 - meshing_backend (str, optional): explicitly specify 'gmsh' or 'cadquery'.
                   If not provided, backend is auto-selected based on other arguments.
                   Defaults to 'cadquery' if no backend-specific arguments are given.
+                - h5m_backend (str, optional): 'pymoab' or 'h5py' for writing h5m files.
+                  Defaults to 'h5py'.
 
                 For GMSH backend:
                 - min_mesh_size (float): minimum mesh element size
@@ -930,7 +1431,7 @@ class CadToDagmc:
             "method",
             "unstructured_volumes",
         }
-        all_acceptable_keys = cadquery_keys | gmsh_keys | {"meshing_backend"}
+        all_acceptable_keys = cadquery_keys | gmsh_keys | {"meshing_backend", "h5m_backend"}
 
         # Check for invalid kwargs
         invalid_keys = set(kwargs.keys()) - all_acceptable_keys
@@ -943,6 +1444,9 @@ class CadToDagmc:
         # Handle meshing_backend - either from kwargs or auto-detect
         meshing_backend = kwargs.pop("meshing_backend", None)
 
+        # Handle h5m_backend - pymoab or h5py
+        h5m_backend = kwargs.pop("h5m_backend", "h5py")
+
         if meshing_backend is None:
             # Auto-select meshing_backend based on kwargs
             has_cadquery = any(key in kwargs for key in cadquery_keys)
@@ -1133,6 +1637,7 @@ class CadToDagmc:
             material_tags=material_tags_in_brep_order,
             h5m_filename=filename,
             implicit_complement_material_tag=implicit_complement_material_tag,
+            method=h5m_backend,
         )
 
         if unstructured_volumes:

cad_to_dagmc-0.11.0.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: cad_to_dagmc
+Version: 0.11.0
+Summary: Converts CAD files to a DAGMC h5m file
+Author-email: Jonathan Shimwell <mail@jshimwell.com>
+Project-URL: Homepage, https://github.com/fusion-energy/cad_to_dagmc
+Project-URL: Bug Tracker, https://github.com/fusion-energy/cad_to_dagmc/issues
+Keywords: dagmc,geometry,plot,slice
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: trimesh
+Requires-Dist: networkx
+Requires-Dist: cadquery>=2.6.0
+Requires-Dist: numpy
+Requires-Dist: gmsh
+Requires-Dist: h5py
+Requires-Dist: cadquery_direct_mesh_plugin>=0.1.0
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-codeblocks; extra == "tests"
+Requires-Dist: vtk; extra == "tests"
+Requires-Dist: assembly-mesh-plugin; extra == "tests"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx-book-theme; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Requires-Dist: sphinx-design; extra == "docs"
+Requires-Dist: sphinxcontrib-mermaid; extra == "docs"
+Requires-Dist: sphinxcadquery; extra == "docs"
+Requires-Dist: pyvista[jupyter]; extra == "docs"
+Requires-Dist: panel; extra == "docs"
+Requires-Dist: jupyter-sphinx; extra == "docs"
+Dynamic: license-file
+
+
+[![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)
+
+[![CI with Conda install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_conda_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_conda_install.yml) Testing package and running examples with dependencies installed via Conda
+
+[![CI with pip install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_pip_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_pip_install.yml) Testing package and running examples with dependencies installed via pip
+
+[![CI with model benchmark zoo](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.yml/badge.svg?branch=main)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.yml) Testing with [Model Benchmark Zoo](https://github.com/fusion-energy/model_benchmark_zoo)
+
+[![Upload Python Package](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml)
+
+[![PyPI](https://img.shields.io/pypi/v/cad_to_dagmc?color=brightgreen&label=pypi&logo=grebrightgreenen&logoColor=green)](https://pypi.org/project/cad_to_dagmc/)
+
+
+A minimal package that converts CAD geometry to [DAGMC](https://github.com/svalinn/DAGMC/) (h5m) files, [unstructured mesh](https://docs.openmc.org/en/latest/pythonapi/generated/openmc.UnstructuredMesh.html) files (vtk) and Gmsh (msh) files ready for use in neutronics simulations.
+
+## See the :point_right: [online documentation](https://fusion-energy.github.io/cad_to_dagmc/) :point_left: for installation options, usage recommendations and Python API details.

cad_to_dagmc-0.11.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+_version.py,sha256=9eKRDJ72C44i2IPiti-C7phzF429SwV2Nogzt0etpr0,706
+cad_to_dagmc/__init__.py,sha256=mGRPqA239UAPXY3wyVefthdMDWz4IPJ5hJjTBeVAex8,555
+cad_to_dagmc/core.py,sha256=6O0SxViLeFYIGIDO-BLVhT7EVDYszuBFv0AywEZTJpY,66658
+cad_to_dagmc-0.11.0.dist-info/licenses/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
+cad_to_dagmc-0.11.0.dist-info/METADATA,sha256=4dpd7Ok3k16qLp_icXlogwcYoBM7lSvuaOI5S2m2_wg,3331
+cad_to_dagmc-0.11.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cad_to_dagmc-0.11.0.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
+cad_to_dagmc-0.11.0.dist-info/RECORD,,

{cad_to_dagmc-0.10.0.dist-info → cad_to_dagmc-0.11.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cad_to_dagmc-0.10.0.dist-info/METADATA

@@ -1,180 +0,0 @@
-Metadata-Version: 2.4
-Name: cad_to_dagmc
-Version: 0.10.0
-Summary: Converts CAD files to a DAGMC h5m file
-Author-email: Jonathan Shimwell <mail@jshimwell.com>
-Project-URL: Homepage, https://github.com/fusion-energy/cad_to_dagmc
-Project-URL: Bug Tracker, https://github.com/fusion-energy/cad_to_dagmc/issues
-Keywords: dagmc,geometry,plot,slice
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: trimesh
-Requires-Dist: networkx
-Requires-Dist: cadquery>=2.6.0
-Requires-Dist: numpy
-Requires-Dist: gmsh
-Requires-Dist: cadquery_direct_mesh_plugin>=0.1.0
-Provides-Extra: tests
-Requires-Dist: pytest; extra == "tests"
-Requires-Dist: vtk; extra == "tests"
-Requires-Dist: assembly-mesh-plugin; extra == "tests"
-Dynamic: license-file
-
-
-[![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)
-
-[![CI with Conda install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_conda_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_conda_install.yml) Testing package and running examples with dependencies installed via Conda
-
-[![CI with pip install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_pip_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_pip_install.yml) Testing package and running examples with dependencies installed vua PIP
-
-[![CI with model benchmark zoo](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.yml/badge.svg?branch=main)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.yml) Testing with [Model Benchmark Zoo](https://github.com/fusion-energy/model_benchmark_zoo)
-
-[![Upload Python Package](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml)
-
-[![PyPI](https://img.shields.io/pypi/v/cad_to_dagmc?color=brightgreen&label=pypi&logo=grebrightgreenen&logoColor=green)](https://pypi.org/project/cad_to_dagmc/)
-
-
-A minimal package that converts CAD geometry to [DAGMC](https://github.com/svalinn/DAGMC/) (h5m) files, [unstructured mesh](https://docs.openmc.org/en/latest/pythonapi/generated/openmc.UnstructuredMesh.html) files (vtk) and Gmsh (msh) files ready for use in neutronics simulations.
-
-cad-to-dagmc can create DAGMC compatible:
-- surface meshes / faceted geometry / triangular meshes
-- unstructured mesh / tetrahedral meshes / volume meshes
-
-cad-to-dagmc can convert the following in to DAGMC compatible meshes:
-- STEP files
-- CadQuery objects (optionally use names as material tags)
-- Gmsh meshes (optionally use physical groups as material tags)
-
-Cad-to-dagmc offers a wide range of features including.
-- Geometry scaling with ```scale_factor``` argument
-- Direct surface meshing of CadQuery geometry with ```tolerance``` and ```angular_tolerance``` arguments (avoids using Gmsh)
-- Model wide mesh Gmsh size parameters with ```min_mesh_size``` and ```max_mesh_size``` arguments
-- Volume specific mesh sizing parameters with the ```set_size``` argument
-- Unstructured mesh that share the same coordinates as the surface mesh.
-- Volume mesh allows selecting individual volumes in the geometry.
-- Parallel meshing to quickly mesh the geometry using multiple CPU cores
-- Imprint and merging of CAD geometry, or disable with the ```imprint``` argument
-- Add geometry from multiple sources ([STEP](http://www.steptools.com/stds/step/) files, [CadQuery](https://cadquery.readthedocs.io) objects and [Gmsh](https://gmsh.info/) meshes)
-- Ability to tag the DAGMC implicit complement material using the ```implicit_complement_material_tag``` argument
-- Selected different Gmesh mesh algorithms (defaults to 1) using the ```mesh_algorithm``` argument
-- Pass CadQuery objects in memory for fast transfer of geometry using the ```method``` argument
-- Easy to install with [pip](https://pypi.org/project/cad-to-dagmc/) and [Conda/Mamba](https://anaconda.org/conda-forge/cad_to_dagmc)
-- Well tested both with [CI unit tests](https://github.com/fusion-energy/cad_to_dagmc/tree/main/tests), integration tests and the CSG [Model Benchmark Zoo](https://github.com/fusion-energy/model_benchmark_zoo).
-- Access to the Gmsh mesh to allow user to define full set of mesh parameters
-- Option to use Gmsh physical groups as material tags
-- Compatibly with [assembly-mesh-plugin](https://github.com/CadQuery/assembly-mesh-plugin) (see examples)
-- Compatible with [Paramak](https://github.com/fusion-energy/paramak) geometry for fusion simulations.
-
-
-# Installation options
-
-- Install using Mamba
-- Install using Conda
-- Install using pip
-
-## Install using Mamba
-
-In principle, installing any Conda/Mamba distribution will work. A few Conda/Mamba options are:
-- [Miniforge](https://github.com/conda-forge/miniforge) (recommended as it includes mamba)
-- [Anaconda](https://www.anaconda.com/download)
-- [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
-
-This example assumes you have installed the Miniforge option or separately have installed Mamba with ```conda install -c conda-forge mamba -y```
-
-Create a new environment, I've chosen Python 3.10 here but newer versions are
-also supported.
-```bash
-mamba create --name new_env python=3.10 -y
-```
-
-Activate the environment
-```bash
-mamba activate new_env
-```
-
-Then you can install the cad_to_dagmc package
-```bash
-mamba install -y -c conda-forge cad_to_dagmc
-```
-
-## Install using Conda
-
-In principle, installing any Conda/Mamba distribution will work. A few Conda/Mamba options are:
-- [Miniforge](https://github.com/conda-forge/miniforge) (recommended as it includes mamba)
-- [Anaconda](https://www.anaconda.com/download)
-- [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
-
-Create a new environment, I've chosen Python 3.10 here but newer versions are
-also supported.
-```bash
-conda create --name new_env python=3.10 -y
-```
-
-Activate the environment
-```bash
-conda activate new_env
-```
-
-Then you can install the cad_to_dagmc package
-```bash
-conda install -y -c conda-forge cad_to_dagmc
-```
-
-## Install using pip and source compilations
-
-It is also possible to avoid the use of conda/mamba and installing using pip.
-
-First ensure hdf5 is installed as this is needed by MOAB pip install command
-
-```
-sudo apt-get install libhdf5-dev
-```
-
-Then install MOAB, currently available from the repo.
-
-```
-pip install git+https://bitbucket.org/fathomteam/moab/
-```
-
-Then you can install the cad_to_dagmc package with ```pip```
-
-```bash
-pip install cad_to_dagmc
-```
-
-## Install with OpenMC or other particle transport codes
-
-You may also want to install OpenMC with DAGMC to make use of the h5m geometry files produced in simulations. However you could also use other supported particle transport codes such as MCNP, FLUKA and others [link to DAGMC documentation](https://svalinn.github.io/DAGMC/).
-
-To install OpenMC you can run ```mamba install -c conda-forge openmc``` however this more specific command makes sure the latest version of OpenMC which contains DAGMC is chosen by conda / mamba
-```bash
-mamba install -c conda-forge -y "openmc=0.15.2=dagmc*nompi*"
-```
-
-You could also install using this [wheel repo](https://github.com/shimwell/wheels)
-
-Another option would be to [install OpenMC from source](https://docs.openmc.org/en/stable/quickinstall.html) which would also need compiling with MOAB and DAGMC options.
-
-
-# Known incompatibilities
-
-The package requires newer versions of Linux. For example the package does not work on Ubuntu 18.04 or older.
-
-The package requires newer versions of pip. It is recommended to ensure that your version of pip is up to date. This can be done with ```python -m pip install --upgrade pip```
-
-Installing one of the package dependancies (Gmsh) with pip appears to result in errors when passing cad objects in memory between cadquery / ocp and gmsh. The default method of passing cad objects is via file so this should not impact most users. The conda install gmsh appears to work fine with in memory passing of cad objects as the version of OCP matches between Gmsh and CadQuery.
-
-
-# Usage
-
-For examples showing creation of DAGMC h5m files, vtk files and usage within OpenMC transport code see the [examples folder](https://github.com/fusion-energy/cad_to_dagmc/tree/main/examples)
-
-For more examples see the CAD tasks in the [neutronics-workshop](https://github.com/fusion-energy/neutronics-workshop) and [model benchmark zoo](https://github.com/fusion-energy/model_benchmark_zoo)
-
-# Related software
-
-Also checkout these other software projects that also create DAGMC geometry [CAD-to-OpenMC](https://github.com/openmsr/CAD_to_OpenMC), [Stellarmesh](https://github.com/Thea-Energy/stellarmesh) and [Coreform Cubit](https://coreform.com/products/coreform-cubit/).

cad_to_dagmc-0.10.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-_version.py,sha256=XS8OMho0YiZyQ_qDeRsy__m_nWUzYVEJw-NLk1VtDQU,706
-cad_to_dagmc/__init__.py,sha256=fskHUTyCunSpnpJUvBfAYjx4uwDKXHTTiMP6GqnFRf0,494
-cad_to_dagmc/core.py,sha256=x4v7EeyXKBqsdcZeq_ks3EQ82yuteedAq8NA76rgJag,45732
-cad_to_dagmc-0.10.0.dist-info/licenses/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
-cad_to_dagmc-0.10.0.dist-info/METADATA,sha256=ZiH6QhnM8Dibqn72qAcMu_RzGyqOxyRKDW997dRkuHc,9045
-cad_to_dagmc-0.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cad_to_dagmc-0.10.0.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
-cad_to_dagmc-0.10.0.dist-info/RECORD,,