cad-to-dagmc 0.9.4__tar.gz → 0.9.7__tar.gz

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/.github/workflows/ci_with_pip_install.yml

@@ -21,22 +21,25 @@ on:
 jobs:
   testing:
     runs-on: ubuntu-latest
-    container:
-      image: openmc/openmc:develop-dagmc
+    strategy:
+      matrix:
+        python-version: [3.12]
     steps:
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
       - name: Checkout repository
         uses: actions/checkout@v4
 
       - name: install non pypi dependencies
         shell: bash
         run: |
-          apt-get --allow-releaseinfo-change update
-          apt-get update -y
-          apt-get upgrade -y
-          apt-get install -y libblas-dev liblapack-dev libgl1 libglx-mesa0 libgl1-mesa-dev libglu1-mesa-dev freeglut3-dev libosmesa6 libosmesa6-dev libgles2-mesa-dev libarchive-dev libpangocairo-1.0-0 libxcursor-dev libxft2 libxinerama-dev make cmake libeigen3-dev
-          apt install python3
-          apt install python3-pip
-          python -m pip install --extra-index-url https://shimwell.github.io/wheels moab
+          sudo apt-get update -y
+          sudo apt-get upgrade -y
+          sudo apt-get install -y libblas-dev liblapack-dev libgl1 libglx-mesa0 libgl1-mesa-dev libglu1-mesa-dev freeglut3-dev libosmesa6 libosmesa6-dev libgles2-mesa-dev libarchive-dev libpangocairo-1.0-0 libxcursor-dev libxft2 libxinerama-dev make cmake libeigen3-dev
+          # Python3 and pip are pre-installed on GitHub Actions runners
+          python -m pip install --extra-index-url https://shimwell.github.io/wheels moab openmc
           python -c "import pymoab"
           python -m pip install .[tests]
           python -m pip install git+https://github.com/svalinn/pydagmc

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cad_to_dagmc
-Version: 0.9.4
+Version: 0.9.7
 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
@@ -50,7 +50,7 @@ cad-to-dagmc can convert the following in to DAGMC compatible meshes:
 
 Cad-to-dagmc offers a wide range of features including.
 - Geometry scaling with ```scale_factor``` argument
-- Ddirect surface meshing of CadQuery geometry with ```tolerance``` and ```angular_tolerance``` arguments (avoids using Gmsh)
+- Direct surface meshing of CadQuery geometry with ```tolerance``` and ```angular_tolerance``` arguments (avoids using Gmsh)
 - Model wide mesh Gmsh size parameters with ```min_mesh_size``` and ```max_mesh_size``` arguments
 - Volume specific mesh sizing parameters with the ```set_size``` argument
 - Unstructured mesh that share the same coordinates as the surface mesh.
@@ -73,7 +73,7 @@ Cad-to-dagmc offers a wide range of features including.
 
 - Install using Mamba
 - Install using Conda
-- Install using pip and source compilations
+- Install using pip
 
 ## Install using Mamba
 
@@ -151,10 +151,10 @@ You may also want to install OpenMC with DAGMC to make use of the h5m geometry f
 
 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.15.0=dagmc*nompi*"
