Added more surface refinement options for the GAI surface mesher (#1597)

* Added default and local option for resolving face boundaries, and option to specify curvature_resolution_angle at the face level with the GAI surface mesher

* Linter fixes

* Apply suggestions from code review

Co-authored-by: Ben <106089368+benflexcompute@users.noreply.github.com>

* Added validation check to ensure that SurfaceRefinement has at least one specified option.

---------

Co-authored-by: Ben <106089368+benflexcompute@users.noreply.github.com>

Author: savithru-flex

flow360/component/simulation/meshing_param/face_params.py

@@ -12,12 +12,13 @@
     GhostSurface,
     Surface,
 )
-from flow360.component.simulation.unit_system import LengthType
+from flow360.component.simulation.unit_system import AngleType, LengthType
 from flow360.component.simulation.validation.validation_context import (
     get_validation_info,
 )
 from flow360.component.simulation.validation.validation_utils import (
     check_deleted_surface_in_entity_list,
+    check_geometry_ai_features,
     check_ghost_surface_usage_policy_for_face_refinements,
 )
 
@@ -43,8 +44,22 @@ class SurfaceRefinement(Flow360BaseModel):
         alias="faces"
     )
     # pylint: disable=no-member
-    max_edge_length: LengthType.Positive = pd.Field(
-        description="Maximum edge length of surface cells."
+    max_edge_length: Optional[LengthType.Positive] = pd.Field(
+        None, description="Maximum edge length of surface cells."
+    )
+
+    curvature_resolution_angle: Optional[AngleType.Positive] = pd.Field(
+        None,
+        description=(
+            "Default maximum angular deviation in degrees. "
+            "This value will restrict the angle between a cell’s normal and its underlying surface normal."
+        ),
+    )
+
+    resolve_face_boundaries: Optional[bool] = pd.Field(
+        None,
+        description="Flag to specify whether boundaries between adjacent faces should be resolved "
+        + "accurately during the surface meshing process using anisotropic mesh refinement.",
     )
 
     @pd.field_validator("entities", mode="after")
@@ -56,6 +71,28 @@ def ensure_surface_existence(cls, value):
         )
         return check_deleted_surface_in_entity_list(value)
 
