Merge branch 'main' into fxc-6541/multiple-surface-outputs

Author: NasserFlexCompute

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

@@ -12,7 +12,6 @@
 from flow360.component.simulation.meshing_param.volume_params import UniformRefinement
 from flow360.component.simulation.primitives import SnappyBody, Surface
 from flow360.component.simulation.unit_system import AngleType, LengthType
-from flow360.log import log
 
 
 class SnappyEntityRefinement(Flow360BaseModel, metaclass=ABCMeta):
@@ -36,11 +35,10 @@ def _check_spacing_order(self) -> Self:
     def _check_proximity_spacing(self) -> Self:
         if self.min_spacing and self.proximity_spacing:
             if self.proximity_spacing > self.min_spacing:
-                log.warning(
-                    f"Proximity spacing ({self.proximity_spacing}) was set higher than the minimal spacing"
-                    + f"({self.min_spacing}), setting proximity spacing to minimal spacing."
+                raise ValueError(
+                    f"Proximity spacing ({self.proximity_spacing}) was set higher than the minimal spacing "
+                    + f"({self.min_spacing})."
                 )
-                self.proximity_spacing = self.min_spacing
         return self
 
 

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

@@ -67,8 +67,16 @@ def _check_body_refinements_w_defaults(self):
             return self
         for refinement in self.refinements:
             if isinstance(refinement, BodyRefinement):
+                if refinement.min_spacing is None and refinement.proximity_spacing:
+                    if refinement.proximity_spacing > self.defaults.min_spacing:
+                        raise ValueError(
+                            f"Proximity spacing for a BodyRefinement ({refinement.proximity_spacing}) was set higher "
+                            + f"than the minimal spacing ({self.defaults.min_spacing})."
+                        )
+
                 if refinement.min_spacing is None and refinement.max_spacing is None:
                     continue
+
                 if refinement.min_spacing is None and self.defaults.min_spacing.to(
                     "m"
                 ) > refinement.max_spacing.to("m"):

flow360/component/simulation/translator/utils.py

@@ -123,9 +123,19 @@ def _apply_transformations_to_model(
                 setattr(model, field_name, new_entity_list)
 
         elif isinstance(field_value, (list, tuple)):
-            new_items = [_transform_sequence_item(item, manager) for item in field_value]
-            new_value = new_items if isinstance(field_value, list) else tuple(new_items)
-            setattr(model, field_name, new_value)
+            transformed_items = None
+            for index, item in enumerate(field_value):
+                transformed = _transform_sequence_item(item, manager)
+                if transformed is not item:
+                    if transformed_items is None:
+                        transformed_items = list(field_value)
+                    transformed_items[index] = transformed
+
+            if transformed_items is not None:
+                new_value = (
+                    transformed_items if isinstance(field_value, list) else tuple(transformed_items)
+                )
+                setattr(model, field_name, new_value)
 
         elif isinstance(field_value, Flow360BaseModel):
             _apply_transformations_to_model(field_value, manager)

tests/simulation/params/meshing_validation/test_refinements_validation.py

@@ -422,3 +422,74 @@ def test_volume_uniform_refinement_project_to_surface_false_skips_validation():
     )
 
     assert errors is None, "No snappy validation error expected when project_to_surface=False"
+
+
+def test_snappy_proximity_spacing_error_when_exceeds_default_min_spacing():
+    """When min_spacing is not set on a BodyRefinement but proximity_spacing exceeds
+    defaults.min_spacing, a ValueError should be raised."""
+    message = "Proximity spacing for a BodyRefinement (5.0 mm) was set higher than the minimal spacing (3.0 mm)."
+    with SI_unit_system, pytest.raises(pd.ValidationError, match=re.escape(message)):
+        snappy.SurfaceMeshingParams(
+            defaults=snappy.SurfaceMeshingDefaults(
+                min_spacing=3 * u.mm, max_spacing=10 * u.mm, gap_resolution=0.1 * u.mm
+            ),
+            refinements=[
+                snappy.BodyRefinement(
+                    bodies=SnappyBody(name="body1", surfaces=[Surface(name="surface")]),
+                    proximity_spacing=5 * u.mm,
+                    max_spacing=10 * u.mm,
+                ),
+            ],
+        )
+
+
+def test_snappy_proximity_spacing_ok_when_below_default_min_spacing():
+    """When proximity_spacing is already <= defaults.min_spacing, no error should be raised."""
+    with SI_unit_system:
+        body = SnappyBody(name="body1", surfaces=[Surface(name="surface")])
+        params = snappy.SurfaceMeshingParams(
+            defaults=snappy.SurfaceMeshingDefaults(
+                min_spacing=3 * u.mm, max_spacing=10 * u.mm, gap_resolution=0.1 * u.mm
+            ),
+            refinements=[
+                snappy.BodyRefinement(
+                    bodies=body,
+                    proximity_spacing=2 * u.mm,
+                    max_spacing=10 * u.mm,
+                ),
+            ],
+        )
+        assert params.refinements[0].proximity_spacing == 2 * u.mm
+
+
+def test_snappy_proximity_spacing_error_with_explicit_min_spacing():
+    """When both min_spacing and proximity_spacing are set on the refinement
+    and proximity_spacing > min_spacing, the entity-level validator raises."""
+    message = "Proximity spacing (6.0 mm) was set higher than the minimal spacing (4.0 mm)."
+    with SI_unit_system, pytest.raises(pd.ValidationError, match=re.escape(message)):
+        snappy.BodyRefinement(
+            bodies=SnappyBody(name="body1", surfaces=[Surface(name="surface")]),
+            min_spacing=4 * u.mm,
+            proximity_spacing=6 * u.mm,
+            max_spacing=10 * u.mm,
+        )
+
+
+def test_snappy_proximity_spacing_ok_when_min_spacing_is_set():
+    """When min_spacing is explicitly set and proximity_spacing <= min_spacing, no error."""
+    with SI_unit_system:
+        body = SnappyBody(name="body1", surfaces=[Surface(name="surface")])
+        params = snappy.SurfaceMeshingParams(
+            defaults=snappy.SurfaceMeshingDefaults(
+                min_spacing=1 * u.mm, max_spacing=10 * u.mm, gap_resolution=0.1 * u.mm
+            ),
+            refinements=[
+                snappy.BodyRefinement(
+                    bodies=body,
+                    min_spacing=4 * u.mm,
+                    proximity_spacing=3 * u.mm,
+                    max_spacing=10 * u.mm,
+                ),
+            ],
+        )
+        assert params.refinements[0].proximity_spacing == 3 * u.mm

tests/simulation/translator/test_translation_utils.py

@@ -0,0 +1,87 @@
+import flow360.component.simulation.units as u
+from flow360.component.simulation.draft_context.coordinate_system_manager import (
+    CoordinateSystemAssignmentGroup,
+    CoordinateSystemEntityRef,
+    CoordinateSystemStatus,
+)
+from flow360.component.simulation.entity_operation import CoordinateSystem
+from flow360.component.simulation.framework.param_utils import AssetCache
+from flow360.component.simulation.models.volume_models import (
+    BETDisk,
+    BETDiskChord,
+    BETDiskSectionalPolar,
+    BETDiskTwist,
+)
+from flow360.component.simulation.primitives import Cylinder
+from flow360.component.simulation.simulation_params import SimulationParams
+from flow360.component.simulation.translator.utils import (
+    apply_coordinate_system_transformations,
+)
+from flow360.component.simulation.unit_system import SI_unit_system
+
+
+def test_apply_coordinate_system_transformations_skips_frozen_non_entity_sequences():
+    with SI_unit_system:
+        cylinder = Cylinder(
+            name="bet_disk",
+            center=(0, 0, 0) * u.m,
+            axis=(0, 0, 1),
+            height=1 * u.m,
+            outer_radius=1 * u.m,
+        )
+        bet_disk = BETDisk(
+            entities=cylinder,
+            rotation_direction_rule="leftHand",
+            number_of_blades=3,
+            omega=100 * u.rpm,
+            chord_ref=1 * u.m,
+            n_loading_nodes=20,
+            mach_numbers=[0],
+            reynolds_numbers=[1000000],
+            twists=[BETDiskTwist(radius=0 * u.m, twist=0 * u.deg)],
+            chords=[BETDiskChord(radius=0 * u.m, chord=1 * u.m)],
+            alphas=[-2, 0, 2] * u.deg,
+            sectional_radiuses=[0.25, 0.5] * u.m,
+            sectional_polars=[
+                BETDiskSectionalPolar(
+                    lift_coeffs=[[[0.1, 0.2, 0.3]]],
+                    drag_coeffs=[[[0.01, 0.02, 0.03]]],
+                ),
+                BETDiskSectionalPolar(
+                    lift_coeffs=[[[0.15, 0.25, 0.35]]],
+                    drag_coeffs=[[[0.015, 0.025, 0.035]]],
+                ),
+            ],
+        )
+        coordinate_system = CoordinateSystem(name="cs", translation=(1, 2, 3) * u.m)
+        coordinate_system_status = CoordinateSystemStatus(
+            coordinate_systems=[coordinate_system],
+            parents=[],
+            assignments=[
+                CoordinateSystemAssignmentGroup(
+                    coordinate_system_id=coordinate_system.private_attribute_id,
+                    entities=[
+                        CoordinateSystemEntityRef(
+                            entity_type="Cylinder",
+                            entity_id=cylinder.private_attribute_id,
+                        )
+                    ],
+                )
+            ],
+        )
+        params = SimulationParams(
+            models=[bet_disk],
+            private_attribute_asset_cache=AssetCache(
+                coordinate_system_status=coordinate_system_status,
+            ),
+        )
+
+    apply_coordinate_system_transformations(params)
+
+    transformed_bet_disk = params.models[0]
+    transformed_cylinder = transformed_bet_disk.entities.stored_entities[0]
+
+    assert all(transformed_cylinder.center == [1, 2, 3] * u.m)
+    assert transformed_bet_disk.mach_numbers == [0]
+    assert transformed_bet_disk.twists[0].radius == 0 * u.m
+    assert transformed_bet_disk.chords[0].chord == 1 * u.m