Modular meshing and Snappy

flow360/__init__.py

@@ -11,6 +11,7 @@
 from flow360.component.simulation import units as u
 from flow360.component.simulation.entity_operation import Transformation
 from flow360.component.simulation.folder import Folder
+from flow360.component.simulation.meshing_param import snappy
 from flow360.component.simulation.meshing_param.edge_params import (
     AngleBasedRefinement,
     AspectRatioBasedRefinement,
@@ -24,9 +25,15 @@
     PassiveSpacing,
     SurfaceRefinement,
 )
-from flow360.component.simulation.meshing_param.params import (
+from flow360.component.simulation.meshing_param.meshing_specs import (
     MeshingDefaults,
+    OctreeSpacing,
+    VolumeMeshingDefaults,
+)
+from flow360.component.simulation.meshing_param.params import (
     MeshingParams,
+    ModularMeshingWorkflow,
+    VolumeMeshingParams,
 )
 from flow360.component.simulation.meshing_param.volume_params import (
     AutomatedFarfield,
@@ -145,6 +152,7 @@
     Cylinder,
     ImportedSurface,
     ReferenceGeometry,
+    SeedpointZone,
 )
 from flow360.component.simulation.run_control.run_control import RunControl
 from flow360.component.simulation.run_control.stopping_criterion import (
@@ -311,11 +319,17 @@
     "math",
     "solution",
     "report",
+    "snappy",
+    "ModularMeshingWorkflow",
+    "SeedpointZone",
+    "VolumeMeshingParams",
+    "VolumeMeshingDefaults",
     "get_user_variable",
     "show_user_variables",
     "remove_user_variable",
     "StoppingCriterion",
     "MovingStatistic",
     "ImportedSurface",
+    "OctreeSpacing",
     "RunControl",
 ]

flow360/component/case.py

@@ -296,7 +296,7 @@ def to_case(self) -> Case:
     @before_submit_only
     def submit(self, force_submit: bool = False) -> Case:
         """
-        submits case to cloud for running
+        Submits case to cloud for running.
         """
         assert self.name
         assert self.volume_mesh_id or self.other_case or self.parent_id or self.parent_case

flow360/component/geometry.py

@@ -236,6 +236,11 @@ class Geometry(AssetBase):
     _entity_info_class = GeometryEntityInfo
     _cloud_resource_type_name = "Geometry"
 
+    # pylint: disable=redefined-builtin
+    def __init__(self, id: Union[str, None]):
+        super().__init__(id)
+        self.snappy_body_registry = None
+
     @property
     def face_group_tag(self):
         "getter for face_group_tag"
@@ -263,6 +268,16 @@ def body_group_tag(self):
     def body_group_tag(self, new_value: str):
         raise SyntaxError("Cannot set body_group_tag, use group_bodies_by_tag() instead.")
 
+    @property
+    def snappy_bodies(self):
+        """Getter for the snappy registry."""
+        if self.snappy_body_registry is None:
+            raise Flow360ValueError(
+                "The faces in geometry are not grouped for snappy."
+                "Please use `group_faces_for_snappy` function to group them first."
+            )
+        return self.snappy_body_registry
+
     def get_dynamic_default_settings(self, simulation_dict: dict):
         """Get the default geometry settings from the simulation dict"""
 
@@ -412,10 +427,25 @@ def group_bodies_by_tag(self, tag_name: str) -> None:
             "body", tag_name, self.internal_registry
         )
 
+    def group_faces_for_snappy(self) -> None:
+        """
+        Group faces according to body::region convention for snappyHexMesh.
+        """
+        # pylint: disable=protected-access,no-member
+        self.internal_registry = self._entity_info._group_entity_by_tag(
+            "face", "faceId", self.internal_registry
+        )
+        # pylint: disable=protected-access
+        self.snappy_body_registry = self._entity_info._group_faces_by_snappy_format()
+
     def reset_face_grouping(self) -> None:
         """Reset the face grouping"""
         # pylint: disable=protected-access,no-member
         self.internal_registry = self._entity_info._reset_grouping("face", self.internal_registry)
+        if self.snappy_body_registry is not None:
+            self.snappy_body_registry = self.snappy_body._reset_grouping(
+                "face", self.snappy_body_registry
+            )
 
     def reset_edge_grouping(self) -> None:
         """Reset the edge grouping"""

flow360/component/simulation/entity_info.py

@@ -7,7 +7,10 @@
 import pydantic as pd
 
 from flow360.component.simulation.framework.base_model import Flow360BaseModel
-from flow360.component.simulation.framework.entity_registry import EntityRegistry
+from flow360.component.simulation.framework.entity_registry import (
+    EntityRegistry,
+    SnappyBodyRegistry,
+)
 from flow360.component.simulation.outputs.output_entities import (
     Point,
     PointArray,
@@ -24,6 +27,7 @@
     GeometryBodyGroup,
     GhostCircularPlane,
     GhostSphere,
+    SnappyBody,
     Surface,
 )
 from flow360.component.simulation.unit_system import LengthType
