cad-to-dagmc 0.5.0__py3-none-any.whl → 0.5.1__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.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)

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,23 +1,375 @@
 import typing
+from pathlib import Path
+
+import cadquery as cq
+import gmsh
+import numpy as np
+import OCP
+import trimesh
 from cadquery import importers
+from pymoab import core, types
+
+
+def fix_normals(vertices: typing.Sequence, triangles_in_each_volume: typing.Sequence):
+    fixed_triangles = []
+    for triangles in triangles_in_each_volume:
+        fixed_triangles.append(fix_normal(vertices, triangles))
+    return fixed_triangles
+
+
+def fix_normal(vertices: typing.Sequence, triangles: typing.Sequence):
+    mesh = trimesh.Trimesh(vertices=vertices, faces=triangles, process=False)
+
+    mesh.fix_normals()
+
+    return mesh.faces
+
+
+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",
+):
+    """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)
+
+                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
+
+
+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 resulting gmsh object and volumes
+    """
+
+    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.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,
+    )
+
+
+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
+
+
+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"""
+
+    # solids = geometry.Solids()
+
+    bldr = OCP.BOPAlgo.BOPAlgo_Splitter()
+
+    if len(parts) == 1:
+        # merged_solid = cq.Compound(solids)
+
+        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()
+
+    # 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)
+
+    bldr.SetNonDestructive(True)
+
+    bldr.Perform()
+
+    bldr.Images()
 
-# from OCP.TopLoc import TopLoc_Location
-# from OCP.BRep import BRep_Tool
-# from OCP.TopAbs import TopAbs_Orientation
+    merged_solid = cq.Compound(bldr.Shape())
 
-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,
-)
+    return merged_solid, merged_solid.wrapped
 
 
 class CadToDagmc:
@@ -99,16 +451,18 @@ class CadToDagmc:
         for part in self.parts:
             assembly.add(part)
 
-        (
-            imprinted_assembly,
-            imprinted_solids_with_original_id,
-        ) = cq.occ_impl.assembly.imprint(assembly)
+        imprinted_assembly, imprinted_solids_with_org_id = 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,
         )
 
+        original_ids = get_ids_from_assembly(assembly)
+        scrambled_ids = get_ids_from_imprinted_assembly(imprinted_solids_with_org_id)
+
         # both id lists should be the same length as each other and the same
         # length as the self.material_tags
 
@@ -116,13 +470,6 @@ class CadToDagmc:
             original_ids, scrambled_ids, self.material_tags
         )
 
-        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,
-        )
-
         h5m_filename = mesh_to_h5m_in_memory_method(
             volumes=volumes,
             material_tags=material_tags_in_brep_order,
@@ -130,42 +477,3 @@ class CadToDagmc:
             msh_filename=msh_filename,
         )
         return h5m_filename
-
-
-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"""
-
-    # solids = geometry.Solids()
-
-    bldr = OCP.BOPAlgo.BOPAlgo_Splitter()
-
-    if len(parts) == 1:
-        # merged_solid = cq.Compound(solids)
-
-        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()
-
-    # 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)
-
-    bldr.SetNonDestructive(True)
-
-    bldr.Perform()
-
-    bldr.Images()
-
-    merged_solid = cq.Compound(bldr.Shape())
-
-    return merged_solid, merged_solid.wrapped

{cad_to_dagmc-0.5.0.dist-info → cad_to_dagmc-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cad-to-dagmc
-Version: 0.5.0
+Version: 0.5.1
 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
@@ -20,24 +20,25 @@ 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)
+[![CI with model benchmark zoo](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.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 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.
+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 a 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 packages that also create DAGMC geometry [CAD-to-OpenMC](https://github.com/openmsr/CAD_to_OpenMC), [Stellarmesh](https://github.com/Thea-Energy/stellarmesh) 
+
 # Installation prerequisite
 
 In principle, any Conda/Mamba distribution will work. A few Conda/Mamba options are:

cad_to_dagmc-0.5.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+_version.py,sha256=8W5N0WKS0YIWUpfry5TouisDYjsMUIZ7Vc0crGGGQQU,411
+cad_to_dagmc/__init__.py,sha256=fskHUTyCunSpnpJUvBfAYjx4uwDKXHTTiMP6GqnFRf0,494
+cad_to_dagmc/core.py,sha256=rLJT6RhmaqQ2NQm9Nyxj1pqSz5TC0pgET0CvpQFI3TM,16643
+cad_to_dagmc-0.5.1.dist-info/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
+cad_to_dagmc-0.5.1.dist-info/METADATA,sha256=4RxJjQNV7RKMmB_xprO8LJ_OyuLSMlklUtmqaQvtyvo,5583
+cad_to_dagmc-0.5.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+cad_to_dagmc-0.5.1.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
+cad_to_dagmc-0.5.1.dist-info/RECORD,,

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

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.42.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/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,,