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

cad_to_dagmc/core.py

@@ -4,15 +4,32 @@ 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
 from cad_to_dagmc import __version__
-from .direct_mesh_plugin import to_mesh
+import cadquery_direct_mesh_plugin
+
+
+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() -> tuple[core.Core, dict]:
+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,28 +89,66 @@ 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"
         raise ValueError(msg)
 
     # limited attribute checking to see if user passed in a list of CadQuery vectors
-    if hasattr(vertices[0], "x") and hasattr(vertices[0], "y") and hasattr(vertices[0], "z"):
+    if (
+        hasattr(vertices[0], "x")
+        and hasattr(vertices[0], "y")
+        and hasattr(vertices[0], "z")
+    ):
         vertices_floats = []
         for vert in vertices:
             vertices_floats.append((vert.x, vert.y, vert.z))
@@ -142,7 +201,9 @@ def vertices_to_h5m(
                 if len(face_ids_with_solid_ids[face_id]) == 2:
                     other_solid_id = face_ids_with_solid_ids[face_id][1]
                     other_volume_set = volume_sets_by_solid_id[other_solid_id]
-                    sense_data = np.array([other_volume_set, volume_set], dtype="uint64")
+                    sense_data = np.array(
+                        [other_volume_set, volume_set], dtype="uint64"
+                    )
                 else:
                     sense_data = np.array([volume_set, 0], dtype="uint64")
 
@@ -215,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":
@@ -233,7 +730,9 @@ def get_volumes(gmsh, assembly, method="file", scale_factor=1.0):
 
     if scale_factor != 1.0:
         dim_tags = gmsh.model.getEntities(3)
-        gmsh.model.occ.dilate(dim_tags, 0.0, 0.0, 0.0, scale_factor, scale_factor, scale_factor)
+        gmsh.model.occ.dilate(
+            dim_tags, 0.0, 0.0, 0.0, scale_factor, scale_factor, scale_factor
+        )
         # update the model to ensure the scaling factor has been applied
         gmsh.model.occ.synchronize()
 
@@ -298,7 +797,9 @@ def set_sizes_for_mesh(
                 )
 
         # Step 1: Preprocess boundaries to find shared surfaces and decide mesh sizes
-        boundary_sizes = {}  # Dictionary to store the mesh size and count for each boundary
+        boundary_sizes = (
+            {}
+        )  # Dictionary to store the mesh size and count for each boundary
         for volume_id, size in set_size.items():
             boundaries = gmsh.model.getBoundary(
                 [(3, volume_id)], recursive=True
@@ -373,7 +874,8 @@ def mesh_to_vertices_and_triangles(
             for nodeTag in nodeTags:
                 shifted_node_tags.append(nodeTag - 1)
             grouped_node_tags = [
-                shifted_node_tags[i : i + n] for i in range(0, len(shifted_node_tags), n)
+                shifted_node_tags[i : i + n]
+                for i in range(0, len(shifted_node_tags), n)
             ]
             nodes_in_each_surface[surface] = grouped_node_tags
         triangles_by_solid_by_face[vol_id] = nodes_in_each_surface
@@ -433,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
@@ -443,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.
@@ -470,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
@@ -497,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
@@ -509,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.
@@ -542,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
@@ -583,14 +1093,18 @@ class CadToDagmc:
             scaled_part = part
         else:
             scaled_part = part.scale(scale_factor)
-        return self.add_cadquery_object(cadquery_object=scaled_part, material_tags=material_tags)
+        return self.add_cadquery_object(
+            cadquery_object=scaled_part, material_tags=material_tags
+        )
 
     def add_cadquery_object(
         self,
         cadquery_object: (
-            cq.assembly.Assembly | cq.occ_impl.shapes.Compound | cq.occ_impl.shapes.Solid
+            cq.assembly.Assembly
+            | cq.occ_impl.shapes.Compound
+            | cq.occ_impl.shapes.Solid
         ),
-        material_tags: list[str] | None = None,
+        material_tags: list[str] | str,
         scale_factor: float = 1.0,
     ) -> int:
         """Loads the parts from CadQuery object into the model.
@@ -612,25 +1126,43 @@ class CadToDagmc:
             int: number of volumes in the stp file.
         """
 
+        if isinstance(material_tags, str) and material_tags not in [
+            "assembly_materials",
+            "assembly_names",
+        ]:
+            raise ValueError(
+                f"If material_tags is a string it must be 'assembly_materials' or 'assembly_names' but got {material_tags}"
+            )
+
         if isinstance(cadquery_object, cq.assembly.Assembly):
             # look for materials in each part of the assembly
-            if material_tags is None:
+            if material_tags == "assembly_materials":
                 material_tags = []
-                for child in cadquery_object.children:
+                for child in _get_all_leaf_children(cadquery_object):
                     if child.material is not None and child.material.name is not None:
-                        material_tags.append(child.material.name)
+                        material_tags.append(str(child.material.name))
                     else:
                         raise ValueError(
-                            f"Not all parts in the assembly have material tags assigned. "
-                            f"Missing material tag for child: {child}. "
-                            "Please assign material tags to all parts or provide material_tags argument when adding the assembly."
+                            f"Not all parts in the assembly have materials assigned.\n"
+                            f"When adding to an assembly include material=cadquery.Material('material_name')\n"
+                            f"Missing material tag for child: {child}.\n"
+                            "Please assign material tags to all parts or provide material_tags argument when adding the assembly.\n"
                         )
+                print("material_tags found from assembly materials:", material_tags)
+            elif material_tags == "assembly_names":
+                material_tags = []
+                for child in _get_all_leaf_children(cadquery_object):
+                    # parts always have a name as cq will auto assign one
+                    material_tags.append(child.name)
+                print("material_tags found from assembly names:", material_tags)
 
             cadquery_compound = cadquery_object.toCompound()
         else:
             cadquery_compound = cadquery_object
 
-        if isinstance(cadquery_compound, (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)):
+        if isinstance(
+            cadquery_compound, (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)
+        ):
             iterable_solids = cadquery_compound.Solids()
         else:
             iterable_solids = cadquery_compound.val().Solids()
@@ -638,10 +1170,9 @@ class CadToDagmc:
         if scale_factor == 1.0:
             scaled_iterable_solids = iterable_solids
         else:
-            scaled_iterable_solids = [part.scale(scale_factor) for part in iterable_solids]
-
-        # look for materials in the
-        # if material_tags is None:
+            scaled_iterable_solids = [
+                part.scale(scale_factor) for part in iterable_solids
+            ]
 
         check_material_tags(material_tags, scaled_iterable_solids)
         if material_tags:
@@ -742,7 +1273,9 @@ class CadToDagmc:
             gmsh.model.occ.synchronize()
             # Clear the mesh
             gmsh.model.mesh.clear()
-            gmsh.option.setNumber("Mesh.SaveElementTagType", 3)  # Save only volume elements
+            gmsh.option.setNumber(
+                "Mesh.SaveElementTagType", 3
+            )  # Save only volume elements
 
         gmsh.model.mesh.generate(3)
 
@@ -813,7 +1346,9 @@ class CadToDagmc:
 
         gmsh = init_gmsh()
 
-        gmsh, _ = get_volumes(gmsh, imprinted_assembly, method=method, scale_factor=scale_factor)
+        gmsh, _ = get_volumes(
+            gmsh, imprinted_assembly, method=method, scale_factor=scale_factor
+        )
 
         gmsh = set_sizes_for_mesh(
             gmsh=gmsh,
@@ -862,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
@@ -894,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
@@ -907,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)
@@ -1014,8 +1554,7 @@ class CadToDagmc:
         if meshing_backend == "cadquery":
 
             # Mesh the assembly using CadQuery's direct-mesh plugin
-            cq_mesh = to_mesh(
-                assembly,
+            cq_mesh = assembly.toMesh(
                 imprint=imprint,
                 tolerance=tolerance,
                 angular_tolerance=angular_tolerance,
@@ -1024,9 +1563,13 @@ class CadToDagmc:
 
             # Fix the material tag order for imprinted assemblies
             if cq_mesh["imprinted_assembly"] is not None:
-                imprinted_solids_with_org_id = cq_mesh["imprinted_solids_with_orginal_ids"]
+                imprinted_solids_with_org_id = cq_mesh[
+                    "imprinted_solids_with_orginal_ids"
+                ]
 
-                scrambled_ids = get_ids_from_imprinted_assembly(imprinted_solids_with_org_id)
+                scrambled_ids = get_ids_from_imprinted_assembly(
+                    imprinted_solids_with_org_id
+                )
 
                 material_tags_in_brep_order = order_material_ids_by_brep_order(
                     original_ids, scrambled_ids, self.material_tags
@@ -1044,11 +1587,13 @@ class CadToDagmc:
             # If assembly is not to be imprinted, pass through the assembly as-is
             if imprint:
                 print("Imprinting assembly for mesh generation")
-                imprinted_assembly, imprinted_solids_with_org_id = cq.occ_impl.assembly.imprint(
-                    assembly
+                imprinted_assembly, imprinted_solids_with_org_id = (
+                    cq.occ_impl.assembly.imprint(assembly)
                 )
 
-                scrambled_ids = get_ids_from_imprinted_assembly(imprinted_solids_with_org_id)
+                scrambled_ids = get_ids_from_imprinted_assembly(
+                    imprinted_solids_with_org_id
+                )
 
                 material_tags_in_brep_order = order_material_ids_by_brep_order(
                     original_ids, scrambled_ids, self.material_tags
@@ -1092,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:
@@ -1108,7 +1654,9 @@ class CadToDagmc:
                 gmsh.model.removePhysicalGroups([entry])
 
             gmsh.model.mesh.generate(3)
-            gmsh.option.setNumber("Mesh.SaveElementTagType", 3)  # Save only volume elements
+            gmsh.option.setNumber(
+                "Mesh.SaveElementTagType", 3
+            )  # Save only volume elements
             gmsh.write(umesh_filename)
 
             gmsh.finalize()
@@ -1116,3 +1664,13 @@ class CadToDagmc:
             return dagmc_filename, umesh_filename
         else:
             return dagmc_filename
+
+
+def _get_all_leaf_children(assembly):
+    """Recursively yield all leaf children (parts, not assemblies) from a CadQuery assembly."""
+    for child in assembly.children:
+        # If the child is itself an assembly, recurse
+        if hasattr(child, "children") and len(child.children) > 0:
+            yield from _get_all_leaf_children(child)
+        else:
+            yield child