cad-to-dagmc 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

_version.py

@@ -2,7 +2,15 @@
 # don't change, don't track in version control
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
 
-__version__ = version = '0.5.0'  # type: str
-__version_tuple__ = version_tuple = (0, 5, 0)  # type: Tuple[int | str, ...]
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)

cad_to_dagmc/__init__.py

@@ -13,9 +13,4 @@ except PackageNotFoundError:
 
 __all__ = ["__version__"]
 
-from .core import CadToDagmc
-from .vertices_to_h5m import vertices_to_h5m
-from .brep_part_finder import *
-from .brep_to_h5m import *
-
-[CadToDagmc, vertices_to_h5m]
+from .core import *

cad_to_dagmc/core.py

@@ -1,38 +1,325 @@
 import typing
+
+import cadquery as cq
+import gmsh
+import numpy as np
 from cadquery import importers
+from pymoab import core, types
+
+
+def _define_moab_core_and_tags() -> typing.Tuple[core.Core, dict]:
+    """Creates a MOAB Core instance which can be built up by adding sets of
+    triangles to the instance
+
+    Returns:
+        (pymoab Core): A pymoab.core.Core() instance
+        (pymoab tag_handle): A pymoab.core.tag_get_handle() instance
+    """
+
+    # create pymoab instance
+    moab_core = core.Core()
+
+    tags = dict()
+
+    sense_tag_name = "GEOM_SENSE_2"
+    sense_tag_size = 2
+    tags["surf_sense"] = moab_core.tag_get_handle(
+        sense_tag_name,
+        sense_tag_size,
+        types.MB_TYPE_HANDLE,
+        types.MB_TAG_SPARSE,
+        create_if_missing=True,
+    )
+
+    tags["category"] = moab_core.tag_get_handle(
+        types.CATEGORY_TAG_NAME,
+        types.CATEGORY_TAG_SIZE,
+        types.MB_TYPE_OPAQUE,
+        types.MB_TAG_SPARSE,
+        create_if_missing=True,
+    )
+
+    tags["name"] = moab_core.tag_get_handle(
+        types.NAME_TAG_NAME,
+        types.NAME_TAG_SIZE,
+        types.MB_TYPE_OPAQUE,
+        types.MB_TAG_SPARSE,
+        create_if_missing=True,
+    )
+
+    tags["geom_dimension"] = moab_core.tag_get_handle(
+        types.GEOM_DIMENSION_TAG_NAME,
+        1,
+        types.MB_TYPE_INTEGER,
+        types.MB_TAG_DENSE,
+        create_if_missing=True,
+    )
+
+    # Global ID is a default tag, just need the name to retrieve
+    tags["global_id"] = moab_core.tag_get_handle(types.GLOBAL_ID_TAG_NAME)
+
+    return moab_core, tags
+
+
+def _vertices_to_h5m(
+    vertices: typing.Union[
+        typing.Iterable[typing.Tuple[float, float, float]],
+        typing.Iterable["cadquery.occ_impl.geom.Vector"],
+    ],
+    triangles_by_solid_by_face: typing.Iterable[typing.Iterable[typing.Tuple[int, int, int]]],
+    material_tags: typing.Iterable[str],
+    h5m_filename="dagmc.h5m",
+    implicit_complement_material_tag=None,
+):
+    """Converts vertices and triangle sets into a tagged h5m file compatible
+    with DAGMC enabled neutronics simulations
+
+    Args:
+        vertices:
+        triangles:
+        material_tags:
+        h5m_filename:
+    """
+
+    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"):
+        vertices_floats = []
+        for vert in vertices:
+            vertices_floats.append((vert.x, vert.y, vert.z))
+    else:
+        vertices_floats = vertices
+
+    face_ids_with_solid_ids = {}
+    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 in face_ids_with_solid_ids.keys():
+                face_ids_with_solid_ids[face_id].append(solid_id)
+            else:
+                face_ids_with_solid_ids[face_id] = [solid_id]
+
+    moab_core, tags = _define_moab_core_and_tags()
+
+    volume_sets_by_solid_id = {}
+    for material_tag, (solid_id, triangles_on_each_face) in zip(
+        material_tags, triangles_by_solid_by_face.items()
+    ):
+        volume_set = moab_core.create_meshset()
+        volume_sets_by_solid_id[solid_id] = volume_set
 
-# from cadquery import Assembly
-# from OCP.GCPnts import GCPnts_QuasiUniformDeflection
+    added_surfaces_ids = {}
+    for material_tag, (solid_id, triangles_on_each_face) in zip(
+        material_tags, triangles_by_solid_by_face.items()
+    ):
+        volume_set = volume_sets_by_solid_id[solid_id]
 
-# from cadquery.occ_impl import shapes
-import OCP
-import cadquery as cq
+        moab_core.tag_set_data(tags["global_id"], volume_set, solid_id)
+        moab_core.tag_set_data(tags["geom_dimension"], volume_set, 3)
+        moab_core.tag_set_data(tags["category"], volume_set, "Volume")
+
+        group_set = moab_core.create_meshset()
+        moab_core.tag_set_data(tags["category"], group_set, "Group")
+        moab_core.tag_set_data(tags["name"], group_set, f"mat:{material_tag}")
+        moab_core.tag_set_data(tags["global_id"], group_set, solid_id)
+        # moab_core.tag_set_data(tags["geom_dimension"], group_set, 4)
+
+        for face_id, triangles_on_face in triangles_on_each_face.items():
+            if face_id not in added_surfaces_ids.keys():
+                face_set = moab_core.create_meshset()
+                moab_core.tag_set_data(tags["global_id"], face_set, face_id)
+                moab_core.tag_set_data(tags["geom_dimension"], face_set, 2)
+                moab_core.tag_set_data(tags["category"], face_set, "Surface")
+
+                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")
+                else:
+                    sense_data = np.array([volume_set, 0], dtype="uint64")
+
+                moab_core.tag_set_data(tags["surf_sense"], face_set, sense_data)
+
+                moab_verts = moab_core.create_vertices(vertices)
+                moab_core.add_entity(face_set, moab_verts)
+
+                for triangle in triangles_on_face:
+                    tri = (
+                        moab_verts[int(triangle[0])],
+                        moab_verts[int(triangle[1])],
+                        moab_verts[int(triangle[2])],
+                    )
+
+                    moab_triangle = moab_core.create_element(types.MBTRI, tri)
+                    moab_core.add_entity(face_set, moab_triangle)
 