@@ -152,7 +156,7 @@ class GeometryEntityInfo(EntityInfoModel):
 
     def group_in_registry(
         self,
-        entity_type_name: Literal["face", "edge", "body"],
+        entity_type_name: Literal["face", "edge", "body", "snappy_body"],
         attribute_name: str,
         registry: EntityRegistry,
     ) -> EntityRegistry:
@@ -165,15 +169,31 @@ def group_in_registry(
             known_frozen_hashes = registry.fast_register(item, known_frozen_hashes)
         return registry
 
+    def _get_snappy_bodies(self) -> List[SnappyBody]:
+
+        snappy_body_mapping = {}
+        for patch in self.grouped_faces[self.face_attribute_names.index("faceId")]:
+            name_components = patch.name.split("::")
+            body_name = name_components[0]
+            if body_name not in snappy_body_mapping:
+                snappy_body_mapping[body_name] = []
+            if patch not in snappy_body_mapping[body_name]:
+                snappy_body_mapping[body_name].append(patch)
+
+        return [
+            SnappyBody(name=snappy_body, surfaces=body_entities)
+            for snappy_body, body_entities in snappy_body_mapping.items()
+        ]
+
     def _get_list_of_entities(
         self,
         attribute_name: Union[str, None] = None,
-        entity_type_name: Literal["face", "edge", "body"] = None,
-    ) -> Union[List[Surface], List[Edge], List[GeometryBodyGroup]]:
+        entity_type_name: Literal["face", "edge", "body", "snappy_body"] = None,
+    ) -> Union[List[Surface], List[Edge], List[GeometryBodyGroup], List[SnappyBody]]:
         # Validations
         if entity_type_name is None:
             raise ValueError("Entity type name is required.")
-        if entity_type_name not in ["face", "edge", "body"]:
+        if entity_type_name not in ["face", "edge", "body", "snappy_body"]:
             raise ValueError(
                 f"Invalid entity type name, expected 'body, 'face' or 'edge' but got {entity_type_name}."
             )
