cad-to-dagmc 0.6.2__py3-none-any.whl → 0.7.1__py3-none-any.whl

_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.6.2'
-__version_tuple__ = version_tuple = (0, 6, 2)
+__version__ = version = '0.7.1'
+__version_tuple__ = version_tuple = (0, 7, 1)

cad_to_dagmc/core.py

@@ -1,13 +1,12 @@
-import typing
-
 import cadquery as cq
 import gmsh
 import numpy as np
-from cadquery import importers
+from cadquery import importers, exporters
 from pymoab import core, types
+import tempfile
 
 
-def _define_moab_core_and_tags() -> typing.Tuple[core.Core, dict]:
+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
 
@@ -62,14 +61,11 @@ def _define_moab_core_and_tags() -> typing.Tuple[core.Core, dict]:
 
 
 def _vertices_to_h5m(
-    vertices: typing.Union[
-        typing.Iterable[typing.Tuple[float, float, float]],
-        typing.Iterable["cadquery.occ_impl.geom.Vector"],
-    ],
-    triangles_by_solid_by_face: typing.Iterable[typing.Iterable[typing.Tuple[int, int, int]]],
-    material_tags: typing.Iterable[str],
-    h5m_filename="dagmc.h5m",
-    implicit_complement_material_tag=None,
+    vertices: list[tuple[float, float, float]] | list["cadquery.occ_impl.geom.Vector"],
+    triangles_by_solid_by_face: list[list[tuple[int, int, int]]],
+    material_tags: list[str],
+    h5m_filename: str = "dagmc.h5m",
+    implicit_complement_material_tag: str | None = None,
 ):
     """Converts vertices and triangle sets into a tagged h5m file compatible
     with DAGMC enabled neutronics simulations
@@ -189,11 +185,34 @@ def _vertices_to_h5m(
 
     moab_core.write_file(h5m_filename)
 
+    print(f"written DAGMC file {h5m_filename}")
+
     return h5m_filename
 
 
+def get_volumes(gmsh, assembly, method="file"):
+
+    if method == "in memory":
+        volumes = gmsh.model.occ.importShapesNativePointer(assembly.wrapped._address())
+        gmsh.model.occ.synchronize()
+    elif method == "file":
+        with tempfile.NamedTemporaryFile(suffix=".step") as temp_file:
+            exporters.export(assembly, temp_file.name)
+            volumes = gmsh.model.occ.importShapes(temp_file.name)
+            gmsh.model.occ.synchronize()
+
+    return gmsh, volumes
+
+
+def init_gmsh():
+    gmsh.initialize()
+    gmsh.option.setNumber("General.Terminal", 1)
+    gmsh.model.add("made_with_cad_to_dagmc_package")
+    return gmsh
+
+
 def _mesh_brep(
-    brep_object: str,
+    gmsh,
     min_mesh_size: float = 1,
     max_mesh_size: float = 10,
     mesh_algorithm: int = 1,
@@ -203,7 +222,7 @@ def _mesh_brep(
     Gmsh.
 
     Args:
-        brep_object: the filename of the Brep file to convert
+        occ_shape: the occ_shape 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
@@ -217,30 +236,21 @@ def _mesh_brep(
         The resulting gmsh object and volumes
     """
 
-    gmsh.initialize()
-    gmsh.option.setNumber("General.Terminal", 1)
-    gmsh.model.add("made_with_cad_to_dagmc_package")
-    volumes = gmsh.model.occ.importShapesNativePointer(brep_object)
-    gmsh.model.occ.synchronize()
-
     gmsh.option.setNumber("Mesh.Algorithm", mesh_algorithm)
     gmsh.option.setNumber("Mesh.MeshSizeMin", min_mesh_size)
     gmsh.option.setNumber("Mesh.MeshSizeMax", max_mesh_size)
     gmsh.model.mesh.generate(dimensions)
 
-    return gmsh, volumes
+    return gmsh
 
 
-def _mesh_to_h5m_in_memory_method(
-    volumes,
-) -> str:
-    """Converts gmsh volumes into a DAGMC h5m file.
+def mesh_to_vertices_and_triangles(
+    dims_and_vol_ids,
+):
+    """Converts gmsh volumes into vertices and triangles for each face.
 
     Args:
         volumes: the volumes in the gmsh file, found with gmsh.model.occ.importShapes
-        material_tags: A list of material tags to tag the DAGMC volumes with.
-            Should be in the same order as the volumes
-        h5m_filename: the filename of the DAGMC h5m file to write
 
     Returns:
         vertices and triangles (grouped by solid then by face)