-# from OCP.TopLoc import TopLoc_Location
-# from OCP.BRep import BRep_Tool
-# from OCP.TopAbs import TopAbs_Orientation
+                added_surfaces_ids[face_id] = face_set
+            else:
+                face_set = added_surfaces_ids[face_id]
 
-from .brep_to_h5m import mesh_brep, mesh_to_h5m_in_memory_method
-from .brep_part_finder import (
-    get_ids_from_assembly,
-    get_ids_from_imprinted_assembly,
-    order_material_ids_by_brep_order,
-)
+                other_solid_id = face_ids_with_solid_ids[face_id][0]
+
+                other_volume_set = volume_sets_by_solid_id[other_solid_id]
+
+                sense_data = np.array([other_volume_set, volume_set], dtype="uint64")
+                moab_core.tag_set_data(tags["surf_sense"], face_set, sense_data)
+
+            moab_core.add_parent_child(volume_set, face_set)
+
+        moab_core.add_entity(group_set, volume_set)
+
+    if implicit_complement_material_tag:
+        group_set = moab_core.create_meshset()
+        moab_core.tag_set_data(tags["category"], group_set, "Group")
+        moab_core.tag_set_data(
+            tags["name"], group_set, f"mat:{implicit_complement_material_tag}_comp"
+        )
+        moab_core.tag_set_data(tags["geom_dimension"], group_set, 4)
+        moab_core.add_entity(
+            group_set, volume_set
+        )  # volume is arbitrary but should exist in moab core
+
+    all_sets = moab_core.get_entities_by_handle(0)
+
+    file_set = moab_core.create_meshset()
+
+    moab_core.add_entities(file_set, all_sets)
+
+    moab_core.write_file(h5m_filename)
+
+    return h5m_filename
+
+
+def _mesh_brep(
+    brep_object: str,
+    min_mesh_size: float = 1,
+    max_mesh_size: float = 10,
+    mesh_algorithm: int = 1,
+    dimensions: int = 2,
+):
+    """Creates a conformal surface meshes of the volumes in a Brep file using
+    Gmsh.
+
+    Args:
+        brep_object: the filename of the Brep file to convert
+        min_mesh_size: the minimum mesh element size to use in Gmsh. Passed
+            into gmsh.option.setNumber("Mesh.MeshSizeMin", min_mesh_size)
+        max_mesh_size: the maximum mesh element size to use in Gmsh. Passed
+            into gmsh.option.setNumber("Mesh.MeshSizeMax", max_mesh_size)
+        mesh_algorithm: The Gmsh mesh algorithm number to use. Passed into
+            gmsh.option.setNumber("Mesh.Algorithm", mesh_algorithm)
+        dimensions: The number of dimensions, 2 for a surface mesh 3 for a
+            volume mesh. Passed to gmsh.model.mesh.generate()
+
+    Returns:
+        The resulting gmsh object and volumes
+    """
+
+    gmsh.initialize()
+    gmsh.option.setNumber("General.Terminal", 1)
+    gmsh.model.add("made_with_cad_to_dagmc_package")
+    volumes = gmsh.model.occ.importShapesNativePointer(brep_object)
+    gmsh.model.occ.synchronize()
+
+    gmsh.option.setNumber("Mesh.Algorithm", mesh_algorithm)
+    gmsh.option.setNumber("Mesh.MeshSizeMin", min_mesh_size)
+    gmsh.option.setNumber("Mesh.MeshSizeMax", max_mesh_size)
+    gmsh.model.mesh.generate(dimensions)
+
+    return gmsh, volumes
+
+
+def _mesh_to_h5m_in_memory_method(
+    volumes,
+) -> str:
+    """Converts gmsh volumes into a DAGMC h5m file.
+
+    Args:
+        volumes: the volumes in the gmsh file, found with gmsh.model.occ.importShapes
+        material_tags: A list of material tags to tag the DAGMC volumes with.
+            Should be in the same order as the volumes
+        h5m_filename: the filename of the DAGMC h5m file to write
+
+    Returns:
+        vertices and triangles (grouped by solid then by face)
+    """
+
+    n = 3  # number of verts in a triangles
+    triangles_by_solid_by_face = {}
+    for dim_and_vol in volumes:
+        # removes all groups so that the following getEntitiesForPhysicalGroup
+        # command only finds surfaces for the volume
+        gmsh.model.removePhysicalGroups()
+
+        vol_id = dim_and_vol[1]
+        entities_in_volume = gmsh.model.getAdjacencies(3, vol_id)
+        surfaces_in_volume = entities_in_volume[1]
+        ps = gmsh.model.addPhysicalGroup(2, surfaces_in_volume)
+        gmsh.model.setPhysicalName(2, ps, f"surfaces_on_volume_{vol_id}")
+
+        groups = gmsh.model.getPhysicalGroups()
+        group = groups[0]
+        # for group in groups:
+        dim = group[0]
+        tag = group[1]
+
+        surfaces = gmsh.model.getEntitiesForPhysicalGroup(dim, tag)
+
+        # nodes_in_all_surfaces = []
+        nodes_in_each_surface = {}
+        for surface in surfaces:
+            _, _, nodeTags = gmsh.model.mesh.getElements(2, surface)
+            nodeTags = nodeTags[0].tolist()
+            shifted_node_tags = []
+            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)
+            ]
+            nodes_in_each_surface[surface] = grouped_node_tags
+        triangles_by_solid_by_face[vol_id] = nodes_in_each_surface
+
+    _, all_coords, _ = gmsh.model.mesh.getNodes()
+
+    vertices = [all_coords[i : i + n].tolist() for i in range(0, len(all_coords), n)]
+
+    return vertices, triangles_by_solid_by_face
+
+
+def _get_ids_from_assembly(assembly: cq.assembly.Assembly):
+    ids = []
+    for obj, name, loc, _ in assembly:
+        ids.append(name)
+    return ids
+
+
+def _get_ids_from_imprinted_assembly(solid_id_dict):
+    ids = []
+    for id in list(solid_id_dict.values()):
+        ids.append(id[0])
+    return ids
+
+
+def order_material_ids_by_brep_order(original_ids, scrambled_id, material_tags):
+    material_tags_in_brep_order = []
+    for brep_id in scrambled_id:
+        id_of_solid_in_org = original_ids.index(brep_id)
+        material_tags_in_brep_order.append(material_tags[id_of_solid_in_org])
+    return material_tags_in_brep_order
 
 
 class CadToDagmc:
     def __init__(self):
         self.parts = []
