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

_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.1'
-__version_tuple__ = version_tuple = (0, 5, 1)
+__version__ = version = '0.6.1'
+__version_tuple__ = version_tuple = (0, 6, 1)

cad_to_dagmc/core.py

@@ -1,31 +1,13 @@
 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]:
+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
 
@@ -79,7 +61,7 @@ def define_moab_core_and_tags() -> typing.Tuple[core.Core, dict]:
     return moab_core, tags
 
 
-def vertices_to_h5m(
+def _vertices_to_h5m(
     vertices: typing.Union[
         typing.Iterable[typing.Tuple[float, float, float]],
         typing.Iterable["cadquery.occ_impl.geom.Vector"],
@@ -87,6 +69,7 @@ def vertices_to_h5m(
     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
@@ -118,7 +101,7 @@ def vertices_to_h5m(
             else:
                 face_ids_with_solid_ids[face_id] = [solid_id]
 
-    moab_core, tags = define_moab_core_and_tags()
+    moab_core, tags = _define_moab_core_and_tags()
 
     volume_sets_by_solid_id = {}
     for material_tag, (solid_id, triangles_on_each_face) in zip(
@@ -187,6 +170,17 @@ def vertices_to_h5m(
 
         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()
@@ -198,11 +192,12 @@ def vertices_to_h5m(
     return h5m_filename
 
 
-def mesh_brep(
+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.
@@ -215,6 +210,8 @@ def mesh_brep(
             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
@@ -222,23 +219,20 @@ def mesh_brep(
 
     gmsh.initialize()
     gmsh.option.setNumber("General.Terminal", 1)
-    gmsh.model.add("made_with_brep_to_h5m_package")
+    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(2)
+    gmsh.model.mesh.generate(dimensions)
 
     return gmsh, volumes
 
 
-def mesh_to_h5m_in_memory_method(
+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.
 
@@ -249,17 +243,9 @@ def mesh_to_h5m_in_memory_method(
         h5m_filename: the filename of the DAGMC h5m file to write
 
     Returns:
-        The filename of the h5m file produced
+        vertices and triangles (grouped by solid then by face)
     """
 
-    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:
@@ -299,28 +285,17 @@ def mesh_to_h5m_in_memory_method(
 
     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,
-    )
+    return vertices, triangles_by_solid_by_face
 
 
-def get_ids_from_assembly(assembly):
+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):
+def _get_ids_from_imprinted_assembly(solid_id_dict):
     ids = []
     for id in list(solid_id_dict.values()):
         ids.append(id[0])
@@ -335,56 +310,16 @@ def order_material_ids_by_brep_order(original_ids, scrambled_id, material_tags):
     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()
-
-    merged_solid = cq.Compound(bldr.Shape())
-
-    return merged_solid, merged_solid.wrapped
-
-
 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.
@@ -399,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):
@@ -432,48 +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)
+    def export_unstructured_mesh_file(
+        self,
+        filename: str = "umesh.h5m",
+        min_mesh_size: float = 1,
+        max_mesh_size: float = 5,
+        mesh_algorithm: int = 1,
+    ):
+
+        assembly = cq.Assembly()
+        for part in self.parts:
+            assembly.add(part)
 
-        for material_tag in material_tags:
-            self.material_tags.append(material_tag)
+        imprinted_assembly, _ = cq.occ_impl.assembly.imprint(assembly)
 
-    def export_dagmc_h5m_file(
+        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,
+        )
+
+        # gmesh writes out a vtk file that is converted by pymoab into a h5 file
+        gmsh.write(filename + ".vtk")
+
+        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 = "dagmc.h5m",
+        filename: str = "mesh.msh",
         min_mesh_size: float = 1,
         max_mesh_size: float = 5,
         mesh_algorithm: int = 1,
-        msh_filename: str = None,
+        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, imprinted_solids_with_org_id = cq.occ_impl.assembly.imprint(assembly)
+        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,
         )
 
-        original_ids = get_ids_from_assembly(assembly)
-        scrambled_ids = get_ids_from_imprinted_assembly(imprinted_solids_with_org_id)
+        gmsh.write(filename)
+
+        gmsh.finalize()
+
+    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
+
+        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)
+
+        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_org_id)
 
         # both id lists should be the same length as each other and the same
         # length as the self.material_tags
 
+        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, self.material_tags
+            original_ids, scrambled_ids, material_tags
+        )
+
+        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,
         )
 
-        h5m_filename = mesh_to_h5m_in_memory_method(
-            volumes=volumes,
+        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)
+
+        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)
+
+        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_in_brep_order,
             h5m_filename=filename,
-            msh_filename=msh_filename,
+            implicit_complement_material_tag=implicit_complement_material_tag,
         )
-        return h5m_filename

cad_to_dagmc-0.6.1.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.1
+Name: cad_to_dagmc
+Version: 0.6.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
+Project-URL: Bug Tracker, https://github.com/fusion-energy/cad_to_dagmc/issues
+Keywords: dagmc,geometry,plot,slice
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: trimesh
+Requires-Dist: networkx
+Requires-Dist: cadquery-ocp >=7.7.2
+Requires-Dist: cadquery >=2.4.0
+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)
+
+cad-to-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 options
+
+- Install using Mamba and pip
+- Install using Conda and pip
+- Install using pip and source compilations
+
+
+## Install using Mamba and pip
+
+In principle, installing any Conda/Mamba distribution will work. A few Conda/Mamba options are:
+- [Miniforge](https://github.com/conda-forge/miniforge) (recommended as it includes mamba)
+- [Anaconda](https://www.anaconda.com/download)
+- [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
+
+This example assumes you have installed the Miniforge option or separately have installed Mamba with ```conda install -c conda-forge mamba -y```
+
+Create a new 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 "moab>=5.3.0" gmsh python-gmsh
+```
+
+Then you can install the cad_to_dagmc package with ```pip```
+```bash
+pip install cad_to_dagmc
+```
+
+
+## Install using Conda and pip
+
+In principle, installing any Conda/Mamba distribution will work. A few Conda/Mamba options are:
+- [Miniforge](https://github.com/conda-forge/miniforge) (recommended as it includes mamba)
+- [Anaconda](https://www.anaconda.com/download)
+- [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
+
+This example 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 "moab>=5.3.0" gmsh python-gmsh
+```
+
+Then you can install the cad_to_dagmc package with ```pip```
+```bash
+pip install cad_to_dagmc
+```
+
+## Install using pip and source compilations
+
+It should possible to avoid the use of conda and installing using pip and compiling from source.
+
+First compile MOAB (and install Pymoab) from source
+
+Then install gmsh from source (installing from pip appears to cause conflicts with the open cascade used in ocp and cadquery)
+
+Then you can install the cad_to_dagmc package with ```pip```
+
+```bash
+pip install cad_to_dagmc
+```
+
+## Install with transport code (e.g 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 [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.
+
+
+
+# Known incompatibilities
+
+The package requires newer versions of Linux. For example the package does not work on Ubuntu 18.04 or older.
+
+The package requires newer versions of pip. It is recommended to ensure that your version of pip is up to date. This can be done with ```python -m pip install --upgrade pip```
+
+Installing one of the package dependancies (gmsh) with pip appears to result in occational errors when passing cad objects between cadquery / ocp and gmsh. The conda install gmsh appears to work fine.
+
+# 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.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+_version.py,sha256=lgiCYGSijhLK71WmuudWf_AyhNAutwQWx2V8bV6a5VQ,411
+cad_to_dagmc/__init__.py,sha256=fskHUTyCunSpnpJUvBfAYjx4uwDKXHTTiMP6GqnFRf0,494
+cad_to_dagmc/core.py,sha256=eMwKgKOjje3gBZEqjNzy9O6NF8a02WxD-VhXB5AJg58,18108
+cad_to_dagmc-0.6.1.dist-info/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
+cad_to_dagmc-0.6.1.dist-info/METADATA,sha256=Fw_uOmqvNJCm1-XPMr1vy4fWgxWW4ZPmqSgCJouGmr4,8183
+cad_to_dagmc-0.6.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cad_to_dagmc-0.6.1.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
+cad_to_dagmc-0.6.1.dist-info/RECORD,,

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

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

cad_to_dagmc-0.5.1.dist-info/METADATA

@@ -1,120 +0,0 @@
-Metadata-Version: 2.1
-Name: cad-to-dagmc
-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
-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 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 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:
-- [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.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-_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,,