+    @pd.field_validator("curvature_resolution_angle", "resolve_face_boundaries", mode="after")
+    @classmethod
+    def ensure_geometry_ai_features(cls, value, info):
+        """Validate that the feature is only used when Geometry AI is enabled."""
+        return check_geometry_ai_features(cls, value, info)
+
+    @pd.model_validator(mode="after")
+    def require_at_least_one_setting(self):
+        """Ensure that at least one of max_edge_length, curvature_resolution_angle,
+        or resolve_face_boundaries is specified for SurfaceRefinement.
+        """
+        if (
+            self.max_edge_length is None
+            and self.curvature_resolution_angle is None
+            and self.resolve_face_boundaries is None
+        ):
+            raise ValueError(
+                "SurfaceRefinement requires at least one of 'max_edge_length', "
+                "'curvature_resolution_angle', or 'resolve_face_boundaries' to be specified."
+            )
+        return self
+
 
 class GeometryRefinement(Flow360BaseModel):
     """

flow360/component/simulation/meshing_param/params.py

@@ -34,7 +34,10 @@
     ContextField,
     get_validation_info,
 )
-from flow360.component.simulation.validation.validation_utils import EntityUsageMap
+from flow360.component.simulation.validation.validation_utils import (
+    EntityUsageMap,
+    check_geometry_ai_features,
+)
 
 RefinementTypes = Annotated[
     Union[
@@ -157,22 +160,32 @@ class MeshingDefaults(Flow360BaseModel):
             "Default maximum angular deviation in degrees. This value will restrict:"
             " 1. The angle between a cell’s normal and its underlying surface normal."
             " 2. The angle between a line segment’s normal and its underlying curve normal."
-            " This can not be overridden per face."
+            " This can be overridden per face only when using geometry AI."
         ),
         context=SURFACE_MESH,
     )
 
+    resolve_face_boundaries: bool = pd.Field(
+        False,
+        description="Flag to specify whether boundaries between adjacent faces should be resolved "
+        + "accurately during the surface meshing process using anisotropic mesh refinement. "
+        + "This option is only supported when using geometry AI, and can be overridden "
+        + "per face with :class:`~flow360.SurfaceRefinement`.",
+    )
+
     preserve_thin_geometry: bool = pd.Field(
         False,
         description="Flag to specify whether thin geometry features with thickness roughly equal "
-        + "to geometry_accuracy should be resolved accurately during the surface meshing process."
-        + "This can be overridden with class: ~flow360.GeometryRefinement",
+        + "to geometry_accuracy should be resolved accurately during the surface meshing process. "
+        + "This option is only supported when using geometry AI, and can be overridden "
+        + "per face with :class:`~flow360.GeometryRefinement`.",
     )
 
     sealing_size: LengthType.NonNegative = pd.Field(
         0.0 * u.m,
         description="Threshold size below which all geometry gaps are automatically closed. "
-        + "This can be overridden with class: ~flow360.GeometryRefinement",
+        + "This option is only supported when using geometry AI, and can be overridden "
+        + "per face with :class:`~flow360.GeometryRefinement`.",
     )
 
     remove_non_manifold_faces: bool = pd.Field(
@@ -212,25 +225,16 @@ def invalid_geometry_accuracy(cls, value):
     @pd.field_validator(
         "surface_max_aspect_ratio",
         "surface_max_adaptation_iterations",
+        "resolve_face_boundaries",
         "preserve_thin_geometry",
         "sealing_size",
         "remove_non_manifold_faces",
         mode="after",
     )
     @classmethod
-    def invalid_geometry_ai_features(cls, value, info):
-        """Ensure GAI features are not specified when GAI is not used"""
-        validation_info = get_validation_info()
-
-        if validation_info is None:
-            return value
-
-        # pylint: disable=unsubscriptable-object
-        default_value = cls.model_fields[info.field_name].default
-        if value != default_value and not validation_info.use_geometry_AI:
-            raise ValueError(f"{info.field_name} is only supported when geometry AI is used.")
-
-        return value
+    def ensure_geometry_ai_features(cls, value, info):
+        """Validate that the feature is only used when Geometry AI is enabled."""
+        return check_geometry_ai_features(cls, value, info)
 
 
 class MeshingParams(Flow360BaseModel):

flow360/component/simulation/translator/surface_meshing_translator.py

@@ -165,6 +165,7 @@ def _get_volume_zones(volume_zones_list: list[dict]):
             "curvature_resolution_angle": None,
             "surface_edge_growth_rate": None,
             "geometry_accuracy": None,
+            "resolve_face_boundaries": None,
             "preserve_thin_geometry": None,
             "surface_max_aspect_ratio": None,
             "surface_max_adaptation_iterations": None,

flow360/component/simulation/validation/validation_utils.py

@@ -366,3 +366,18 @@ def add_entity_usage(self, entity, model_type):
         )
         entity_log["model_list"].append(model_type)
         self.dict_entity[entity_type][entity_key] = entity_log
+
+
+def check_geometry_ai_features(cls, value, info):
+    """Ensure GAI features are not specified when GAI is not used"""
+    validation_info = get_validation_info()
+
+    if validation_info is None:
+        return value
+
+    # pylint: disable=unsubscriptable-object
+    default_value = cls.model_fields[info.field_name].default
+    if value != default_value and not validation_info.use_geometry_AI:
+        raise ValueError(f"{info.field_name} is only supported when geometry AI is used.")
+
+    return value

tests/ref/simulation/service_init_geometry.json

@@ -16,6 +16,7 @@
                 "value": 12.0,
                 "units": "degree"
             },
+            "resolve_face_boundaries": false,
             "preserve_thin_geometry": false,
             "sealing_size": {
                 "value": 0.0,

tests/ref/simulation/service_init_surface_mesh.json

@@ -16,6 +16,7 @@
                 "value": 12.0,
                 "units": "degree"
             },
+            "resolve_face_boundaries": false,
             "preserve_thin_geometry": false,
             "sealing_size": {
                 "value": 0.0,

tests/simulation/params/meshing_validation/test_meshing_param_validation.py

@@ -1,7 +1,12 @@
 import pydantic as pd
 import pytest
 
-from flow360.component.simulation.meshing_param.params import MeshingParams
+import flow360.component.simulation.units as u
+from flow360.component.simulation.meshing_param.face_params import SurfaceRefinement
+from flow360.component.simulation.meshing_param.params import (
+    MeshingDefaults,
+    MeshingParams,
+)
 from flow360.component.simulation.meshing_param.volume_params import (
     AutomatedFarfield,
     AxisymmetricRefinement,
@@ -18,6 +23,7 @@
 from flow360.component.simulation.simulation_params import SimulationParams
 from flow360.component.simulation.unit_system import CGS_unit_system
 from flow360.component.simulation.validation.validation_context import (
+    SURFACE_MESH,
     VOLUME_MESH,
     ParamsValidationInfo,
     ValidationContext,
@@ -493,3 +499,47 @@ def test_enclosed_entities_none_does_not_raise():
             spacing_radial=0.2,
             spacing_circumferential=20,
         )
+
+
+def test_resolve_face_boundary_only_in_gai_mesher():
+    # raise when GAI is off
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"resolve_face_boundaries is only supported when geometry AI is used",
+    ):
+        with ValidationContext(SURFACE_MESH, non_gai_context):
+            with CGS_unit_system:
+                MeshingParams(
+                    defaults=MeshingDefaults(
+                        boundary_layer_first_layer_thickness=0.1, resolve_face_boundaries=True
+                    )
+                )
+
+
+def test_surface_refinement_in_gai_mesher():
+    # raise when GAI is off
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"curvature_resolution_angle is only supported when geometry AI is used",
+    ):
+        with ValidationContext(SURFACE_MESH, non_gai_context):
+            with CGS_unit_system:
+                SurfaceRefinement(max_edge_length=0.1, curvature_resolution_angle=10 * u.deg)
+
+    # raise when GAI is off
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"resolve_face_boundaries is only supported when geometry AI is used",
+    ):
+        with ValidationContext(SURFACE_MESH, non_gai_context):
+            with CGS_unit_system:
+                SurfaceRefinement(resolve_face_boundaries=True)
+
+    # raise when no options are specified
+    with pytest.raises(
+        pd.ValidationError,
+        match=r"SurfaceRefinement requires at least one of 'max_edge_length', 'curvature_resolution_angle', or 'resolve_face_boundaries' to be specified",
+    ):
+        with ValidationContext(SURFACE_MESH, non_gai_context):
+            with CGS_unit_system:
+                SurfaceRefinement(entities=Surface(name="testFace"))

tests/simulation/translator/ref/surface_meshing/gai_surface_mesher.json

@@ -14,6 +14,7 @@
                 "value": 0.05,
                 "units": "1.0*m"
             },
+            "resolve_face_boundaries": false,
             "preserve_thin_geometry": false,
             "surface_max_aspect_ratio": 0.01,
             "surface_max_adaptation_iterations": 19,
@@ -151,7 +152,12 @@
                 "max_edge_length": {
                     "value": 0.1,
                     "units": "1.0*m"
-                }
+                },
+                "curvature_resolution_angle": {
+                    "value": 0.08726646259971647,
+                    "units": "rad"
+                },
+                "resolve_face_boundaries": true
             },
             {
                 "name": "Local_override",

tests/simulation/translator/test_surface_meshing_translator.py

@@ -382,11 +382,11 @@ def airplane_surface_mesh():
 
 @pytest.fixture()
 def rotor_surface_mesh():
-    rotor_geopmetry = TempGeometry("rotor.csm")
+    rotor_geometry = TempGeometry("rotor.csm")
     with imperial_unit_system:
         param = SimulationParams(
             private_attribute_asset_cache=AssetCache(
-                project_entity_info=rotor_geopmetry._get_entity_info()
+                project_entity_info=rotor_geometry._get_entity_info()
             ),
             meshing=MeshingParams(
                 defaults=MeshingDefaults(
@@ -396,40 +396,40 @@ def rotor_surface_mesh():
                 ),
                 refinements=[
                     SurfaceRefinement(
-                        entities=[rotor_geopmetry["body01_face003"]],
+                        entities=[rotor_geometry["body01_face003"]],
                         max_edge_length=0.1 * u.inch,
                     ),
                     SurfaceRefinement(
                         entities=[
-                            rotor_geopmetry["body01_face001"],
-                            rotor_geopmetry["body01_face002"],
+                            rotor_geometry["body01_face001"],
+                            rotor_geometry["body01_face002"],
                         ],
                         max_edge_length=10 * u.inch,
                     ),
                     SurfaceEdgeRefinement(
-                        entities=[rotor_geopmetry["body01_edge001"]],
+                        entities=[rotor_geometry["body01_edge001"]],
                         method=AngleBasedRefinement(value=1 * u.degree),
                     ),
                     SurfaceEdgeRefinement(
                         entities=[
-                            rotor_geopmetry["body01_edge002"],
-                            rotor_geopmetry["body01_edge003"],
+                            rotor_geometry["body01_edge002"],
+                            rotor_geometry["body01_edge003"],
                         ],
                         method=HeightBasedRefinement(value=0.05 * u.inch),
                     ),
                     SurfaceEdgeRefinement(
                         entities=[
-                            rotor_geopmetry["body01_edge004"],
-                            rotor_geopmetry["body01_edge006"],
+                            rotor_geometry["body01_edge004"],
+                            rotor_geometry["body01_edge006"],
                         ],
                         method=ProjectAnisoSpacing(),
                     ),
                     SurfaceEdgeRefinement(
-                        entities=[rotor_geopmetry["body01_edge005"]],
+                        entities=[rotor_geometry["body01_edge005"]],
                         method=HeightBasedRefinement(value=0.01 * u.inch),
                     ),
                     SurfaceEdgeRefinement(
-                        entities=[rotor_geopmetry["body01_edge007"]],
+                        entities=[rotor_geometry["body01_edge007"]],
                         method=HeightBasedRefinement(value=0.01 * u.inch),
                     ),
                 ],
@@ -531,7 +531,7 @@ def test_gai_surface_mesher_refinements():
         params = SimulationParams(
             meshing=MeshingParams(
                 defaults=MeshingDefaults(
-                    geometry_accuracy=0.05 * u.m,  # GAI setting
+                    geometry_accuracy=0.05 * u.m,  # GAI only setting
                     surface_max_edge_length=0.2,
                     boundary_layer_first_layer_thickness=0.01,
                     surface_max_aspect_ratio=0.01,
@@ -543,6 +543,8 @@ def test_gai_surface_mesher_refinements():
                         name="renamed_surface",
                         max_edge_length=0.1,
                         faces=[geometry["*"]],
+                        curvature_resolution_angle=5.0 * u.deg,  # GAI only setting
+                        resolve_face_boundaries=True,  # GAI only setting
                     ),
                     GeometryRefinement(
                         name="Local_override",