cad-to-dagmc 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

_version.py

@@ -1,4 +1,16 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+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,7 +13,4 @@ except PackageNotFoundError:
 
 __all__ = ["__version__"]
 
-from .core import CadToDagmc
-from .vertices_to_h5m import *
-from .brep_part_finder import *
-from .brep_to_h5m import *
+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:
@@ -45,7 +397,6 @@ class CadToDagmc:
                 Useful when converting the geometry to cm for use in neutronics
                 simulations.
         """
-        print(f"loading stp file {filename}")
         part = importers.importStep(str(filename)).val()
 
         if scale_factor == 1:
@@ -73,7 +424,6 @@ class CadToDagmc:
         """
 
         if isinstance(object, cq.assembly.Assembly):
-            print("assembly found")
             object = object.toCompound()
 
         if isinstance(object, (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)):
@@ -93,23 +443,26 @@ class CadToDagmc:
         self,
         filename: str = "dagmc.h5m",
         min_mesh_size: float = 1,
-        max_mesh_size: float = 10,
+        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, 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
 
@@ -117,55 +470,10 @@ 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,
             h5m_filename=filename,
+            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.4.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.4.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,46 +20,53 @@ 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
 
-[![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)
+[![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
+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.
+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.
 
-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
+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.
 
-In principle, any Conda distribution will work. 
+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
 
-# Install using Conda and pip
+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)
 
-This example uses Conda to install some dependencies that are not available via PyPi.
 
-Create a new conda environment
+# 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
-conda create --name new_env python=3.9 -y
+mamba create --name new_env python=3.9 -y
 ```
 
 Activate the environment
 ```bash
-conda activate new_env
+mamba activate new_env
 ```
 
 Install the dependencies
 ```bash
-conda install -c conda-forge moab multimethod typish ezdxf nptyping nlopt casadi gmsh python-gmsh ocp>=7.7.1 -y
-conda install -c cadquery -c conda-forge cadquery=master --no-deps -y
+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```
@@ -69,30 +76,27 @@ 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*"
+mamba install -c conda-forge -y "openmc=0.13.3=dagmc*nompi*"
 ```
 
 
-# Install using Mamba and pip
+# Install using Conda and pip
 
-This example uses Mamba to install some dependencies that are not available via PyPi.
+This example uses Conda to install some dependencies that are not available via PyPi.
 
-Create a new conda environment, I've chosen Python 3.9 here but new versions are
-also supported.
+Create a new conda environment
 ```bash
 conda create --name new_env python=3.9 -y
 ```
 
 Activate the environment
 ```bash
-mamba activate new_env
+conda activate new_env
 ```
 
 Install the dependencies
 ```bash
-conda install -c conda-forge mamba -y
-mamba install -c conda-forge moab multimethod typish ezdxf nptyping nlopt casadi gmsh python-gmsh ocp>=7.7.1 -y
-mamba install -c cadquery -c conda-forge cadquery=master --no-deps -y
+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```
@@ -102,9 +106,11 @@ 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*"
+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)

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.4.0.dist-info → cad_to_dagmc-0.5.1.dist-info}/WHEEL

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

cad_to_dagmc/brep_part_finder.py

@@ -1,37 +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()):
-        print(id[0])
-        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,118 +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 = 30,
-    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",
-) -> 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
-    nodes_in_each_pg = []
-    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 = []
-        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_all_surfaces += grouped_node_tags
-        nodes_in_each_pg.append(nodes_in_all_surfaces)
-
-    _, all_coords, _ = gmsh.model.mesh.getNodes()
-
-    GroupedCoords = [
-        all_coords[i : i + n].tolist() for i in range(0, len(all_coords), n)
-    ]
-
-    gmsh.finalize()
-
-    # checks and fixes triangle fix_normals within vertices_to_h5m
-    return vertices_to_h5m(
-        vertices=GroupedCoords,
-        triangles=nodes_in_each_pg,
-        material_tags=material_tags,
-        h5m_filename=h5m_filename,
-    )

cad_to_dagmc/vertices_to_h5m.py

