[Hotfix Main]: [SNAPPY] Added validator for duplicate refinements on an entity (#1813)

Co-authored-by: piotrkluba <piotr.kluba@flexcompute.com>

Author: github-actions[bot]

flow360/component/simulation/meshing_param/snappy/snappy_params.py

@@ -9,6 +9,7 @@
 from flow360.component.simulation.meshing_param.meshing_specs import OctreeSpacing
 from flow360.component.simulation.meshing_param.snappy.snappy_mesh_refinements import (
     BodyRefinement,
+    RegionRefinement,
     SnappyEntityRefinement,
     SnappySurfaceRefinementTypes,
     SurfaceEdgeRefinement,
@@ -75,6 +76,37 @@ def _check_body_refinements_w_defaults(self):
                     )
         return self
 
+    @pd.field_validator("refinements", mode="after")
+    @classmethod
+    def _check_duplicate_refinements_per_entity(cls, refinements):
+        """Raise if the same refinement type is applied more than once to the same entity."""
+        if refinements is None:
+            return refinements
+
+        entity_refinement_map: dict[tuple[str, str], dict[str, int]] = {}
+        refinement_types_with_entities = (BodyRefinement, RegionRefinement, SurfaceEdgeRefinement)
+
+        for refinement in refinements:
+            if not isinstance(refinement, refinement_types_with_entities):
+                continue
+            if refinement.entities is None:
+                continue
+            refinement_type_name = type(refinement).__name__
+            for entity in refinement.entities.stored_entities:
+                entity_key = (type(entity).__name__, entity.name)
+                counts = entity_refinement_map.setdefault(entity_key, {})
+                counts[refinement_type_name] = counts.get(refinement_type_name, 0) + 1
+
+        for entity_key, type_counts in entity_refinement_map.items():
+            for refinement_type_name, count in type_counts.items():
+                if count > 1:
+                    raise ValueError(
+                        f"`{refinement_type_name}` is applied {count} times "
+                        f"to entity `{entity_key[1]}`. Each refinement type "
+                        f"can only be applied once per entity."
+                    )
+        return refinements
+
     @contextual_model_validator(mode="after")
     def _check_uniform_refinement_entities(self):
         # pylint: disable=no-member

tests/simulation/params/meshing_validation/test_meshing_param_validation.py

@@ -937,6 +937,132 @@ def test_bad_refinements():
         )
 
 