@@ -248,7 +258,7 @@ def _mesh_to_h5m_in_memory_method(
 
     n = 3  # number of verts in a triangles
     triangles_by_solid_by_face = {}
-    for dim_and_vol in volumes:
+    for dim_and_vol in dims_and_vol_ids:
         # removes all groups so that the following getEntitiesForPhysicalGroup
         # command only finds surfaces for the volume
         gmsh.model.removePhysicalGroups()
@@ -302,6 +312,22 @@ def _get_ids_from_imprinted_assembly(solid_id_dict):
     return ids
 
 
+def _check_material_tags(material_tags, iterable_solids):
+    if material_tags:
+        if len(material_tags) != len(iterable_solids):
+            msg = (
+                "When setting material_tags the number of material_tags \n"
+                "should be equal to the number of volumes in the CAD \n"
+                f"geometry {len(iterable_solids)} volumes found in model \n"
+                f"and {len(material_tags)} material_tags found"
+            )
+            raise ValueError(msg)
+        for material_tag in material_tags:
+            if not isinstance(material_tag, str):
+                msg = f"material_tags should be an iterable of strings."
+                raise ValueError(msg)
+
+
 def order_material_ids_by_brep_order(original_ids, scrambled_id, material_tags):
     material_tags_in_brep_order = []
     for brep_id in scrambled_id:
@@ -310,27 +336,94 @@ def order_material_ids_by_brep_order(original_ids, scrambled_id, material_tags):
     return material_tags_in_brep_order
 
 
+class MeshToDagmc:
+    """Convert a GMSH mesh file to a DAGMC h5m file"""
+
+    def __init__(self, filename: str):
+        self.filename = filename
+
+    # TODO add export_unstructured_mesh_file
+    # TODO add add_gmsh_msh_file
+
+    def export_dagmc_h5m_file(
+        self,
+        material_tags: list[str],
+        implicit_complement_material_tag: str | None = None,
+        filename: str = "dagmc.h5m",
+    ):
+        """Saves a DAGMC h5m file of the geometry
+
+        Args:
+            material_tags (list[str]): the names of the DAGMC
+                material tags to assign. These will need to be in the same
+                order as the volumes in the GMESH mesh and match the
+                material tags used in the neutronics code (e.g. OpenMC).
+            implicit_complement_material_tag (str | None, optional):
+                the name of the material tag to use for the implicit
+                complement (void space). Defaults to None which is a vacuum.
+            filename (str, optional): _description_. Defaults to "dagmc.h5m".
+
+        Raises:
+            ValueError: _description_
+
+        Returns:
+            _type_: _description_
+        """
+
+        gmsh.initialize()
+        self.mesh_file = gmsh.open(self.filename)
+        dims_and_vol_ids = gmsh.model.getEntities(3)
+
+        if len(dims_and_vol_ids) != len(material_tags):
+            msg = f"Number of volumes {len(dims_and_vol_ids)} is not equal to number of material tags {len(material_tags)}"
+            raise ValueError(msg)
+
+        vertices, triangles_by_solid_by_face = mesh_to_vertices_and_triangles(
+            dims_and_vol_ids=dims_and_vol_ids
+        )
+
+        gmsh.finalize()
+
+        h5m_filename = _vertices_to_h5m(
+            vertices=vertices,
+            triangles_by_solid_by_face=triangles_by_solid_by_face,
+            material_tags=material_tags,
+            h5m_filename=filename,
+            implicit_complement_material_tag=implicit_complement_material_tag,
+        )
+
+        return h5m_filename
+
+
 class CadToDagmc:
+    """Converts Step files and CadQuery parts to a DAGMC h5m file"""
+
     def __init__(self):
         self.parts = []
+        self.material_tags = []
 
     def add_stp_file(
         self,
         filename: str,
         scale_factor: float = 1.0,
-    ):
+        material_tags: list[str] | None = None,
+    ) -> int:
         """Loads the parts from stp file into the model.
 
         Args:
             filename: the filename used to save the html graph.
-            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).
+            material_tags (list[str]): the names of the DAGMC
+                material tags to assign. These will need to be in the
+                same order as the volumes in the geometry added (STP
+                file and CadQuery objects) and match the material tags
+                used in the neutronics code (e.g. OpenMC).
             scale_factor: a scaling factor to apply to the geometry that can be
                 used to increase the size or decrease the size of the geometry.
                 Useful when converting the geometry to cm for use in neutronics
                 simulations.
+
+        Returns:
+            int: number of volumes in the stp file.
         """
         part = importers.importStep(str(filename)).val()
 
