cad-to-dagmc 0.3.2__tar.gz → 0.4.0__tar.gz

{cad_to_dagmc-0.3.2 → cad_to_dagmc-0.4.0}/.github/workflows/ci_with_install.yml

@@ -1,6 +1,8 @@
 
 # This CI will launch a Docker image that contains all the dependencies required
 # within that image the pytest test suite is run 
+# container:
+#       image: continuumio/miniconda3:23.3.1-0
 
 name: CI with install
 
@@ -21,41 +23,88 @@ jobs:
   testing:
     runs-on: ubuntu-latest
     container:
-      image: continuumio/miniconda3:4.12.0
+      image: continuumio/miniconda3:23.3.1-0
     steps:
       - name: Checkout repository
         uses: actions/checkout@v3
 
+      # - uses: conda-incubator/setup-miniconda@v2
+
       - name: install non pypi dependencies for cad creation
         run: |
           apt-get --allow-releaseinfo-change update
           apt-get update -y
           apt-get upgrade -y
-          apt-get install -y libgl1-mesa-glx libgl1-mesa-dev libglu1-mesa-dev  freeglut3-dev libosmesa6 libosmesa6-dev  libgles2-mesa-dev
+          apt-get install -y libgl1-mesa-glx libgl1-mesa-dev libglu1-mesa-dev freeglut3-dev libosmesa6 libosmesa6-dev libgles2-mesa-dev libarchive-dev
           apt-get install -y libpangocairo-1.0-0
-          conda install -c conda-forge -y moab
-          conda install -c conda-forge -y gmsh
-          conda install -c conda-forge -y python-gmsh
-          conda install -c conda-forge -y "openmc=0.13.3=dagmc*nompi*"
+          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
 
       - name: install package
         run: |
+          pip install --upgrade pip
           pip install .
           python -c "import cad_to_dagmc"
+          mamba install -c conda-forge openmc -y
 
       - name: run examples
         run: |
           cd examples
           python create_stp_files_for_examples.py
+
+      - name: run examples
+        run: |
+          cd examples
           python cadquery_assembly.py
+
+      - name: run examples
+        run: |
+          cd examples
           python cadquery_compound.py
+
+      - name: run examples
+        run: |
+          cd examples
           python cadquery_object_and_stp_file.py
+
+      - name: run examples
+        run: |
+          cd examples
           python cadquery_text.py
+
+      - name: run examples 1
+        run: |
+          cd examples
           python curved_cadquery_object.py
+
+      - name: run examples 2
+        run: |
+          cd examples
           python multiple_cadquery_objects.py
+
+      - name: run examples 3
+        run: |
+          cd examples
           python multiple_stp_files.py
+
+      - name: run examples 4
+        run: |
+          cd examples
           python single_stp_file_multiple_volumes.py
+
+      - name: run examples 5
+        run: |
+          cd examples
+
+      - name: run examples 6
+        run: |
+          cd examples
           python single_cadquery_object.py
+
+      - name: run examples 7
+        run: |
+          cd examples
           python single_stp_file.py
 
       - name: Run pytest