-        self.material_tags = []
 
     def add_stp_file(
         self,
         filename: str,
-        material_tags: typing.Iterable[str],
         scale_factor: float = 1.0,
     ):
-        """Loads the parts from stp file into the model keeping track of the
-        parts and their material tags.
+        """Loads the parts from stp file into the model.
 
         Args:
             filename: the filename used to save the html graph.
@@ -47,28 +334,22 @@ class CadToDagmc:
         """
         part = importers.importStep(str(filename)).val()
 
-        if scale_factor == 1:
+        if scale_factor == 1.0:
             scaled_part = part
         else:
             scaled_part = part.scale(scale_factor)
-        self.add_cadquery_object(object=scaled_part, material_tags=material_tags)
+        self.add_cadquery_object(object=scaled_part)
 
     def add_cadquery_object(
         self,
         object: typing.Union[
             cq.assembly.Assembly, cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid
         ],
-        material_tags: typing.Iterable[str],
     ):
-        """Loads the parts from CadQuery object into the model keeping track of
-        the parts and their material tags.
+        """Loads the parts from CadQuery object into the model.
 
         Args:
             object: the cadquery object to convert
-            material_tags: the names of the DAGMC material tags to assign.
-                These will need to be in the same order as the volumes in the
-                STP file and match the material tags used in the neutronics
-                code (e.g. OpenMC).
         """
 
         if isinstance(object, cq.assembly.Assembly):
@@ -80,92 +361,143 @@ class CadToDagmc:
             iterable_solids = object.val().Solids()
         self.parts = self.parts + iterable_solids
 