@@ -338,35 +431,52 @@ class CadToDagmc:
             scaled_part = part
         else:
             scaled_part = part.scale(scale_factor)
-        self.add_cadquery_object(object=scaled_part)
+        return self.add_cadquery_object(cadquery_object=scaled_part, material_tags=material_tags)
 
     def add_cadquery_object(
         self,
-        object: typing.Union[
-            cq.assembly.Assembly, cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid
-        ],
-    ):
+        cadquery_object: (
+            cq.assembly.Assembly | cq.occ_impl.shapes.Compound | cq.occ_impl.shapes.Solid
+        ),
+        material_tags: list[str] | None,
+    ) -> int:
         """Loads the parts from CadQuery object into the model.
 
         Args:
-            object: the cadquery object to convert
+            cadquery_object: the cadquery object to convert, can be a CadQuery assembly
+                cadquery workplane or a cadquery solid
+            material_tags (Optional list[str]): the names of the
+                DAGMC material tags to assign. These will need to be in the
+                same order as the volumes in the geometry added (STP file and
+                CadQuery objects) and match the material tags used in the
+                neutronics code (e.g. OpenMC).
+
+        Returns:
+            int: number of volumes in the stp file.
         """
 
-        if isinstance(object, cq.assembly.Assembly):
-            object = object.toCompound()
+        if isinstance(cadquery_object, cq.assembly.Assembly):
+            cadquery_object = cadquery_object.toCompound()
 
-        if isinstance(object, (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)):
-            iterable_solids = object.Solids()
+        if isinstance(cadquery_object, (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)):
+            iterable_solids = cadquery_object.Solids()
         else:
-            iterable_solids = object.val().Solids()
+            iterable_solids = cadquery_object.val().Solids()
+
+        _check_material_tags(material_tags, iterable_solids)
+        if material_tags:
+            self.material_tags = self.material_tags + material_tags
         self.parts = self.parts + iterable_solids
 
+        return len(iterable_solids)
+
     def export_unstructured_mesh_file(
         self,
         filename: str = "umesh.h5m",
         min_mesh_size: float = 1,
         max_mesh_size: float = 5,
         mesh_algorithm: int = 1,
+        method: str = "file",
     ):
 
         assembly = cq.Assembly()
@@ -375,8 +485,12 @@ class CadToDagmc:
 
         imprinted_assembly, _ = cq.occ_impl.assembly.imprint(assembly)
 