cad_to_dagmc-0.4.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: cad_to_dagmc
+Version: 0.4.0
+Summary: Converts CAD files to a DAGMC h5m file
+Author-email: Jonathan Shimwell <mail@jshimwell.com>
+Project-URL: Homepage, https://github.com/fusion-energy/cad_to_dagmc
+Project-URL: Bug Tracker, https://github.com/fusion-energy/cad_to_dagmc/issues
+Keywords: dagmc,geometry,plot,slice
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: tests
+License-File: LICENSE
+
+
+[![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)
+
+[![CI with install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml)
+
+[![Upload Python Package](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml)
+
+
+[![PyPI](https://img.shields.io/pypi/v/cad_to_dagmc?color=brightgreen&label=pypi&logo=grebrightgreenen&logoColor=green)](https://pypi.org/project/cad_to_dagmc/)
+
+___
+
+A minimal package that uses CadQuery functionality to convert Cad geometry to [DAGMC](https://github.com/svalinn/DAGMC/) h5m files
+
+This particular method of producing DAGMC compatible h5m files from CAD geometry
+is intended to convert STP files or [CadQuery](https://cadquery.readthedocs.io) objects to h5m file.
+
+One unique feature of this package is the ability to combine STP files with CadQuery objects.
+This allows for the addition of parametric geometry to static geometry.
+
+# Installation
+
+In principle, any Conda distribution will work. 
+
+
+# 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 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
+```
+
+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*"
+```
+
+
+# Install using Mamba and pip
+
+This example uses Mamba 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.
+```bash
+conda create --name new_env python=3.9 -y
+```
+
+Activate the environment
+```bash
+mamba 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
+```
+
+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*"
+```
+
+# 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.4.0/README.md

@@ -0,0 +1,95 @@
+
+[![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)
+
+[![CI with install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_install.yml)
+
+[![Upload Python Package](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml)
+
+
+[![PyPI](https://img.shields.io/pypi/v/cad_to_dagmc?color=brightgreen&label=pypi&logo=grebrightgreenen&logoColor=green)](https://pypi.org/project/cad_to_dagmc/)
+
+___
+
+A minimal package that uses CadQuery functionality to convert Cad geometry to [DAGMC](https://github.com/svalinn/DAGMC/) h5m files
+
+This particular method of producing DAGMC compatible h5m files from CAD geometry
+is intended to convert STP files or [CadQuery](https://cadquery.readthedocs.io) objects to h5m file.
+
+One unique feature of this package is the ability to combine STP files with CadQuery objects.
+This allows for the addition of parametric geometry to static geometry.
+
+# Installation
+
+In principle, any Conda distribution will work. 
+
+
+# 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 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
+```
+
+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*"
+```
+
+
+# Install using Mamba and pip
+
+This example uses Mamba 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.
+```bash
+conda create --name new_env python=3.9 -y
+```
+
+Activate the environment
+```bash
+mamba 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
+```
+
+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*"
+```
+
+# 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.3.2 → cad_to_dagmc-0.4.0}/pyproject.toml

@@ -18,7 +18,6 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "cadquery>=2.2.0",
     "trimesh",
     "networkx",
 ]

{cad_to_dagmc-0.3.2 → cad_to_dagmc-0.4.0}/src/_version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)

cad_to_dagmc-0.4.0/src/cad_to_dagmc/brep_part_finder.py

@@ -0,0 +1,37 @@
+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-0.3.2 → cad_to_dagmc-0.4.0}/src/cad_to_dagmc/brep_to_h5m.py

@@ -4,50 +4,8 @@ from .vertices_to_h5m import vertices_to_h5m
 import typing
 
 
-def brep_to_h5m(
-    brep_filename: str,
-    material_tags: typing.Iterable[str],
-    h5m_filename: str = "dagmc.h5m",
-    min_mesh_size: float = 30,
-    max_mesh_size: float = 10,
-    mesh_algorithm: int = 1,
-) -> str:
-    """Converts a Brep file into a DAGMC h5m file. This makes use of Gmsh and
-    will therefore need to have Gmsh installed to work.
-
-    Args:
-        brep_filename: the filename of the Brep file to convert
-        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
-        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 filename of the h5m file produced
-    """
-
-    gmsh, volumes = mesh_brep(
-        brep_filename=brep_filename,
-        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,
-        h5m_filename=h5m_filename,
-    )
-
-    return h5m_filename
-
-
 def mesh_brep(
-    brep_filename: str,
+    brep_object: str,
     min_mesh_size: float = 30,
     max_mesh_size: float = 10,
     mesh_algorithm: int = 1,
@@ -56,7 +14,7 @@ def mesh_brep(
     Gmsh.
 
     Args:
-        brep_filename: the filename of the Brep file to convert
+        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
@@ -68,14 +26,11 @@ def mesh_brep(
         The gmsh object and volumes in Brep file
     """
 
-    if not Path(brep_filename).is_file():
-        msg = f"The specified brep ({brep_filename}) file was not found"
-        raise FileNotFoundError(msg)
-
     gmsh.initialize()
     gmsh.option.setNumber("General.Terminal", 1)
     gmsh.model.add("made_with_brep_to_h5m_package")
-    volumes = gmsh.model.occ.importShapes(brep_filename)
+    volumes = gmsh.model.occ.importShapesNativePointer(brep_object)
+    # gmsh.model.occ.importShapes(brep_object)
     gmsh.model.occ.synchronize()
 
     gmsh.option.setNumber("Mesh.Algorithm", mesh_algorithm)
@@ -155,11 +110,9 @@ def mesh_to_h5m_in_memory_method(
     gmsh.finalize()
 
     # checks and fixes triangle fix_normals within vertices_to_h5m
-    vertices_to_h5m(
+    return vertices_to_h5m(
         vertices=GroupedCoords,
         triangles=nodes_in_each_pg,
         material_tags=material_tags,
         h5m_filename=h5m_filename,
     )
-
-    return h5m_filename

{cad_to_dagmc-0.3.2 → cad_to_dagmc-0.4.0}/src/cad_to_dagmc/core.py

@@ -1,22 +1,22 @@
-from tempfile import mkstemp
-
 import typing
 from cadquery import importers
-from cadquery import Assembly
-from OCP.GCPnts import GCPnts_QuasiUniformDeflection
+
+# from cadquery import Assembly
+# from OCP.GCPnts import GCPnts_QuasiUniformDeflection
 
 # from cadquery.occ_impl import shapes
 import OCP
 import cadquery as cq
-from OCP.TopLoc import TopLoc_Location
-from OCP.BRep import BRep_Tool
-from OCP.TopAbs import TopAbs_Orientation
 
-from .brep_to_h5m import brep_to_h5m
+# from OCP.TopLoc import TopLoc_Location
+# from OCP.BRep import BRep_Tool
+# from OCP.TopAbs import TopAbs_Orientation
+
+from .brep_to_h5m import mesh_brep, mesh_to_h5m_in_memory_method
 from .brep_part_finder import (
-    get_part_properties_from_shapes,
-    get_part_properties_from_shapes,
-    get_matching_part_ids,
+    get_ids_from_assembly,
+    get_ids_from_imprinted_assembly,
+    order_material_ids_by_brep_order,
 )
 
 
@@ -45,7 +45,7 @@ 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:
@@ -94,71 +94,78 @@ class CadToDagmc:
         filename: str = "dagmc.h5m",
         min_mesh_size: float = 1,
         max_mesh_size: float = 10,
-        verbose: bool = False,
-        volume_atol: float = 0.000001,
-        center_atol: float = 0.000001,
-        bounding_box_atol: float = 0.000001,
+        mesh_algorithm: int = 1,
     ):
-        brep_shape = self._merge_surfaces()
-
-        tmp_brep_filename = mkstemp(suffix=".brep", prefix="paramak_")[1]
-        brep_shape.exportBrep(tmp_brep_filename)
-
-        if verbose:
-            print(f"Brep file saved to {tmp_brep_filename}")
-
-        brep_file_part_properties = get_part_properties_from_shapes(brep_shape)
+        assembly = cq.Assembly()
+        for part in self.parts:
+            assembly.add(part)
+
+        (
+            imprinted_assembly,
+            imprinted_solids_with_original_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
+        )
 
-        shape_properties = get_part_properties_from_shapes(self.parts)
+        # both id lists should be the same length as each other and the same
+        # length as the self.material_tags
 
-        brep_and_shape_part_ids = get_matching_part_ids(
-            brep_part_properties=brep_file_part_properties,
-            shape_properties=shape_properties,
-            volume_atol=volume_atol,
-            center_atol=center_atol,
-            bounding_box_atol=bounding_box_atol,
+        material_tags_in_brep_order = order_material_ids_by_brep_order(
+            original_ids, scrambled_ids, self.material_tags
         )
 
-        material_tags_in_brep_order = []
-        for brep_id, shape_id in brep_and_shape_part_ids:
-            material_tags_in_brep_order.append(self.material_tags[shape_id - 1])
+        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,
+        )
 
-        brep_to_h5m(
-            brep_filename=tmp_brep_filename,
+        h5m_filename = mesh_to_h5m_in_memory_method(
+            volumes=volumes,
             material_tags=material_tags_in_brep_order,
             h5m_filename=filename,
-            min_mesh_size=min_mesh_size,
-            max_mesh_size=max_mesh_size,
         )
+        return h5m_filename
 
-    def _merge_surfaces(self):
-        """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()
+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"""
 
-        bldr = OCP.BOPAlgo.BOPAlgo_Splitter()
+    # solids = geometry.Solids()
 
-        if len(self.parts) == 1:
-            # merged_solid = cq.Compound(solids)
-            return self.parts[0]
+    bldr = OCP.BOPAlgo.BOPAlgo_Splitter()
 
-        for solid in self.parts:
-            # checks if solid is a compound as .val() is not needed for compounds
-            if isinstance(
-                solid, (cq.occ_impl.shapes.Compound, cq.occ_impl.shapes.Solid)
-            ):
-                bldr.AddArgument(solid.wrapped)
-            else:
-                bldr.AddArgument(solid.val().wrapped)
+    if len(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.SetNonDestructive(True)
 
-        bldr.Perform()
+    bldr.Perform()
 
-        bldr.Images()
+    bldr.Images()
 
-        merged_solid = cq.Compound(bldr.Shape())
+    merged_solid = cq.Compound(bldr.Shape())
 
-        return merged_solid
+    return merged_solid, merged_solid.wrapped

{cad_to_dagmc-0.3.2 → cad_to_dagmc-0.4.0}/src/cad_to_dagmc/vertices_to_h5m.py

@@ -207,3 +207,5 @@ def vertices_to_h5m(
     moab_core.add_entities(file_set, all_sets)
 
     moab_core.write_file(h5m_filename)
+
+    return h5m_filename