+mamba install -c conda-forge -y "openmc=0.15.2=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.
+You could also install using this [wheel repo](https://github.com/shimwell/wheels)
 
 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.
 

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/README.md

@@ -25,7 +25,7 @@ cad-to-dagmc can convert the following in to DAGMC compatible meshes:
 
 Cad-to-dagmc offers a wide range of features including.
 - Geometry scaling with ```scale_factor``` argument
-- Ddirect surface meshing of CadQuery geometry with ```tolerance``` and ```angular_tolerance``` arguments (avoids using Gmsh)
+- Direct surface meshing of CadQuery geometry with ```tolerance``` and ```angular_tolerance``` arguments (avoids using Gmsh)
 - Model wide mesh Gmsh size parameters with ```min_mesh_size``` and ```max_mesh_size``` arguments
 - Volume specific mesh sizing parameters with the ```set_size``` argument
 - Unstructured mesh that share the same coordinates as the surface mesh.
@@ -48,7 +48,7 @@ Cad-to-dagmc offers a wide range of features including.
 
 - Install using Mamba
 - Install using Conda
-- Install using pip and source compilations
+- Install using pip
 
 ## Install using Mamba
 
@@ -126,10 +126,10 @@ You may also want to install OpenMC with DAGMC to make use of the h5m geometry f
 
 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.15.0=dagmc*nompi*"
+mamba install -c conda-forge -y "openmc=0.15.2=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.
+You could also install using this [wheel repo](https://github.com/shimwell/wheels)
 
 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.
 

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/src/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.9.4'
-__version_tuple__ = version_tuple = (0, 9, 4)
+__version__ = version = '0.9.7'
+__version_tuple__ = version_tuple = (0, 9, 7)
 
-__commit_id__ = commit_id = 'g725750322'
+__commit_id__ = commit_id = 'g7b0ab5bff'

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/src/cad_to_dagmc/core.py

@@ -687,6 +687,7 @@ class CadToDagmc:
             assembly.add(part)
 
         if imprint:
+            print("Imprinting assembly for unstructured mesh generation")
             imprinted_assembly, _ = cq.occ_impl.assembly.imprint(assembly)
         else:
             imprinted_assembly = assembly
@@ -777,6 +778,7 @@ class CadToDagmc:
             assembly.add(part)
 
         if imprint:
+            print("Imprinting assembly for mesh generation")
             imprinted_assembly, _ = cq.occ_impl.assembly.imprint(assembly)
         else:
             imprinted_assembly = assembly
@@ -812,7 +814,6 @@ class CadToDagmc:
     def export_dagmc_h5m_file(
         self,
         filename: str = "dagmc.h5m",
-        meshing_backend: str = "cadquery",
         implicit_complement_material_tag: str | None = None,
         scale_factor: float = 1.0,
         imprint: bool = True,
@@ -822,8 +823,6 @@ class CadToDagmc:
 
         Args:
             filename: the filename to use for the saved DAGMC file.
-            meshing_backend: determines whether gmsh or cadquery's direct mesh method
-                is used for meshing. Options are 'gmsh' or 'cadquery'.
             implicit_complement_material_tag: the name of the material tag to use
                 for the implicit complement (void space).
             scale_factor: a scaling factor to apply to the geometry.
@@ -831,6 +830,11 @@ class CadToDagmc:
 
             **kwargs: Backend-specific parameters:
 
+                Backend selection:
+                - meshing_backend (str, optional): explicitly specify 'gmsh' or 'cadquery'.
+                  If not provided, backend is auto-selected based on other arguments.
+                  Defaults to 'cadquery' if no backend-specific arguments are given.
+
                 For GMSH backend:
                 - min_mesh_size (float): minimum mesh element size
                 - max_mesh_size (float): maximum mesh element size
@@ -851,6 +855,52 @@ class CadToDagmc:
             ValueError: If invalid parameter combinations are used.
         """
 
+        # Define all acceptable kwargs
+        cadquery_keys = {"tolerance", "angular_tolerance"}
+        gmsh_keys = {
+            "min_mesh_size",
+            "max_mesh_size",
+            "mesh_algorithm",
+            "set_size",
+            "umesh_filename",
+            "method",
+            "unstructured_volumes",
+        }
+        all_acceptable_keys = cadquery_keys | gmsh_keys | {"meshing_backend"}
+
+        # Check for invalid kwargs
+        invalid_keys = set(kwargs.keys()) - all_acceptable_keys
+        if invalid_keys:
+            raise ValueError(
+                f"Invalid keyword arguments: {sorted(invalid_keys)}\n"
+                f"Acceptable arguments are: {sorted(all_acceptable_keys)}"
+            )
+
+        # Handle meshing_backend - either from kwargs or auto-detect
+        meshing_backend = kwargs.pop("meshing_backend", None)
+
+        if meshing_backend is None:
+            # Auto-select meshing_backend based on kwargs
+            has_cadquery = any(key in kwargs for key in cadquery_keys)
+            has_gmsh = any(key in kwargs for key in gmsh_keys)
+            if has_cadquery and not has_gmsh:
+                meshing_backend = "cadquery"
+            elif has_gmsh and not has_cadquery:
+                meshing_backend = "gmsh"
+            elif has_cadquery and has_gmsh:
+                provided_cadquery = [key for key in cadquery_keys if key in kwargs]
+                provided_gmsh = [key for key in gmsh_keys if key in kwargs]
+                raise ValueError(
+                    "Ambiguous backend: both CadQuery and GMSH-specific arguments provided.\n"
+                    f"CadQuery-specific arguments: {sorted(cadquery_keys)}\n"
+                    f"GMSH-specific arguments: {sorted(gmsh_keys)}\n"
+                    f"Provided CadQuery arguments: {provided_cadquery}\n"
+                    f"Provided GMSH arguments: {provided_gmsh}\n"
+                    "Please provide only one backend's arguments."
+                )
+            else:
+                meshing_backend = "cadquery"  # default
+
         # Validate meshing backend
         if meshing_backend not in ["gmsh", "cadquery"]:
             raise ValueError(
@@ -858,6 +908,8 @@ class CadToDagmc:
                 'Available options are "gmsh" or "cadquery"'
             )
 
+        print(f"Using meshing backend: {meshing_backend}")
+
         # Initialize variables to avoid unbound errors
         tolerance = 0.1
         angular_tolerance = 0.1
@@ -963,6 +1015,7 @@ class CadToDagmc:
         elif meshing_backend == "gmsh":
             # If assembly is not to be imprinted, pass through the assembly as-is
             if imprint:
+                print("Imprinting assembly for mesh generation")
                 imprinted_assembly, imprinted_solids_with_org_id = cq.occ_impl.assembly.imprint(
                     assembly
                 )

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/src/cad_to_dagmc/direct_mesh_plugin.py

@@ -291,6 +291,7 @@ def to_mesh(
     # Imprinted assemblies end up being compounds, whereas you have to step through each of the
     # parts in an assembly and extract the solids.
     if imprint:
+        print("Imprinting assembly for mesh generation")
         # Imprint the assembly and process it as a compound
         (
             imprinted_assembly,
@@ -329,6 +330,7 @@ def to_mesh(
 
     # Step through all of the collected solids and their respective faces to get the vertices
     for solid in solids:
+        print(f"Meshing solid {solid_idx} of {len(solids)}")
         # Reset this each time so that we get the correct number of faces per solid
         face_triangles = {}
 

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/src/cad_to_dagmc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cad_to_dagmc
-Version: 0.9.4
+Version: 0.9.7
 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
@@ -50,7 +50,7 @@ cad-to-dagmc can convert the following in to DAGMC compatible meshes:
 
 Cad-to-dagmc offers a wide range of features including.
 - Geometry scaling with ```scale_factor``` argument
-- Ddirect surface meshing of CadQuery geometry with ```tolerance``` and ```angular_tolerance``` arguments (avoids using Gmsh)
+- Direct surface meshing of CadQuery geometry with ```tolerance``` and ```angular_tolerance``` arguments (avoids using Gmsh)
 - Model wide mesh Gmsh size parameters with ```min_mesh_size``` and ```max_mesh_size``` arguments
 - Volume specific mesh sizing parameters with the ```set_size``` argument
 - Unstructured mesh that share the same coordinates as the surface mesh.
@@ -73,7 +73,7 @@ Cad-to-dagmc offers a wide range of features including.
 
 - Install using Mamba
 - Install using Conda
-- Install using pip and source compilations
+- Install using pip
 
 ## Install using Mamba
 
@@ -151,10 +151,10 @@ You may also want to install OpenMC with DAGMC to make use of the h5m geometry f
 
 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.15.0=dagmc*nompi*"
+mamba install -c conda-forge -y "openmc=0.15.2=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.
+You could also install using this [wheel repo](https://github.com/shimwell/wheels)
 
 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.
 

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/tests/test_file_creation.py

@@ -133,7 +133,9 @@ def test_h5m_with_multi_volume_touching(meshing_backend):
         assert get_volumes_and_materials_from_h5m(h5m_file) == tags_dict
 
         cad_to_dagmc.export_gmsh_file_to_dagmc_h5m_file(
-            dagmc_filename=h5m_file, material_tags=mat_tags, gmsh_filename=h5m_file + ".msh"
+            dagmc_filename=h5m_file,
+            material_tags=mat_tags,
+            gmsh_filename=h5m_file + ".msh",
         )
         assert get_volumes_and_materials_from_h5m(h5m_file) == tags_dict
 

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/tests/test_get_volumes.py

@@ -9,8 +9,14 @@ import cad_to_dagmc
     "scale_factor, expected_bbox",
     [
         (1.0, (-5.0000001, -5.0000001, -5.0000001, 5.0000001, 5.0000001, 5.0000001)),
-        (2.0, (-10.0000001, -10.0000001, -10.0000001, 10.0000001, 10.0000001, 10.0000001)),
-        (10.0, (-50.0000001, -50.0000001, -50.0000001, 50.0000001, 50.0000001, 50.0000001)),
+        (
+            2.0,
+            (-10.0000001, -10.0000001, -10.0000001, 10.0000001, 10.0000001, 10.0000001),
+        ),
+        (
+            10.0,
+            (-50.0000001, -50.0000001, -50.0000001, 50.0000001, 50.0000001, 50.0000001),
+        ),
     ],
 )
 def test_get_volumes(scale_factor, expected_bbox):
@@ -35,8 +41,18 @@ def test_get_volumes(scale_factor, expected_bbox):
 @pytest.mark.parametrize(
     "scale_factor, expected_bbox_lower_left, expected_bbox_upper_right, meshing_backend",
     [
-        (1.0, (-5.0000001, -5.0000001, -5.0000001), (5.0000001, 5.0000001, 5.0000001), "cadquery"),
-        (1.0, (-5.0000001, -5.0000001, -5.0000001), (5.0000001, 5.0000001, 5.0000001), "gmsh"),
+        (
+            1.0,
+            (-5.0000001, -5.0000001, -5.0000001),
+            (5.0000001, 5.0000001, 5.0000001),
+            "cadquery",
+        ),
+        (
+            1.0,
+            (-5.0000001, -5.0000001, -5.0000001),
+            (5.0000001, 5.0000001, 5.0000001),
+            "gmsh",
+        ),
         (
             2.0,
             (-10.0000001, -10.0000001, -10.0000001),

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/tests/test_h5m_in_transport.py

@@ -288,7 +288,9 @@ def test_umesh_with_volumes(meshing_backend):
     model.add_cadquery_object(assembly, material_tags=mat_tags)
 
     h5m_file = model.export_dagmc_h5m_file(
-        filename="dagmc.h5m", set_size={1: 0.9, 2: 0.1, 3: 0.9}, meshing_backend=meshing_backend
+        filename="dagmc.h5m",
+        set_size={1: 0.9, 2: 0.1, 3: 0.9},
+        meshing_backend=meshing_backend,
     )
 
     vtk_file = model.export_unstructured_mesh_file(

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/tests/test_kwarg_args.py

@@ -54,7 +54,9 @@ class TestKwargsExportDagmcH5mFile:
 
         with pytest.raises(ValueError, match="CadQuery backend cannot be used for volume meshing"):
             self.my_model.export_dagmc_h5m_file(
-                filename=str(output_file), meshing_backend="cadquery", unstructured_volumes=[1]
+                filename=str(output_file),
+                meshing_backend="cadquery",
+                unstructured_volumes=[1],
             )
 
     def test_invalid_meshing_backend_raises_error(self, tmp_path):
@@ -187,6 +189,121 @@ class TestKwargsExportDagmcH5mFile:
         assert output_file_gmsh.exists()
 
 
+class TestKwargsValidation:
+    """Test kwargs validation for export_dagmc_h5m_file method"""
+
+    def setup_method(self):
+        """Setup method to create a simple geometry for testing"""
+        self.my_model = CadToDagmc()
+
+        # Create a simple box
+        box = cq.Workplane("XY").box(10, 10, 10)
+        self.my_model.add_cadquery_object(box, material_tags=["steel"])
+
+    def test_invalid_kwargs_raises_error(self, tmp_path):
+        """Test that invalid kwargs raise ValueError with helpful message"""
+        output_file = tmp_path / "test_invalid_kwargs.h5m"
+
+        with pytest.raises(ValueError) as excinfo:
+            self.my_model.export_dagmc_h5m_file(
+                filename=str(output_file),
+                invalid_param=123,
+                another_invalid=True,
+            )
+
+        error_message = str(excinfo.value)
+        assert "Invalid keyword arguments:" in error_message
+        assert "another_invalid" in error_message
+        assert "invalid_param" in error_message
+        assert "Acceptable arguments are:" in error_message
+
+    def test_mixed_valid_invalid_kwargs_raises_error(self, tmp_path):
+        """Test that mix of valid and invalid kwargs raises error"""
+        output_file = tmp_path / "test_mixed_kwargs.h5m"
+
+        with pytest.raises(ValueError) as excinfo:
+            self.my_model.export_dagmc_h5m_file(
+                filename=str(output_file),
+                tolerance=0.1,  # valid
+                bad_param=456,  # invalid
+                min_mesh_size=0.5,  # valid
+            )
+
+        error_message = str(excinfo.value)
+        assert "Invalid keyword arguments:" in error_message
+        assert "bad_param" in error_message
+        assert "tolerance" in error_message  # valid param should be in error
+        assert "min_mesh_size" in error_message  # valid param should be in error
+
+    def test_all_valid_cadquery_kwargs_accepted(self, tmp_path):
+        """Test that all valid CadQuery kwargs are accepted"""
+        output_file = tmp_path / "test_valid_cq_kwargs.h5m"
+
+        # Should not raise any error
+        result = self.my_model.export_dagmc_h5m_file(
+            filename=str(output_file),
+            meshing_backend="cadquery",
+            tolerance=0.1,
+            angular_tolerance=0.2,
+        )
+
+        assert result == str(output_file)
+        assert output_file.exists()
+
+    def test_all_valid_gmsh_kwargs_accepted(self, tmp_path):
+        """Test that all valid GMSH kwargs are accepted"""
+        output_file = tmp_path / "test_valid_gmsh_kwargs.h5m"
+
+        # Should not raise any error
+        result = self.my_model.export_dagmc_h5m_file(
+            filename=str(output_file),
+            meshing_backend="gmsh",
+            min_mesh_size=0.1,
+            max_mesh_size=1.0,
+            mesh_algorithm=1,
+            set_size={1: 0.5},
+            umesh_filename="test.vtk",
+            method="file",
+            # unstructured_volumes would be tested separately
+        )
+
+        assert result == str(output_file)
+        assert output_file.exists()
+
+    def test_typo_in_kwarg_name_raises_helpful_error(self, tmp_path):
+        """Test that typos in parameter names give helpful error messages"""
+        output_file = tmp_path / "test_typo.h5m"
+
+        # Common typo: "tolerance" -> "tollerance"
+        with pytest.raises(ValueError) as excinfo:
+            self.my_model.export_dagmc_h5m_file(
+                filename=str(output_file),
+                tollerance=0.1,  # typo
+            )
+
+        error_message = str(excinfo.value)
+        assert "Invalid keyword arguments:" in error_message
+        assert "tollerance" in error_message
+        assert "tolerance" in error_message  # should show the correct options
+
+    def test_case_sensitivity_in_kwargs(self, tmp_path):
+        """Test that kwargs are case sensitive"""
+        output_file = tmp_path / "test_case_sensitive.h5m"
+
+        # Wrong case should raise error
+        with pytest.raises(ValueError) as excinfo:
+            self.my_model.export_dagmc_h5m_file(
+                filename=str(output_file),
+                Tolerance=0.1,  # wrong case
+                MESHING_BACKEND="cadquery",  # wrong case
+            )
+
+        error_message = str(excinfo.value)
+        assert "Invalid keyword arguments:" in error_message
+        assert "Tolerance" in error_message
+        assert "MESHING_BACKEND" in error_message
+
+
 class TestKwargsWithMultipleVolumes:
     """Test kwargs functionality with multiple volumes"""
 

{cad_to_dagmc-0.9.4 → cad_to_dagmc-0.9.7}/tests/test_python_api.py

@@ -400,7 +400,9 @@ def test_unstructured_mesh_with_volumes(meshing_backend):
     model.add_cadquery_object(assembly, material_tags=["mat1", "mat2", "mat3"])
 
     filename = model.export_dagmc_h5m_file(
-        filename="dagmc.h5m", set_size={1: 0.9, 2: 0.1, 3: 0.9}, meshing_backend=meshing_backend
+        filename="dagmc.h5m",
+        set_size={1: 0.9, 2: 0.1, 3: 0.9},
+        meshing_backend=meshing_backend,
     )
     assert Path(filename).is_file()