-        if len(iterable_solids) != len(material_tags):
-            msg = f"Number of volumes {len(iterable_solids)} is not equal to number of material tags {len(material_tags)}"
-            raise ValueError(msg)
-
-        for material_tag in material_tags:
-            self.material_tags.append(material_tag)
-
-    def export_dagmc_h5m_file(
+    def export_unstructured_mesh_file(
         self,
-        filename: str = "dagmc.h5m",
+        filename: str = "umesh.h5m",
         min_mesh_size: float = 1,
         max_mesh_size: float = 5,
         mesh_algorithm: int = 1,
-        msh_filename: str = None,
     ):
+
         assembly = cq.Assembly()
         for part in self.parts:
             assembly.add(part)
 
-        (
-            imprinted_assembly,
-            imprinted_solids_with_original_id,
-        ) = cq.occ_impl.assembly.imprint(assembly)
+        imprinted_assembly, _ = cq.occ_impl.assembly.imprint(assembly)
 
-        original_ids = get_ids_from_assembly(assembly)
-        scrambled_ids = get_ids_from_imprinted_assembly(
-            imprinted_solids_with_original_id
+        gmsh, volumes = _mesh_brep(
+            brep_object=imprinted_assembly.wrapped._address(),
+            min_mesh_size=min_mesh_size,
+            max_mesh_size=max_mesh_size,
+            mesh_algorithm=mesh_algorithm,
+            dimensions=3,
         )
 
-        # both id lists should be the same length as each other and the same
-        # length as the self.material_tags
+        # gmesh writes out a vtk file that is converted by pymoab into a h5 file
+        gmsh.write(filename + ".vtk")
 
-        material_tags_in_brep_order = order_material_ids_by_brep_order(
-            original_ids, scrambled_ids, self.material_tags
-        )
+        moab_core = core.Core()
+        moab_core.load_file(filename + ".vtk")
+        moab_core.write_file(filename)
+
+        gmsh.finalize()
+
+    def export_gmsh_mesh_file(
+        self,
+        filename: str = "mesh.msh",
+        min_mesh_size: float = 1,
+        max_mesh_size: float = 5,
+        mesh_algorithm: int = 1,
+        dimensions: int = 2,
+    ):
+        """Saves a GMesh msh file of the geometry in either 2D surface mesh or
+        3D volume mesh.
+
+        Args:
+            filename
+            min_mesh_size: the minimum size of mesh elements to use.
+            max_mesh_size: the maximum size of mesh elements to use.
+            mesh_algorithm: the gmsh mesh algorithm to use.
+            dimensions: The number of dimensions, 2 for a surface mesh 3 for a
+                volume mesh. Passed to gmsh.model.mesh.generate()
+        """
+
+        assembly = cq.Assembly()
+        for part in self.parts:
+            assembly.add(part)
+
+        imprinted_assembly, _ = cq.occ_impl.assembly.imprint(assembly)
 
-        gmsh, volumes = mesh_brep(
+        gmsh, volumes = _mesh_brep(
             brep_object=imprinted_assembly.wrapped._address(),
             min_mesh_size=min_mesh_size,
             max_mesh_size=max_mesh_size,
             mesh_algorithm=mesh_algorithm,
+            dimensions=dimensions,
         )
 
-        h5m_filename = mesh_to_h5m_in_memory_method(
-            volumes=volumes,
-            material_tags=material_tags_in_brep_order,
-            h5m_filename=filename,
-            msh_filename=msh_filename,
-        )
-        return h5m_filename
+        gmsh.write(filename)
 
+        gmsh.finalize()
 
-def merge_surfaces(parts):
-    """Merges surfaces in the geometry that are the same. More details on
-    the merging process in the DAGMC docs
-    https://svalinn.github.io/DAGMC/usersguide/cubit_basics.html"""
+    def export_dagmc_h5m_file(
+        self,
+        material_tags: typing.Iterable[str],
+        filename: str = "dagmc.h5m",
+        min_mesh_size: float = 1,
+        max_mesh_size: float = 5,
+        mesh_algorithm: int = 1,
+        implicit_complement_material_tag: typing.Optional[str] = None,
+    ):
+        """Saves a DAGMC h5m file of the geometry
 
-    # solids = geometry.Solids()
+        Args:
+            filename
+            min_mesh_size: the minimum size of mesh elements to use.
+            max_mesh_size: the maximum size of mesh elements to use.
+            mesh_algorithm: the gmsh mesh algorithm to use.
+            material_tags: the names of the DAGMC material tags to assign.
+                These will need to be in the same order as the volumes in the
+                geometry geometry added (STP file and CadQuery objects) and
+                match the material tags used in the neutronics code (e.g. OpenMC).
+            implicit_complement_material_tag: the name of the material tag to
+                use for the implicit complement (void space). Defaults to None
+                which is a vacuum.
+        """
+        assembly = cq.Assembly()
+        for part in self.parts:
+            assembly.add(part)
 
-    bldr = OCP.BOPAlgo.BOPAlgo_Splitter()
+        imprinted_assembly, imprinted_solids_with_org_id = cq.occ_impl.assembly.imprint(assembly)
 
-    if len(parts) == 1:
-        # merged_solid = cq.Compound(solids)
+        original_ids = _get_ids_from_assembly(assembly)
+        scrambled_ids = _get_ids_from_imprinted_assembly(imprinted_solids_with_org_id)
 
-        if isinstance(
-            parts[0], (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)
-        ):
-            # stp file
-            return parts[0], parts[0].wrapped
-        else:
-            return parts[0], parts[0].toOCC()
+        # both id lists should be the same length as each other and the same
+        # length as the self.material_tags
 
-    # else:
-    for solid in parts:
-        # checks if solid is a compound as .val() is not needed for compounds
-        if isinstance(solid, (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)):
-            bldr.AddArgument(solid.wrapped)
-        else:
-            bldr.AddArgument(solid.val().wrapped)
+        if len(original_ids) != len(material_tags):
+            msg = f"Number of volumes {len(original_ids)} is not equal to number of material tags {len(material_tags)}"
+            raise ValueError(msg)
+
+        material_tags_in_brep_order = order_material_ids_by_brep_order(
+            original_ids, scrambled_ids, material_tags
+        )
 
-    bldr.SetNonDestructive(True)
+        gmsh, volumes = _mesh_brep(
+            brep_object=imprinted_assembly.wrapped._address(),  # in memory address
+            min_mesh_size=min_mesh_size,
+            max_mesh_size=max_mesh_size,
+            mesh_algorithm=mesh_algorithm,
+        )
 
-    bldr.Perform()
+        if isinstance(material_tags_in_brep_order, str):
+            msg = f"material_tags should be a list of strings, not a single string."
+            raise ValueError(msg)
 
-    bldr.Images()
+        if len(volumes) != len(material_tags_in_brep_order):
+            msg = f"{len(volumes)} volumes found in Brep file is not equal to the number of material_tags {len(material_tags_in_brep_order)} provided."
+            raise ValueError(msg)
+
+        vertices, triangles_by_solid_by_face = _mesh_to_h5m_in_memory_method(volumes=volumes)
 
-    merged_solid = cq.Compound(bldr.Shape())
+        gmsh.finalize()
 
-    return merged_solid, merged_solid.wrapped
+        # checks and fixes triangle fix_normals within vertices_to_h5m
+        return _vertices_to_h5m(
+            vertices=vertices,
+            triangles_by_solid_by_face=triangles_by_solid_by_face,
+            material_tags=material_tags_in_brep_order,
+            h5m_filename=filename,
+            implicit_complement_material_tag=implicit_complement_material_tag,
+        )

cad_to_dagmc-0.6.0.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.1
+Name: cad_to_dagmc
+Version: 0.6.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
+Provides-Extra: tests
+Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: vtk ; extra == 'tests'
+
+
+[![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)
+
+[![CI with install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml/badge.svg?branch=main)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml) Testing package and running examples
+
+[![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
+
+cad-to-dagmc can create:
+- surface meshes / faceted geometry / triangular meshes
+- unstructured mesh / tetrahedral meshes / volume meshes
+
+cad-to-dagmc can convert:
+- STEP files
+- CadQuery objects (in memory)
+
+cadto-dagmc aims to produce DAGMC compatible h5m files from CAD geometry is intended to convert [STEP](http://www.steptools.com/stds/step/) files or [CadQuery](https://cadquery.readthedocs.io) objects to a [DAGMC](https://github.com/svalinn/DAGMC/) compatible h5m file.
+
+
+The resulting DAGMC geometry can then be used for simulations in [OpenMC](https://github.com/openmc-dev/openmc/) or [other supported codes](https://svalinn.github.io/DAGMC/).
+
+This package is tested with [pytest tests](https://github.com/fusion-energy/cad_to_dagmc/tree/main/tests) and also the DAGMC geometry made with this package is compared to simulation carried out with native constructive solid geometry, see [Model Benchmark Zoo](https://github.com/fusion-energy/model_benchmark_zoo) for more details.
+
+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/)
+
+# Installation prerequisite
+
+In principle, 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)
+
+
+# Install using Mamba and pip
+
+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 conda 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
+```
+
+Install the dependencies
+```bash
+mamba install -y -c conda-forge gmsh python-gmsh moab>=5.3.0 ocp>=7.7.2.0 cadquery>=2.4.0
+```
+
+Then you can install the cad_to_dagmc package with ```pip```
+```bash
+pip install cad_to_dagmc
+```
+
+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.14.0=dagmc*nompi*"
+```
+
+It might not be possible to install OpenMC and cad-to-dagmc in the same conda/mamba python environment so you may have to create a new conda/mamba environment and install OpenMC there.
+
+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. 
+
+
+# Install using Conda and pip
+
+This example uses Conda to install some dependencies that are not available via PyPi.
+
+Create a new conda environment
+```bash
+conda create --name new_env python=3.10 -y
+```
+
+Activate the environment
+```bash
+conda activate new_env
+```
+
+Install the dependencies
+```bash
+conda install -y -c conda-forge gmsh python-gmsh moab>=5.3.0 ocp>=7.7.2.0 cadquery>=2.4.0
+```
+
+Then you can install the cad_to_dagmc package with ```pip```
+```bash
+pip install cad_to_dagmc
+```
+
+# Usage - with OpenMC
+
+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 supported by [DAGMC](https://svalinn.github.io/DAGMC/).
+
+You can run ```mamba install -c conda-forge openmc``` however this may choose to install OpenMC without DAGMC included.
+
+You can be more specific with conda/mamba commands to make sure the latest version of OpenMC which contains DAGMC is chosen by conda / mamba
+```bash
+mamba install -c conda-forge -y "openmc=0.14.0=dagmc*nompi*"
+```
+
+You could also [install OpenMC from source](https://docs.openmc.org/en/stable/quickinstall.html) which might be prefered as it can be tricky for the conda enviroment to get resolved.
+
+
+
+# Usage - creation of DAGMC h5m files
+
+For examples see the [examples folder](https://github.com/fusion-energy/cad_to_dagmc/tree/main/examples)
+
+# Usage - simulation with transport code
+
+For examples 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)

cad_to_dagmc-0.6.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+_version.py,sha256=2JKwcA-YQ0okV2N-gwTWy_n51igWrPcsKQFm0cnqsvw,411
+cad_to_dagmc/__init__.py,sha256=fskHUTyCunSpnpJUvBfAYjx4uwDKXHTTiMP6GqnFRf0,494
+cad_to_dagmc/core.py,sha256=eMwKgKOjje3gBZEqjNzy9O6NF8a02WxD-VhXB5AJg58,18108
+cad_to_dagmc-0.6.0.dist-info/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
+cad_to_dagmc-0.6.0.dist-info/METADATA,sha256=Zrz_-X2KkLAoKrucNIcvOr1070dmSxq10ytsfqU5oWA,6771
+cad_to_dagmc-0.6.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cad_to_dagmc-0.6.0.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
+cad_to_dagmc-0.6.0.dist-info/RECORD,,

{cad_to_dagmc-0.5.0.dist-info → cad_to_dagmc-0.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cad_to_dagmc/brep_part_finder.py

@@ -1,36 +0,0 @@
-import cadquery as cq
-
-
-def convert_shape_to_iterable_of_shapes(shapes):
-    if isinstance(shapes, cq.occ_impl.shapes.Compound):
-        # brep route
-        iterable_solids = shapes.Solids()
-    elif isinstance(shapes, cq.Workplane):
-        # workplane route
-        iterable_solids = shapes.val().Solids()
-    else:
-        iterable_solids = shapes.Solids()
-
-    return iterable_solids
-
-
-def get_ids_from_assembly(assembly):
-    ids = []
-    for obj, name, loc, _ in assembly:
-        ids.append(name)
-    return ids
-
-
-def get_ids_from_imprinted_assembly(solid_id_dict):
-    ids = []
-    for id in list(solid_id_dict.values()):
-        ids.append(id[0])
-    return ids
-
-
-def order_material_ids_by_brep_order(original_ids, scrambled_id, material_tags):
-    material_tags_in_brep_order = []
-    for brep_id in scrambled_id:
-        id_of_solid_in_org = original_ids.index(brep_id)
-        material_tags_in_brep_order.append(material_tags[id_of_solid_in_org])
-    return material_tags_in_brep_order

cad_to_dagmc/brep_to_h5m.py

@@ -1,121 +0,0 @@
-import gmsh
-from pathlib import Path
-from .vertices_to_h5m import vertices_to_h5m
-import typing
-
-
-def mesh_brep(
-    brep_object: str,
-    min_mesh_size: float = 1,
-    max_mesh_size: float = 10,
-    mesh_algorithm: int = 1,
-):
-    """Creates a conformal surface meshes of the volumes in a Brep file using
-    Gmsh.
-
-    Args:
-        brep_object: the filename of the Brep file to convert
-        min_mesh_size: the minimum mesh element size to use in Gmsh. Passed
-            into gmsh.option.setNumber("Mesh.MeshSizeMin", min_mesh_size)
-        max_mesh_size: the maximum mesh element size to use in Gmsh. Passed
-            into gmsh.option.setNumber("Mesh.MeshSizeMax", max_mesh_size)
-        mesh_algorithm: The Gmsh mesh algorithm number to use. Passed into
-            gmsh.option.setNumber("Mesh.Algorithm", mesh_algorithm)
-
-    Returns:
-        The gmsh object and volumes in Brep file
-    """
-
-    gmsh.initialize()
-    gmsh.option.setNumber("General.Terminal", 1)
-    gmsh.model.add("made_with_brep_to_h5m_package")
-    volumes = gmsh.model.occ.importShapesNativePointer(brep_object)
-    # gmsh.model.occ.importShapes(brep_object)
-    gmsh.model.occ.synchronize()
-
-    gmsh.option.setNumber("Mesh.Algorithm", mesh_algorithm)
-    gmsh.option.setNumber("Mesh.MeshSizeMin", min_mesh_size)
-    gmsh.option.setNumber("Mesh.MeshSizeMax", max_mesh_size)
-    gmsh.model.mesh.generate(2)
-
-    return gmsh, volumes
-
-
-def mesh_to_h5m_in_memory_method(
-    volumes,
-    material_tags: typing.Iterable[str],
-    h5m_filename: str = "dagmc.h5m",
-    msh_filename=None,
-) -> str:
-    """Converts gmsh volumes into a DAGMC h5m file.
-
-    Args:
-        volumes: the volumes in the gmsh file, found with gmsh.model.occ.importShapes
-        material_tags: A list of material tags to tag the DAGMC volumes with.
-            Should be in the same order as the volumes
-        h5m_filename: the filename of the DAGMC h5m file to write
-
-    Returns:
-        The filename of the h5m file produced
-    """
-
-    if isinstance(material_tags, str):
-        msg = f"material_tags should be a list of strings, not a single string."
-        raise ValueError(msg)
-
-    if len(volumes) != len(material_tags):
-        msg = f"{len(volumes)} volumes found in Brep file is not equal to the number of material_tags {len(material_tags)} provided."
-        raise ValueError(msg)
-
-    n = 3  # number of verts in a triangles
-    triangles_by_solid_by_face = {}
-    for dim_and_vol in volumes:
-        # removes all groups so that the following getEntitiesForPhysicalGroup
-        # command only finds surfaces for the volume
-        gmsh.model.removePhysicalGroups()
-
-        vol_id = dim_and_vol[1]
-        entities_in_volume = gmsh.model.getAdjacencies(3, vol_id)
-        surfaces_in_volume = entities_in_volume[1]
-        ps = gmsh.model.addPhysicalGroup(2, surfaces_in_volume)
-        gmsh.model.setPhysicalName(2, ps, f"surfaces_on_volume_{vol_id}")
-
-        groups = gmsh.model.getPhysicalGroups()
-        group = groups[0]
-        # for group in groups:
-        dim = group[0]
-        tag = group[1]
-
-        surfaces = gmsh.model.getEntitiesForPhysicalGroup(dim, tag)
-
-        # nodes_in_all_surfaces = []
-        nodes_in_each_surface = {}
-        for surface in surfaces:
-            _, _, nodeTags = gmsh.model.mesh.getElements(2, surface)
-            nodeTags = nodeTags[0].tolist()
-            shifted_node_tags = []
-            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)
-            ]
-            nodes_in_each_surface[surface] = grouped_node_tags
-        triangles_by_solid_by_face[vol_id] = nodes_in_each_surface
-
-    _, all_coords, _ = gmsh.model.mesh.getNodes()
-
-    vertices = [all_coords[i : i + n].tolist() for i in range(0, len(all_coords), n)]
-
-    if msh_filename is not None:
-        gmsh.write(msh_filename)
-
-    gmsh.finalize()
-
-    # checks and fixes triangle fix_normals within vertices_to_h5m
-    return vertices_to_h5m(
-        vertices=vertices,
-        triangles_by_solid_by_face=triangles_by_solid_by_face,
-        material_tags=material_tags,
-        h5m_filename=h5m_filename,
-    )

cad_to_dagmc/vertices_to_h5m.py

@@ -1,262 +0,0 @@
-from typing import Iterable, Tuple, Union
-import typing
-import numpy as np
-import trimesh
-from pymoab import core, types
-
-
-def fix_normals(vertices: list, triangles_in_each_volume: list):
-    fixed_triangles = []
-    for triangles in triangles_in_each_volume:
-        fixed_triangles.append(fix_normal(vertices, triangles))
-    return fixed_triangles
-
-
-def fix_normal(vertices: list, triangles: list):
-    mesh = trimesh.Trimesh(vertices=vertices, faces=triangles, process=False)
-
-    mesh.fix_normals()
-
-    return mesh.faces
-
-
-def _define_moab_core_and_tags() -> Tuple[core.Core, dict]:
-    """Creates a MOAB Core instance which can be built up by adding sets of
-    triangles to the instance
-
-    Returns:
-        (pymoab Core): A pymoab.core.Core() instance
-        (pymoab tag_handle): A pymoab.core.tag_get_handle() instance
-    """
-
-    # create pymoab instance
-    moab_core = core.Core()
-
-    tags = dict()
-
-    sense_tag_name = "GEOM_SENSE_2"
-    sense_tag_size = 2
-    tags["surf_sense"] = moab_core.tag_get_handle(
-        sense_tag_name,
-        sense_tag_size,
-        types.MB_TYPE_HANDLE,
-        types.MB_TAG_SPARSE,
-        create_if_missing=True,
-    )
-
-    tags["category"] = moab_core.tag_get_handle(
-        types.CATEGORY_TAG_NAME,
-        types.CATEGORY_TAG_SIZE,
-        types.MB_TYPE_OPAQUE,
-        types.MB_TAG_SPARSE,
-        create_if_missing=True,
-    )
-
-    tags["name"] = moab_core.tag_get_handle(
-        types.NAME_TAG_NAME,
-        types.NAME_TAG_SIZE,
-        types.MB_TYPE_OPAQUE,
-        types.MB_TAG_SPARSE,
-        create_if_missing=True,
-    )
-
-    tags["geom_dimension"] = moab_core.tag_get_handle(
-        types.GEOM_DIMENSION_TAG_NAME,
-        1,
-        types.MB_TYPE_INTEGER,
-        types.MB_TAG_DENSE,
-        create_if_missing=True,
-    )
-
-    # Global ID is a default tag, just need the name to retrieve
-    tags["global_id"] = moab_core.tag_get_handle(types.GLOBAL_ID_TAG_NAME)
-
-    return moab_core, tags
-
-
-def prepare_moab_core_volume_set(
-    moab_core,
-    volume_id,
-    tags,
-):
-    volume_set = moab_core.create_meshset()
-
-    # recent versions of MOAB handle this automatically
-    # but best to go ahead and do it manually
-    moab_core.tag_set_data(tags["global_id"], volume_set, volume_id)
-
-    # set geom IDs
-    moab_core.tag_set_data(tags["geom_dimension"], volume_set, 3)
-
-    # set category tag values
-    moab_core.tag_set_data(tags["category"], volume_set, "Volume")
-
-    return moab_core, volume_set
-
-
-def prepare_moab_core_surface_set(
-    moab_core,
-    surface_id,
-    tags,
-):
-    surface_set = moab_core.create_meshset()
-
-    moab_core.tag_set_data(tags["global_id"], surface_set, surface_id)
-
-    # set geom IDs
-    moab_core.tag_set_data(tags["geom_dimension"], surface_set, 2)
-
-    # set category tag values
-    moab_core.tag_set_data(tags["category"], surface_set, "Surface")
-
-    return moab_core, surface_set
-
-
-def add_triangles_to_moab_core(
-    material_tag, surface_set, moab_core, tags, triangles, moab_verts, volume_set
-):
-    for triangle in triangles:
-        tri = (
-            moab_verts[int(triangle[0])],
-            moab_verts[int(triangle[1])],
-            moab_verts[int(triangle[2])],
-        )
-
-        moab_triangle = moab_core.create_element(types.MBTRI, tri)
-        moab_core.add_entity(surface_set, moab_triangle)
-
-    group_set = moab_core.create_meshset()
-
-    moab_core.tag_set_data(tags["category"], group_set, "Group")
-
-    moab_core.tag_set_data(tags["name"], group_set, f"mat:{material_tag}")
-
-    moab_core.tag_set_data(tags["geom_dimension"], group_set, 4)
-
-    moab_core.add_entity(group_set, volume_set)
-
-    return moab_core
-
-
-def vertices_to_h5m(
-    vertices: Union[
-        Iterable[Tuple[float, float, float]], Iterable["cadquery.occ_impl.geom.Vector"]
-    ],
-    triangles_by_solid_by_face: Iterable[Iterable[Tuple[int, int, int]]],
-    material_tags: Iterable[str],
-    h5m_filename="dagmc.h5m",
-):
-    """Converts vertices and triangle sets into a tagged h5m file compatible
-    with DAGMC enabled neutronics simulations
-
-    Args:
-        vertices:
-        triangles:
-        material_tags:
-        h5m_filename:
-    """
-
-    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")
-    ):
-        vertices_floats = []
-        for vert in vertices:
-            vertices_floats.append((vert.x, vert.y, vert.z))
-    else:
-        vertices_floats = vertices
-
-    face_ids_with_solid_ids = {}
-    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 in face_ids_with_solid_ids.keys():
-                face_ids_with_solid_ids[face_id].append(solid_id)
-            else:
-                face_ids_with_solid_ids[face_id] = [solid_id]
-
-    moab_core, tags = _define_moab_core_and_tags()
-
-    volume_sets_by_solid_id = {}
-    for material_tag, (solid_id, triangles_on_each_face) in zip(
-        material_tags, triangles_by_solid_by_face.items()
-    ):
-        volume_set = moab_core.create_meshset()
-        volume_sets_by_solid_id[solid_id] = volume_set
-
-    added_surfaces_ids = {}
-    for material_tag, (solid_id, triangles_on_each_face) in zip(
-        material_tags, triangles_by_solid_by_face.items()
-    ):
-        volume_set = volume_sets_by_solid_id[solid_id]
-
-        moab_core.tag_set_data(tags["global_id"], volume_set, solid_id)
-        moab_core.tag_set_data(tags["geom_dimension"], volume_set, 3)
-        moab_core.tag_set_data(tags["category"], volume_set, "Volume")
-
-        group_set = moab_core.create_meshset()
-        moab_core.tag_set_data(tags["category"], group_set, "Group")
-        moab_core.tag_set_data(tags["name"], group_set, f"mat:{material_tag}")
-        moab_core.tag_set_data(tags["global_id"], group_set, solid_id)
-        # moab_core.tag_set_data(tags["geom_dimension"], group_set, 4)
-
-        for face_id, triangles_on_face in triangles_on_each_face.items():
-            if face_id not in added_surfaces_ids.keys():
-                face_set = moab_core.create_meshset()
-                moab_core.tag_set_data(tags["global_id"], face_set, face_id)
-                moab_core.tag_set_data(tags["geom_dimension"], face_set, 2)
-                moab_core.tag_set_data(tags["category"], face_set, "Surface")
-
-                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"
-                    )
-                else:
-                    sense_data = np.array([volume_set, 0], dtype="uint64")
-
-                moab_core.tag_set_data(tags["surf_sense"], face_set, sense_data)
-
-                moab_verts = moab_core.create_vertices(vertices)
-                moab_core.add_entity(face_set, moab_verts)
-
-                for triangle in triangles_on_face:
-                    tri = (
-                        moab_verts[int(triangle[0])],
-                        moab_verts[int(triangle[1])],
-                        moab_verts[int(triangle[2])],
-                    )
-
-                    moab_triangle = moab_core.create_element(types.MBTRI, tri)
-                    moab_core.add_entity(face_set, moab_triangle)
-
-                added_surfaces_ids[face_id] = face_set
-            else:
-                face_set = added_surfaces_ids[face_id]
-
-                other_solid_id = face_ids_with_solid_ids[face_id][0]
-
-                other_volume_set = volume_sets_by_solid_id[other_solid_id]
-
-                sense_data = np.array([other_volume_set, volume_set], dtype="uint64")
-                moab_core.tag_set_data(tags["surf_sense"], face_set, sense_data)
-
-            moab_core.add_parent_child(volume_set, face_set)
-
-        moab_core.add_entity(group_set, volume_set)
-
-    all_sets = moab_core.get_entities_by_handle(0)
-
-    file_set = moab_core.create_meshset()
-
-    moab_core.add_entities(file_set, all_sets)
-
-    moab_core.write_file(h5m_filename)
-
-    return h5m_filename

cad_to_dagmc-0.5.0.dist-info/METADATA

@@ -1,119 +0,0 @@
-Metadata-Version: 2.1
-Name: cad-to-dagmc
-Version: 0.5.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
-Provides-Extra: tests
-Requires-Dist: pytest ; extra == 'tests'
-
-
-[![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)
-
-[![CI with install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml)
-
-[![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 uses CadQuery functionality to convert CAD geometry to [DAGMC](https://github.com/svalinn/DAGMC/) h5m files
-
-This particular method of producing DAGMC compatible h5m files from CAD geometry
-is intended to convert STP files or [CadQuery](https://cadquery.readthedocs.io) objects to h5m file.
-
-One unique feature of this package is the ability to combine STP files with CadQuery objects.
-This allows for the addition of parametric geometry to static geometry.
-
-The resulting DAGMC geometry can then be used for simulations in [OpenMC](https://github.com/openmc-dev/openmc/) or [other supported codes](https://svalinn.github.io/DAGMC/).
-
-# Installation prerequisite
-
-In principle, any Conda/Mamba distribution will work. A few Conda/Mamba options are:
-- [Mambaforge](https://github.com/conda-forge/miniforge#mambaforge)
-- [Miniforge](https://github.com/conda-forge/miniforge#miniforge-pypy3)
-- [Anaconda](https://www.anaconda.com/download)
-- [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
-
-
-# Install using Mamba and pip
-
-This example assumes you have installed the MambaForge option or separately
-installed Mamba with ```conda install -c conda-forge mamba -y```
-
-Create a new conda environment, I've chosen Python 3.9 here but new versions are
-also supported.
-```bash
-mamba create --name new_env python=3.9 -y
-```
-
-Activate the environment
-```bash
-mamba activate new_env
-```
-
-Install the dependencies
-```bash
-mamba install -c cadquery -c conda-forge moab gmsh python-gmsh cadquery=master -y
-```
-
-Then you can install the cad_to_dagmc package with ```pip```
-```bash
-pip install cad_to_dagmc
-```
-
-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/).You can run ```conda 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.13.3=dagmc*nompi*"
-```
-
-
-# Install using Conda and pip
-
-This example uses Conda to install some dependencies that are not available via PyPi.
-
-Create a new conda environment
-```bash
-conda create --name new_env python=3.9 -y
-```
-
-Activate the environment
-```bash
-conda activate new_env
-```
-
-Install the dependencies
-```bash
-conda install -c cadquery -c conda-forge moab gmsh python-gmsh cadquery=master -y
-```
-
-Then you can install the cad_to_dagmc package with ```pip```
-```bash
-pip install cad_to_dagmc
-```
-
-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/).You can run ```conda 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
-conda install -c conda-forge -y "openmc=0.13.3=dagmc*nompi*"
-```
-
-
-
-# Usage - creation of DAGMC h5m files
-
-For examples see the [examples folder](https://github.com/fusion-energy/cad_to_dagmc/tree/main/examples)
-
-# Usage - simulation with transport code
-
-For examples see the CAD tasks in the [neutronics-workshop](https://github.com/fusion-energy/neutronics-workshop)

cad_to_dagmc-0.5.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-_version.py,sha256=3YxISZVp_DgBHizWP4UzbUATbJ2-kn6oz3xEF0uxyCg,274
-cad_to_dagmc/__init__.py,sha256=pI6sOn4nbEiZClP53g2UJSNgE8tkm9wz-hA_JLwUkLk,638
-cad_to_dagmc/brep_part_finder.py,sha256=Se5IYTbPvmYOU28C-Sx2xYrn6ZRVXWicNjra1lVyWxw,999
-cad_to_dagmc/brep_to_h5m.py,sha256=AXm8AF68rD6iSNpLcSyGwCPTUyXC1yoLH47Q4hmUZFc,4266
-cad_to_dagmc/core.py,sha256=Sd2ITQfg2pEcRjpUGZgysGJNdiXrk9En953ItqgAH7o,5584
-cad_to_dagmc/vertices_to_h5m.py,sha256=AUi8ddOl5pv1riH7rZY4r4L1GsgoPUO_NZ4S2sxwPJQ,8550
-cad_to_dagmc-0.5.0.dist-info/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
-cad_to_dagmc-0.5.0.dist-info/METADATA,sha256=oj692qzyRJyYR13BfyZyaoJ4Ue1QMKvbRs6U2osQ19U,4838
-cad_to_dagmc-0.5.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-cad_to_dagmc-0.5.0.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
-cad_to_dagmc-0.5.0.dist-info/RECORD,,