-        gmsh, volumes = _mesh_brep(
-            brep_object=imprinted_assembly.wrapped._address(),
+        gmsh = init_gmsh()
+
+        gmsh, _ = get_volumes(gmsh, imprinted_assembly, method=method)
+
+        gmsh = _mesh_brep(
+            gmsh=gmsh,
             min_mesh_size=min_mesh_size,
             max_mesh_size=max_mesh_size,
             mesh_algorithm=mesh_algorithm,
@@ -392,6 +506,8 @@ class CadToDagmc:
 
         gmsh.finalize()
 
+        return gmsh
+
     def export_gmsh_mesh_file(
         self,
         filename: str = "mesh.msh",
@@ -399,6 +515,7 @@ class CadToDagmc:
         max_mesh_size: float = 5,
         mesh_algorithm: int = 1,
         dimensions: int = 2,
+        method: str = "file",
     ):
         """Saves a GMesh msh file of the geometry in either 2D surface mesh or
         3D volume mesh.
@@ -410,6 +527,14 @@ class CadToDagmc:
             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()
+            method: the method to use to import the geometry into gmsh. Options
+                are 'file' or 'in memory'. 'file' is the default and will write
+                the geometry to a temporary file before importing it into gmsh.
+                'in memory' will import the geometry directly into gmsh but
+                requires the version of OpenCASCADE used to build gmsh to be
+                the same as the version used by CadQuery. This is possible to
+                ensure when installing the package with Conda but harder when
+                installing from PyPI.
         """
 
         assembly = cq.Assembly()
@@ -418,8 +543,12 @@ class CadToDagmc:
 
         imprinted_assembly, _ = cq.occ_impl.assembly.imprint(assembly)
 
-        gmsh, volumes = _mesh_brep(
-            brep_object=imprinted_assembly.wrapped._address(),
+        gmsh = init_gmsh()
+
+        gmsh, _ = get_volumes(gmsh, imprinted_assembly, method=method)
+
+        gmsh = _mesh_brep(
+            gmsh=gmsh,
             min_mesh_size=min_mesh_size,
             max_mesh_size=max_mesh_size,
             mesh_algorithm=mesh_algorithm,
@@ -428,32 +557,42 @@ class CadToDagmc:
 
         gmsh.write(filename)
 
+        print(f"written GMSH mesh file {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,
-    ):
+        implicit_complement_material_tag: str | None = None,
+        method: str = "file",
+    ) -> str:
         """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.
+
+            filename (str, optional): the filename to use for the saved DAGMC file. Defaults to "dagmc.h5m".
+            min_mesh_size (float, optional): the minimum size of mesh elements to use. Defaults to 1.
+            max_mesh_size (float, optional): the maximum size of mesh elements to use. Defaults to 5.
+            mesh_algorithm (int, optional): the GMSH mesh algorithm to use.. Defaults to 1.
+            implicit_complement_material_tag (str | None, optional):
+                the name of the material tag to use for the implicit complement
+                (void space). Defaults to None which is a vacuum. Defaults to None.
+           method: the method to use to import the geometry into gmsh. Options
+                are 'file' or 'in memory'. 'file' is the default and will write
+                the geometry to a temporary file before importing it into gmsh.
+                'in memory' will import the geometry directly into gmsh but
+                requires the version of OpenCASCADE used to build gmsh to be
+                the same as the version used by CadQuery. This is possible to
+                ensure when installing the package with Conda but harder when
+                installing from PyPI.
+        Returns:
+            str: the DAGMC filename saved
         """
+
         assembly = cq.Assembly()
         for part in self.parts:
             assembly.add(part)
@@ -466,30 +605,32 @@ class CadToDagmc:
         # 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)}"
+        if len(original_ids) != len(self.material_tags):
+            msg = f"Number of volumes {len(original_ids)} is not equal to number of material tags {len(self.material_tags)}"
             raise ValueError(msg)
 
         material_tags_in_brep_order = order_material_ids_by_brep_order(
-            original_ids, scrambled_ids, material_tags
+            original_ids, scrambled_ids, self.material_tags
         )
 
-        gmsh, volumes = _mesh_brep(
-            brep_object=imprinted_assembly.wrapped._address(),  # in memory address
+        _check_material_tags(material_tags_in_brep_order, self.parts)
+
+        gmsh = init_gmsh()
+
+        gmsh, volumes = get_volumes(gmsh, imprinted_assembly, method=method)
+
+        gmsh = _mesh_brep(
+            gmsh=gmsh,
             min_mesh_size=min_mesh_size,
             max_mesh_size=max_mesh_size,
             mesh_algorithm=mesh_algorithm,
         )
 
-        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)
+        dims_and_vol_ids = volumes
 
-        vertices, triangles_by_solid_by_face = _mesh_to_h5m_in_memory_method(volumes=volumes)
+        vertices, triangles_by_solid_by_face = mesh_to_vertices_and_triangles(
+            dims_and_vol_ids=dims_and_vol_ids
+        )
 
         gmsh.finalize()
 

{cad_to_dagmc-0.6.2.dist-info → cad_to_dagmc-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cad_to_dagmc
-Version: 0.6.2
+Version: 0.7.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
@@ -15,6 +15,8 @@ License-File: LICENSE
 Requires-Dist: trimesh
 Requires-Dist: networkx
 Requires-Dist: cadquery >=2.4.0
+Requires-Dist: numpy <=1.23.5
+Requires-Dist: gmsh
 Provides-Extra: tests
 Requires-Dist: pytest ; extra == 'tests'
 Requires-Dist: vtk ; extra == 'tests'
@@ -51,12 +53,11 @@ Also checkout these other software projects that also create DAGMC geometry [CAD
 
 # Installation options
 
-- Install using Mamba and pip
-- Install using Conda and pip
+- Install using Mamba
+- Install using Conda
 - Install using pip and source compilations
 
-
-## Install using Mamba and pip
+## Install using Mamba
 
 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)
@@ -65,7 +66,7 @@ In principle, installing any Conda/Mamba distribution will work. A few Conda/Mam
 
 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
+Create a new environment, I've chosen Python 3.10 here but newer versions are
 also supported.
 ```bash
 mamba create --name new_env python=3.10 -y
@@ -76,27 +77,20 @@ Activate the environment
 mamba activate new_env
 ```
 
-Install the dependencies
+Then you can install the cad_to_dagmc package
 ```bash
-mamba install -y -c conda-forge "moab>=5.3.0" gmsh python-gmsh
+mamba install -y -c conda-forge cad_to_dagmc
 ```
 
-Then you can install the cad_to_dagmc package with ```pip```
-```bash
-pip install cad_to_dagmc
-```
-
-
-## Install using Conda and pip
+## Install using Conda
 
 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
+Create a new environment, I've chosen Python 3.10 here but newer versions are
+also supported.
 ```bash
 conda create --name new_env python=3.10 -y
 ```
@@ -106,23 +100,37 @@ Activate the environment
 conda activate new_env
 ```
 
-Install the dependencies
+Then you can install the cad_to_dagmc package
 ```bash
-conda install -y -c conda-forge "moab>=5.3.0" gmsh python-gmsh
+conda install -y -c conda-forge cad_to_dagmc
 ```
 
-Then you can install the cad_to_dagmc package with ```pip```
-```bash
-pip install cad_to_dagmc
+## Install using pip and source compilations
+
+It is also possible to avoid the use of conda/mamba and installing using pip.
+
+First ensure hdf5 is installed as this is needed by MOAB pip install command
+
+```
+sudo apt-get install libhdf5-dev
 ```
 
-## Install using pip and source compilations
+Then clone the latest version of MOAB and cd into the moab directory.
 
-It should possible to avoid the use of conda and installing using pip and compiling from source.
+```
+git clone  master https://bitbucket.org/fathomteam/moab/
+cd moab
+```
 
-First compile MOAB (and install Pymoab) from source
+Ensure pip is up to date as a new version is needed
+```
+python -m pip install --upgrade pip
+```
 
-Then install gmsh from source (installing from pip appears to cause conflicts with the open cascade used in ocp and cadquery)
+Run the pip install command with cmake arguments.
+```
+pip install . --config-settings=cmake.args=-DENABLE_HDF5=ON
+```
 
 Then you can install the cad_to_dagmc package with ```pip```
 
@@ -130,7 +138,7 @@ Then you can install the cad_to_dagmc package with ```pip```
 pip install cad_to_dagmc
 ```
 
-## Install with transport code (e.g OpenMC)
+## Install with OpenMC or other particle transport codes
 
 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/).
 
@@ -144,28 +152,13 @@ It might not be possible to install OpenMC and cad-to-dagmc in the same conda/ma
 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.
-
+Installing one of the package dependancies (gmsh) with pip appears to result in errors when passing cad objects in memory between cadquery / ocp and gmsh. The default method of passing cad objects is via file so this should not impact most users. The conda install gmsh appears to work fine with in memory passing of cad objects as the version of OCP matches between Gmsh and CadQuery.
 
 
 # Usage - creation of DAGMC h5m files

cad_to_dagmc-0.7.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+_version.py,sha256=5-skCoU2Vu44uYeNEApDjjGE2Q26ndIh5lKJuVOeL88,411
+cad_to_dagmc/__init__.py,sha256=fskHUTyCunSpnpJUvBfAYjx4uwDKXHTTiMP6GqnFRf0,494
+cad_to_dagmc/core.py,sha256=aGBPoxZMWmoo-qf28AFkoSsdO59EtLtRJ_87QKUaFgU,23297
+cad_to_dagmc-0.7.1.dist-info/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
+cad_to_dagmc-0.7.1.dist-info/METADATA,sha256=9gUrCwcSrUx0wHrYoug9f9PJiiiCEwnH4BU-_-pyJ-s,7610
+cad_to_dagmc-0.7.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+cad_to_dagmc-0.7.1.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
+cad_to_dagmc-0.7.1.dist-info/RECORD,,

{cad_to_dagmc-0.6.2.dist-info → cad_to_dagmc-0.7.1.dist-info}/WHEEL

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

cad_to_dagmc-0.6.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-_version.py,sha256=PMhMumGW6FY6KtkQm1bSNdEAeyrHlBqpSQ7WpjsTyws,411
-cad_to_dagmc/__init__.py,sha256=fskHUTyCunSpnpJUvBfAYjx4uwDKXHTTiMP6GqnFRf0,494
-cad_to_dagmc/core.py,sha256=eMwKgKOjje3gBZEqjNzy9O6NF8a02WxD-VhXB5AJg58,18108
-cad_to_dagmc-0.6.2.dist-info/LICENSE,sha256=B8kznH_777JVNZ3HOKDc4Tj24F7wJ68ledaNYeL9sCw,1070
-cad_to_dagmc-0.6.2.dist-info/METADATA,sha256=vt8mq3_FjyTBzNfGDDpH5Kd8PVyqICf1AQUphB-qAic,8147
-cad_to_dagmc-0.6.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cad_to_dagmc-0.6.2.dist-info/top_level.txt,sha256=zTi8C64SEBsE5WOtPovnxhOzt-E6Oc5nC3RW6M_5aEA,22
-cad_to_dagmc-0.6.2.dist-info/RECORD,,