@@ -1,211 +0,0 @@
-from typing import Iterable, Tuple, Union
-
-import numpy as np
-import trimesh
-from pymoab import core, types
-
-
-def fix_normals(vertices, triangles_in_each_volume):
-    fixed_triangles = []
-    for triangles in triangles_in_each_volume:
-        fixed_triangles.append(fix_normal(vertices, triangles))
-    return fixed_triangles
-
-
-def fix_normal(vertices, triangles):
-    # for triangles in triangles_in_each_volume:
-    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(
-    moab_core,
-    surface_id,
-    volume_id,
-    tags,
-):
-    surface_set = moab_core.create_meshset()
-    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)
-
-    moab_core.tag_set_data(tags["global_id"], surface_set, surface_id)
-
-    # set geom IDs
-    moab_core.tag_set_data(tags["geom_dimension"], volume_set, 3)
-    moab_core.tag_set_data(tags["geom_dimension"], surface_set, 2)
-
-    # set category tag values
-    moab_core.tag_set_data(tags["category"], volume_set, "Volume")
-    moab_core.tag_set_data(tags["category"], surface_set, "Surface")
-
-    # establish parent-child relationship
-    moab_core.add_parent_child(volume_set, surface_set)
-
-    # set surface sense
-    sense_data = [volume_set, np.uint64(0)]
-    moab_core.tag_set_data(tags["surf_sense"], surface_set, sense_data)
-
-    return moab_core, surface_set, volume_set
-
-
-def add_vertices_to_moab_core(moab_core, vertices, surface_set):
-    moab_verts = moab_core.create_vertices(vertices)
-
-    moab_core.add_entity(surface_set, moab_verts)
-    return moab_core, moab_verts
-
-
-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: 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):
-        msg = f"The number of material_tags provided is {len(material_tags)} and the number of sets of triangles is {len(triangles)}. 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
-
-    triangles = fix_normals(
-        vertices=vertices_floats, triangles_in_each_volume=triangles
-    )
-
-    moab_core, tags = _define_moab_core_and_tags()
-
-    for vol_id, material_tag in enumerate(material_tags, 1):
-        moab_core, surface_set, volume_set = prepare_moab_core(
-            moab_core, surface_id=vol_id, volume_id=vol_id, tags=tags
-        )
-
-        moab_core, moab_verts = add_vertices_to_moab_core(
-            moab_core, vertices_floats, surface_set
-        )
-
-        moab_core = add_triangles_to_moab_core(
-            material_tag,
-            surface_set,
-            moab_core,
-            tags,
-            triangles[vol_id - 1],
-            moab_verts,
-            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.4.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-_version.py,sha256=QiCQVGOicQZY3DBr4tYPU9egzT1VgzOJGfLt9Q26uyU,160
-cad_to_dagmc/__init__.py,sha256=PgkpCP8unzhcoyvw-lKpy5HLy2bnUNmFHS508_bsCCE,593
-cad_to_dagmc/brep_part_finder.py,sha256=by2wnjo_KrTZaihFP5m5Z_sZJSdtEef7GS4nvpwqNrc,1020
-cad_to_dagmc/brep_to_h5m.py,sha256=4w7xaO0uJU5c8PoQFtDoPUyzWart7pdSpynU1Rcv7xY,4107
-cad_to_dagmc/core.py,sha256=XNXmEn06VellMwEqTXiCKRLVPN7NRDG3X0OQZXM2cOE,5594
-cad_to_dagmc/vertices_to_h5m.py,sha256=h7KI2fofhBlyTMRdb0FXUO12SxW9MtnNEgwdCyNCPmk,5997
-cad_to_dagmc-0.4.0.dist-info/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
-cad_to_dagmc-0.4.0.dist-info/METADATA,sha256=9iMhi-El25ZzKZL1sKTQqwDQO5t2zd-8DEA5-acacgA,4545
-cad_to_dagmc-0.4.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-cad_to_dagmc-0.4.0.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
-cad_to_dagmc-0.4.0.dist-info/RECORD,,