@@ -185,10 +205,12 @@ def _get_list_of_entities(
             entity_attribute_names = self.edge_attribute_names
             entity_full_list = self.grouped_edges
             specified_attribute_name = self.edge_group_tag
-        else:
+        elif entity_type_name == "body":
             entity_attribute_names = self.body_attribute_names
             entity_full_list = self.grouped_bodies
             specified_attribute_name = self.body_group_tag
+        else:
+            return self._get_snappy_bodies()
 
         # Use the supplied one if not None
         if attribute_name is not None:
@@ -358,11 +380,20 @@ def _group_entity_by_tag(
 
         return registry
 
+    def _group_faces_by_snappy_format(self):
+        registry = SnappyBodyRegistry()
+
+        registry = self.group_in_registry("snappy_body", attribute_name="faceId", registry=registry)
+
+        return registry
+
+    @pd.validate_call
     def _reset_grouping(
         self, entity_type_name: Literal["face", "edge", "body"], registry: EntityRegistry
     ) -> EntityRegistry:
         if entity_type_name == "face":
             registry.clear(Surface)
+            registry.clear(SnappyBody)
             with model_attribute_unlock(self, "face_group_tag"):
                 self.face_group_tag = None
         elif entity_type_name == "edge":

flow360/component/simulation/framework/entity_registry.py

@@ -7,6 +7,37 @@
 from flow360.component.simulation.framework.base_model import Flow360BaseModel
 from flow360.component.simulation.framework.entity_base import EntityBase
 from flow360.component.utils import _naming_pattern_handler
+from flow360.exceptions import Flow360ValueError
+
+
+class StringIndexableList(list):
+    """
+    An extension of a list that allows accessing elements inside it through a string key.
+    """
+
+    def __getitem__(self, key: Union[str, slice, int]):
+        if isinstance(key, str):
+            returned_items = []
+            for item in self:
+                try:
+                    item_ret_value = item[key]
+                except KeyError:
+                    item_ret_value = []
+                except Exception as e:
+                    raise ValueError(
+                        f"Trying to access something in {item} through string indexing, which is not allowed."
+                    ) from e
+                if isinstance(item_ret_value, list):
+                    returned_items += item_ret_value
+                else:
+                    returned_items.append(item_ret_value)
+            if not returned_items:
+                raise ValueError(
+                    "No entity found in registry for parent entities: "
+                    + f"{', '.join([f'{entity.name}' for entity in self])} with given name/naming pattern: '{key}'."
+                )
+            return returned_items
+        return super().__getitem__(key)
 
 
 class EntityRegistryBucket:
@@ -224,3 +255,49 @@ def find_by_asset_id(self, *, entity_id: str, entity_class: type[EntityBase]):
     def is_empty(self):
         """Return True if the registry is empty, False otherwise."""
         return not self.internal_registry
+
+
+class SnappyBodyRegistry(EntityRegistry):
+    """
+    Extension of :class:`EntityRegistry` to be used with :class:`SnappyBody`, allows double indexing
+    for accessing the boundaries under certain :class:`SnappyBody`.
+    """
+
+    def find_by_naming_pattern(
+        self, pattern: str, enforce_output_as_list: bool = True, error_when_no_match: bool = False
+    ) -> StringIndexableList[EntityBase]:
+        """
+        Finds all registered entities whose names match a given pattern.
+
+        Parameters:
+            pattern (str): A naming pattern, which can include '*' as a wildcard.
+
+        Returns:
+            List[EntityBase]: A list of entities whose names match the pattern.
+        """
+        matched_entities = StringIndexableList()
+        regex = _naming_pattern_handler(pattern=pattern)
+        # pylint: disable=no-member
+        for entity_list in self.internal_registry.values():
+            matched_entities.extend(filter(lambda x: regex.match(x.name), entity_list))
+
+        if not matched_entities and error_when_no_match is True:
+            raise ValueError(
+                f"No entity found in registry with given name/naming pattern: '{pattern}'."
+            )
+        if enforce_output_as_list is False and len(matched_entities) == 1:
+            return matched_entities[0]
+
+        return matched_entities
+
+    def __getitem__(self, key):
+        """
+        Get the entity by name.
+        `key` is the name of the entity or the naming pattern if wildcard is used.
+        """
+        if isinstance(key, str) is False:
+            raise Flow360ValueError(f"Entity naming pattern: {key} is not a string.")
+
+        return self.find_by_naming_pattern(
+            key, enforce_output_as_list=False, error_when_no_match=True
+        )

flow360/component/simulation/framework/param_utils.py

@@ -149,6 +149,7 @@ def register_entity_list(model: Flow360BaseModel, registry: EntityRegistry) -> N
             register_entity_list(field, registry)
 
 
+# pylint: disable=too-many-branches
 def _update_entity_full_name(
     model: Flow360BaseModel,
     target_entity_type: Union[type[_SurfaceEntityBase], type[_VolumeEntityBase]],
@@ -167,20 +168,36 @@ def _update_entity_full_name(
             field._update_entity_info_with_metadata(volume_mesh_meta_data)
 
         if isinstance(field, EntityList):
+            added_entities = []
             for entity in field.stored_entities:
                 if isinstance(entity, target_entity_type):
                     # pylint: disable=protected-access
-                    entity._update_entity_info_with_metadata(volume_mesh_meta_data)
+                    partial_additions = entity._update_entity_info_with_metadata(
+                        volume_mesh_meta_data
+                    )
+                    if partial_additions is not None:
+                        added_entities.extend(partial_additions)
+            field.stored_entities.extend(added_entities)
 
         elif isinstance(field, (list, tuple)):
+            added_entities = []
             for item in field:
                 if isinstance(item, target_entity_type):
-                    item._update_entity_info_with_metadata(  # pylint: disable=protected-access
-                        volume_mesh_meta_data
+                    partial_additions = (
+                        item._update_entity_info_with_metadata(  # pylint: disable=protected-access
+                            volume_mesh_meta_data
+                        )
                     )
+                    if partial_additions is not None:
+                        added_entities.extend(partial_additions)
                 elif isinstance(item, Flow360BaseModel):
                     _update_entity_full_name(item, target_entity_type, volume_mesh_meta_data)
 
+            if isinstance(field, list):
+                field.extend(added_entities)
+            if isinstance(field, tuple):
+                field += tuple(added_entities)
+
         elif isinstance(field, Flow360BaseModel):
             _update_entity_full_name(field, target_entity_type, volume_mesh_meta_data)
 

flow360/component/simulation/framework/updater.py

@@ -373,6 +373,15 @@ def _to_25_7_6(params_as_dict):
     return remove_entity_bucket_field(params_as_dict=params_as_dict)
 
 
+def _to_25_8_0(params_as_dict):
+    # new method of specifying meshing was added, as well as the method discriminator
+    meshing = params_as_dict.get("meshing")
+    if meshing:
+        meshing["type_name"] = "MeshingParams"
+
+    return params_as_dict
+
+
 VERSION_MILESTONES = [
     (Flow360Version("24.11.1"), _to_24_11_1),
     (Flow360Version("24.11.7"), _to_24_11_7),
@@ -386,7 +395,8 @@ def _to_25_7_6(params_as_dict):
     (Flow360Version("25.6.5"), _to_25_6_5),
     (Flow360Version("25.6.6"), _to_25_6_6),
     (Flow360Version("25.7.2"), _to_25_7_2),
-    (Flow360Version("25.8.0b4"), _to_25_7_6),
+    (Flow360Version("25.7.6"), _to_25_7_6),
+    (Flow360Version("25.8.0b4"), _to_25_8_0),
 ]  # A list of the Python API version tuple with there corresponding updaters.