+def test_duplicate_refinement_type_per_entity():
+    """Raise when the same refinement type is applied twice to one entity."""
+    body = SnappyBody(name="car_body", surfaces=[])
+    surface = Surface(name="wing")
+    defaults = snappy.SurfaceMeshingDefaults(
+        min_spacing=1 * u.mm, max_spacing=5 * u.mm, gap_resolution=0.01 * u.mm
+    )
+
+    # -- Two BodyRefinements targeting the same SnappyBody --
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"`BodyRefinement` is applied 2 times to entity `car_body`",
+    ):
+        snappy.SurfaceMeshingParams(
+            defaults=defaults,
+            refinements=[
+                snappy.BodyRefinement(min_spacing=2 * u.mm, bodies=[body]),
+                snappy.BodyRefinement(max_spacing=4 * u.mm, bodies=[body]),
+            ],
+        )
+
+    # -- Two RegionRefinements targeting the same Surface --
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"`RegionRefinement` is applied 2 times to entity `wing`",
+    ):
+        snappy.SurfaceMeshingParams(
+            defaults=defaults,
+            refinements=[
+                snappy.RegionRefinement(
+                    min_spacing=1 * u.mm, max_spacing=3 * u.mm, regions=[surface]
+                ),
+                snappy.RegionRefinement(
+                    min_spacing=2 * u.mm, max_spacing=4 * u.mm, regions=[surface]
+                ),
+            ],
+        )
+
+    # -- Two SurfaceEdgeRefinements targeting the same SnappyBody --
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"`SurfaceEdgeRefinement` is applied 2 times to entity `car_body`",
+    ):
+        snappy.SurfaceMeshingParams(
+            defaults=defaults,
+            refinements=[
+                snappy.SurfaceEdgeRefinement(spacing=0.5 * u.mm, entities=[body]),
+                snappy.SurfaceEdgeRefinement(spacing=1 * u.mm, entities=[body]),
+            ],
+        )
+
+    # -- Two SurfaceEdgeRefinements targeting the same Surface --
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"`SurfaceEdgeRefinement` is applied 2 times to entity `wing`",
+    ):
+        snappy.SurfaceMeshingParams(
+            defaults=defaults,
+            refinements=[
+                snappy.SurfaceEdgeRefinement(spacing=0.5 * u.mm, entities=[surface]),
+                snappy.SurfaceEdgeRefinement(spacing=1 * u.mm, entities=[surface]),
+            ],
+        )
+
+
+def test_duplicate_refinement_different_types_is_allowed():
+    """Different refinement types on the same entity should NOT raise."""
+    body = SnappyBody(name="car_body", surfaces=[])
+    surface = Surface(name="wing")
+    defaults = snappy.SurfaceMeshingDefaults(
+        min_spacing=1 * u.mm, max_spacing=5 * u.mm, gap_resolution=0.01 * u.mm
+    )
+
+    # BodyRefinement + SurfaceEdgeRefinement on the same SnappyBody is fine
+    snappy.SurfaceMeshingParams(
+        defaults=defaults,
+        refinements=[
+            snappy.BodyRefinement(min_spacing=2 * u.mm, bodies=[body]),
+            snappy.SurfaceEdgeRefinement(spacing=0.5 * u.mm, entities=[body]),
+        ],
+    )
+
+    # RegionRefinement + SurfaceEdgeRefinement on the same Surface is fine
+    snappy.SurfaceMeshingParams(
+        defaults=defaults,
+        refinements=[
+            snappy.RegionRefinement(min_spacing=1 * u.mm, max_spacing=3 * u.mm, regions=[surface]),
+            snappy.SurfaceEdgeRefinement(spacing=0.5 * u.mm, entities=[surface]),
+        ],
+    )
+
+
+def test_duplicate_refinement_different_entities_is_allowed():
+    """Same refinement type on different entities should NOT raise."""
+    body1 = SnappyBody(name="car_body", surfaces=[])
+    body2 = SnappyBody(name="other_body", surfaces=[])
+    defaults = snappy.SurfaceMeshingDefaults(
+        min_spacing=1 * u.mm, max_spacing=5 * u.mm, gap_resolution=0.01 * u.mm
+    )
+
+    snappy.SurfaceMeshingParams(
+        defaults=defaults,
+        refinements=[
+            snappy.BodyRefinement(min_spacing=2 * u.mm, bodies=[body1]),
+            snappy.BodyRefinement(min_spacing=3 * u.mm, bodies=[body2]),
+        ],
+    )
+
+
+def test_duplicate_refinement_body_and_surface_same_name_is_allowed():
+    """SurfaceEdgeRefinement on a SnappyBody and a Surface sharing a name should NOT raise."""
+    body = SnappyBody(name="shared_name", surfaces=[])
+    surface = Surface(name="shared_name")
+    defaults = snappy.SurfaceMeshingDefaults(
+        min_spacing=1 * u.mm, max_spacing=5 * u.mm, gap_resolution=0.01 * u.mm
+    )
+
+    snappy.SurfaceMeshingParams(
+        defaults=defaults,
+        refinements=[
+            snappy.SurfaceEdgeRefinement(spacing=0.5 * u.mm, entities=[body]),
+            snappy.SurfaceEdgeRefinement(spacing=1 * u.mm, entities=[surface]),
+        ],
+    )
+
+
 def test_box_entity_enclosed_only_in_beta_mesher():
     # raises when beta mesher is off
     with pytest.raises(

tests/simulation/params/meshing_validation/test_refinements_validation.py

@@ -160,8 +160,8 @@ def test_snappy_edge_refinement_validators():
             snappy.SurfaceEdgeRefinement(
                 spacing=[2 * u.mm], distances=[5 * u.mm], entities=[Surface(name="test")]
             ),
-            snappy.SurfaceEdgeRefinement(spacing=2 * u.mm, entities=[Surface(name="test")]),
-            snappy.SurfaceEdgeRefinement(entities=[Surface(name="test")]),
+            snappy.SurfaceEdgeRefinement(spacing=2 * u.mm, entities=[Surface(name="test2")]),
+            snappy.SurfaceEdgeRefinement(entities=[Surface(name="test3")]),
         ],
     )