ansys-fluent-core 0.34.dev0__py3-none-any.whl → 0.34.1__py3-none-any.whl

ansys/fluent/core/services/field_data.py

@@ -21,6 +21,7 @@
 # SOFTWARE.
 
 """Wrappers over FieldData gRPC service of Fluent."""
+from collections.abc import Iterable
 from dataclasses import dataclass, field
 from enum import Enum
 from functools import reduce
@@ -30,6 +31,7 @@ from typing import Callable, Dict, List, Tuple
 import warnings
 import weakref
 
+from deprecated.sphinx import deprecated
 import grpc
 import numpy as np
 
@@ -39,8 +41,8 @@ from ansys.fluent.core.exceptions import DisallowedValuesError
 from ansys.fluent.core.field_data_interfaces import (
     BaseFieldDataSource,
     BaseFieldInfo,
+    FieldBatch,
     FieldDataSource,
-    FieldTransaction,
     PathlinesFieldDataRequest,
     ScalarFieldDataRequest,
     SurfaceDataType,
@@ -51,7 +53,12 @@ from ansys.fluent.core.field_data_interfaces import (
     _AllowedSurfaceNames,
     _AllowedVectorFieldNames,
     _ReturnFieldData,
+    _ScalarFields,
+    _SurfaceIds,
+    _SurfaceNames,
     _to_field_name_str,
+    _VectorFields,
+    get_surfaces_from_objects,
 )
 from ansys.fluent.core.pyfluent_warnings import PyFluentDeprecationWarning
 from ansys.fluent.core.services.interceptors import (
@@ -156,25 +163,7 @@ class FieldDataService(StreamingService):
         return elementss
 
 
-class FieldInfo(BaseFieldInfo):
-    """Provides access to Fluent field information.
-
-    Methods
-    -------
-    get_scalar_field_range(field: str, node_value: bool, surface_ids: List[int])
-    -> List[float]
-        Get the range (minimum and maximum values) of the field.
-
-    get_scalar_fields_info(self) -> dict
-        Get fields information (field name, domain, and section).
-
-    get_vector_fields_info(self) -> dict
-        Get vector fields information.
-
-    get_surfaces_info(self) -> dict
-        Get surfaces information (surface name, ID, and type).
-    """
-
+class _FieldInfo(BaseFieldInfo):
     def __init__(
         self,
         service: FieldDataService,
@@ -201,6 +190,16 @@ class FieldInfo(BaseFieldInfo):
         -------
         List[float]
         """
+        warnings.warn(
+            "This usage is deprecated and will be removed in a future release. "
+            f"Please use 'field_data.scalar_fields.range({field}, {node_value}, {surface_ids})' instead",
+            PyFluentDeprecationWarning,
+        )
+        return self._get_scalar_field_range(field, node_value, surface_ids)
+
+    def _get_scalar_field_range(
+        self, field: str, node_value: bool = False, surface_ids: List[int] = None
+    ) -> List[float]:
         if not surface_ids:
             surface_ids = []
         request = FieldDataProtoModule.GetRangeRequest()
@@ -219,6 +218,14 @@ class FieldInfo(BaseFieldInfo):
         -------
         Dict
         """
+        warnings.warn(
+            "This usage is deprecated and will be removed in a future release. "
+            "Please use 'field_data.scalar_fields()' instead",
+            PyFluentDeprecationWarning,
+        )
+        return self._get_scalar_fields_info()
+
+    def _get_scalar_fields_info(self) -> Dict[str, Dict]:
         request = FieldDataProtoModule.GetFieldsInfoRequest()
         response = self._service.get_scalar_fields_info(request)
         return {
@@ -238,6 +245,14 @@ class FieldInfo(BaseFieldInfo):
         -------
         Dict
         """
+        warnings.warn(
+            "This usage is deprecated and will be removed in a future release. "
+            "Please use 'field_data.vector_fields()' instead",
+            PyFluentDeprecationWarning,
+        )
+        return self._get_vector_fields_info()
+
+    def _get_vector_fields_info(self) -> Dict[str, Dict]:
         request = FieldDataProtoModule.GetVectorFieldsInfoRequest()
         response = self._service.get_vector_fields_info(request)
         return {
@@ -256,6 +271,14 @@ class FieldInfo(BaseFieldInfo):
         -------
         Dict
         """
+        warnings.warn(
+            "This usage is deprecated and will be removed in a future release. "
+            "Please use 'field_data.surfaces()' instead",
+            PyFluentDeprecationWarning,
+        )
+        return self._get_surfaces_info()
+
+    def _get_surfaces_info(self) -> Dict[str, Dict]:
         request = FieldDataProtoModule.GetSurfacesInfoResponse()
         response = self._service.get_surfaces_info(request)
         info = {
@@ -271,20 +294,64 @@ class FieldInfo(BaseFieldInfo):
 
     def validate_scalar_fields(self, field_name: str):
         """Validate scalar fields."""
+        warnings.warn(
+            "This usage is deprecated and will be removed in a future release. "
+            f"Please use 'field_data.scalar_fields.is_active(field_name={field_name})' instead",
+            PyFluentDeprecationWarning,
+        )
         _AllowedScalarFieldNames(
-            self._is_data_valid, info=self.get_scalar_fields_info()
+            self._is_data_valid, info=self._get_scalar_fields_info()
         ).valid_name(field_name)
 
     def validate_vector_fields(self, field_name: str):
         """Validate vector fields."""
+        warnings.warn(
+            "This usage is deprecated and will be removed in a future release. "
+            f"Please use 'field_data.vector_fields.is_active(field_name={field_name})' instead",
+            PyFluentDeprecationWarning,
+        )
         _AllowedVectorFieldNames(
-            self._is_data_valid, info=self.get_vector_fields_info()
+            self._is_data_valid, info=self._get_vector_fields_info()
         ).valid_name(field_name)
 
     def validate_surfaces(self, surfaces: List[str]):
         """Validate surfaces."""
+        warnings.warn(
+            "This usage is deprecated and will be removed in a future release. "
+            f"Please use 'field_data.surfaces.validate(surfaces={surfaces})' instead",
+            PyFluentDeprecationWarning,
+        )
         for surface in surfaces:
-            _AllowedSurfaceNames(info=self.get_surfaces_info()).valid_name(surface)
+            _AllowedSurfaceNames(info=self._get_surfaces_info()).valid_name(surface)
+
+
+class FieldInfo(_FieldInfo):
+    """Provides access to Fluent field information.
+
+    Methods
+    -------
+    get_scalar_field_range(field: str, node_value: bool, surface_ids: List[int])
+    -> List[float]
+        Get the range (minimum and maximum values) of the field.
+
+    get_scalar_fields_info(self) -> dict
+        Get fields information (field name, domain, and section).
+
+    get_vector_fields_info(self) -> dict
+        Get vector fields information.
+
+    get_surfaces_info(self) -> dict
+        Get surfaces information (surface name, ID, and type).
+    """
+
+    def __init__(self, service: FieldDataService, is_data_valid: Callable[[], bool]):
+        """__init__ method of FieldInfo class."""
+        warnings.warn(
+            "'FieldInfo' is deprecated and will be removed in a future release. "
+            "Please use relevant methods from 'FieldData' instead",
+            PyFluentDeprecationWarning,
+        )
+        super().__init__(service, is_data_valid)
 
 
 class _FieldMethod:
@@ -294,6 +361,30 @@ class _FieldMethod:
 
         def allowed_values(self):
             """Returns set of allowed values."""
+            if self._accessor.__class__.__name__ == "_AllowedScalarFieldNames":
+                warnings.warn(
+                    "This usage is deprecated and will be removed in a future release. "
+                    "Please use 'scalar_fields.allowed_values()' instead",
+                    PyFluentDeprecationWarning,
+                )
+            elif self._accessor.__class__.__name__ == "_AllowedVectorFieldNames":
+                warnings.warn(
+                    "This usage is deprecated and will be removed in a future release. "
+                    "Please use 'vector_fields.allowed_values()' instead",
+                    PyFluentDeprecationWarning,
+                )
+            elif self._accessor.__class__.__name__ == "_AllowedSurfaceNames":
+                warnings.warn(
+                    "This usage is deprecated and will be removed in a future release. "
+                    "Please use 'field_data.surfaces.allowed_values()' instead",
+                    PyFluentDeprecationWarning,
+                )
+            elif self._accessor.__class__.__name__ == "_AllowedSurfaceIDs":
+                warnings.warn(
+                    "This usage is deprecated and will be removed in a future release. "
+                    "Please use 'field_data.surface_ids.allowed_values()' instead",
+                    PyFluentDeprecationWarning,
+                )
             return sorted(self._accessor())
 
     def __init__(self, field_data_accessor, args_allowed_values_accessors):
@@ -445,6 +536,7 @@ class BaseFieldData:
             kwargs.get("surfaces"),
             self.get_surface_ids(kwargs.get("surfaces")),
             surface_data,
+            flatten_connectivity=kwargs.get("flatten_connectivity"),
         )
 
     def _get_vector_field_data(
@@ -473,6 +565,7 @@ class BaseFieldData:
             kwargs.get("surfaces"),
             self.get_surface_ids(kwargs.get("surfaces")),
             pathlines_data,
+            flatten_connectivity=kwargs.get("flatten_connectivity"),
         )
 
     def get_field_data(
@@ -484,7 +577,20 @@ class BaseFieldData:
             | PathlinesFieldDataRequest
         ),
     ) -> Dict[int | str, Dict | np.array]:
-        """Get the surface, scalar, vector or path-lines field data on a surface."""
+        """Get the surface, scalar, vector or path-lines field data on a surface.
+
+        Returns
+        -------
+        Dict[int | str, Dict | np.array]
+            Field data for the requested surface. If field data is unavailable for the surface,
+            an empty array is returned and a warning is issued. Users should always check
+            the array size before using the data.
+
+            Example:
+                data = get_field_data(field_data_request)[surface_id]
+                if data.size == 0:
+                    # Handle missing data
+        """
         if isinstance(obj, SurfaceFieldDataRequest):
             return self._get_surface_data(**obj._asdict())
         elif isinstance(obj, ScalarFieldDataRequest):
@@ -495,8 +601,8 @@ class BaseFieldData:
             return self._get_pathlines_field_data(**obj._asdict())
 
 
-class TransactionFieldData(BaseFieldData, BaseFieldDataSource):
-    """Provides access to Fluent field data on surfaces collected via transactions."""
+class BatchFieldData(BaseFieldData, BaseFieldDataSource):
+    """Provides access to Fluent field data on surfaces collected via batches."""
 
     def __init__(
         self,
@@ -505,7 +611,7 @@ class TransactionFieldData(BaseFieldData, BaseFieldDataSource):
         allowed_surface_names,
         allowed_scalar_field_names,
     ):
-        """__init__ method of TransactionFieldData class."""
+        """__init__ method of BatchFieldData class."""
         super().__init__(
             data, field_info, allowed_surface_names, allowed_scalar_field_names
         )
@@ -517,19 +623,19 @@ class TransactionFieldData(BaseFieldData, BaseFieldDataSource):
         return self.data
 
 
-class Transaction(FieldTransaction):
+class Batch(FieldBatch):
     """Populates Fluent field data on surfaces."""
 
     def __init__(
         self,
         service: FieldDataService,
-        field_info: FieldInfo,
+        field_info: _FieldInfo,
         allowed_surface_ids,
         allowed_surface_names,
         allowed_scalar_field_names,
         allowed_vector_field_names,
     ):
-        """__init__ method of Transaction class."""
+        """__init__ method of Batch class."""
         self._service = service
         self._field_info = field_info
         self._fields_request = get_fields_request()
@@ -873,7 +979,7 @@ class Transaction(FieldTransaction):
             self._cache_requests.append(req)
         return self
 
-    def get_fields(self) -> TransactionFieldData:
+    def get_fields(self) -> BatchFieldData:
         """Get data for previously added requests."""
         warnings.warn(
             "'get_fields' is deprecated, use 'get_response' instead",
@@ -881,7 +987,7 @@ class Transaction(FieldTransaction):
         )
         return self.get_response()
 
-    def get_response(self) -> TransactionFieldData:
+    def get_response(self) -> BatchFieldData:
         """Get data for previously added requests.
 
         Returns
@@ -892,7 +998,7 @@ class Transaction(FieldTransaction):
 
             The tag is a tuple for Fluent 2023 R1 or later.
         """
-        return TransactionFieldData(
+        return BatchFieldData(
             ChunkParser().extract_fields(
                 self._service.get_fields(self._fields_request)
             ),
@@ -932,9 +1038,9 @@ class _FieldDataConstants:
 
 
 def _get_surface_ids(
-    field_info: FieldInfo,
+    field_info: _FieldInfo,
     allowed_surface_names,
-    surfaces: List[int | str],
+    surfaces: List[int | str | object],
 ) -> List[int]:
     """Get surface IDs based on surface names or IDs.
 
@@ -948,10 +1054,11 @@ def _get_surface_ids(
     List[int]
     """
     surface_ids = []
-    for surf in surfaces:
+    updated_surfaces = get_surfaces_from_objects(surfaces)
+    for surf in updated_surfaces:
         if isinstance(surf, str):
             surface_ids.extend(
-                field_info.get_surfaces_info()[allowed_surface_names.valid_name(surf)][
+                field_info._get_surfaces_info()[allowed_surface_names.valid_name(surf)][
                     "surface_id"
                 ]
             )
@@ -959,6 +1066,8 @@ def _get_surface_ids(
             allowed_surf_ids = _AllowedSurfaceIDs(field_info)()
             if surf in allowed_surf_ids:
                 surface_ids.append(surf)
+            elif isinstance(surf, Iterable) and not isinstance(surf, (str, bytes)):
+                raise DisallowedValuesError("surface", surf, list(surf))
             else:
                 raise DisallowedValuesError("surface", surf, allowed_surf_ids)
     return surface_ids
@@ -1089,13 +1198,19 @@ class ChunkParser:
                     payload_tag_id = None
             field = None
             if payload_tag_id is not None:
-                field = _extract_field(
-                    _FieldDataConstants.proto_field_type_to_np_data_type[
-                        payload_info.fieldType
-                    ],
-                    payload_info.fieldSize,
-                    chunk_iterator,
-                )
+                if payload_info.fieldSize > 0:
+                    field = _extract_field(
+                        _FieldDataConstants.proto_field_type_to_np_data_type[
+                            payload_info.fieldType
+                        ],
+                        payload_info.fieldSize,
+                        chunk_iterator,
+                    )
+                else:
+                    warnings.warn(
+                        f"Field data is not available for surface: {surface_id}"
+                    )
+                    field = np.array([])
 
             if self._callbacks_provider is not None:
                 for callback_data in self._callbacks_provider.callbacks():
@@ -1257,7 +1372,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
     def __init__(
         self,
         service: FieldDataService,
-        field_info: FieldInfo,
+        field_info: _FieldInfo,
         is_data_valid: Callable[[], bool],
         scheme_eval=None,
         get_zones_info: weakref.WeakMethod[Callable[[], list[ZoneInfo]]] | None = None,
@@ -1327,12 +1442,21 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
             ),
             self.get_pathlines_field_data,
         )
+        self.surfaces = _SurfaceNames(allowed_surface_names=self._allowed_surface_names)
+        self.surface_ids = _SurfaceIds(allowed_surface_ids=self._allowed_surface_ids)
+        self.scalar_fields = _ScalarFields(
+            available_field_names=self._allowed_scalar_field_names,
+            field_info=self._field_info,
+        )
+        self.vector_fields = _VectorFields(
+            available_field_names=self._allowed_vector_field_names
+        )
         self._returned_data = _ReturnFieldData()
         self._fetched_data = _FetchFieldData()
 
-    def new_transaction(self):
-        """Create a new field transaction."""
-        return Transaction(
+    def new_batch(self):
+        """Create a new field batch."""
+        return Batch(
             self._service,
             self._field_info,
             self._allowed_surface_ids,
@@ -1341,6 +1465,11 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
             self._allowed_vector_field_names,
         )
 
+    @deprecated(version="0.34", reason="Use `new_batch` instead.")
+    def new_transaction(self):
+        """Create a new field transaction."""
+        return self.new_batch()
+
     def _get_scalar_field_data(self, **kwargs):
         surfaces = kwargs.get("surfaces")
         surface_ids = self.get_surface_ids(surfaces)
@@ -1385,10 +1514,15 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
                 surface_ids,
                 surface_data,
                 deprecated_flag=True,
+                flatten_connectivity=kwargs.get("flatten_connectivity"),
             )
 
         return self._returned_data._surface_data(
-            kwargs.get("data_types"), kwargs.get("surfaces"), surface_ids, surface_data
+            kwargs.get("data_types"),
+            kwargs.get("surfaces"),
+            surface_ids,
+            surface_data,
+            flatten_connectivity=kwargs.get("flatten_connectivity"),
         )
 
     def _get_vector_field_data(
@@ -1467,6 +1601,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
                 surface_ids,
                 pathlines_data,
                 deprecated_flag=True,
+                flatten_connectivity=kwargs.get("flatten_connectivity"),
             )
 
         return self._returned_data._pathlines_data(
@@ -1474,6 +1609,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
             kwargs.get("surfaces"),
             surface_ids,
             pathlines_data,
+            flatten_connectivity=kwargs.get("flatten_connectivity"),
         )
 
     def get_scalar_field_data(

ansys/fluent/core/services/reduction.py

@@ -21,7 +21,7 @@
 # SOFTWARE.
 
 """Wrappers over Reduction gRPC service of Fluent."""
-
+from collections.abc import Iterable
 from typing import Any, List, Tuple
 import weakref
 
@@ -29,6 +29,7 @@ import grpc
 
 from ansys.api.fluent.v0 import reduction_pb2 as ReductionProtoModule
 from ansys.api.fluent.v0 import reduction_pb2_grpc as ReductionGrpcModule
+from ansys.fluent.core.exceptions import DisallowedValuesError
 from ansys.fluent.core.services.datamodel_se import _convert_variant_to_value
 from ansys.fluent.core.services.interceptors import (
     BatchInterceptor,
@@ -36,6 +37,7 @@ from ansys.fluent.core.services.interceptors import (
     GrpcErrorInterceptor,
     TracingInterceptor,
 )
+from ansys.fluent.core.solver.function.reduction import Weight
 from ansys.fluent.core.variable_strategies import (
     FluentExprNamingStrategy as naming_strategy,
 )
@@ -282,7 +284,7 @@ class Reduction:
         if all(
             loc not in names()
             for names in (
-                self.ctxt.fields.field_info.get_surfaces_info,
+                self.ctxt.fields.field_data.surfaces,
                 self.ctxt.settings.setup.cell_zone_conditions,
             )
         ):
@@ -292,6 +294,8 @@ class Reduction:
         if locations == []:
             return []
         for loc in locations:
+            if isinstance(loc, Iterable) and not isinstance(loc, (str, bytes)):
+                raise DisallowedValuesError("location", loc, list(loc))
             if isinstance(loc, str):
                 self._validate_str_location(loc)
         try:
@@ -312,12 +316,17 @@ class Reduction:
         if expression is not None:
             request.expression = self._to_str(expression)
         if weight is not None:
-            request.weight = weight
+            request.weight = Weight(weight).value
         if condition is not None:
             request.condition = condition
         request.locations.extend(self._get_location_string(locations, ctxt))
         return request
 
+    @property
+    def weight(self):
+        """Weight for calculating sum."""
+        return Weight
+
     def area(self, locations, ctxt=None) -> Any:
         """Get area."""
         request = self._make_request("AreaRequest", locations, ctxt)
@@ -442,13 +451,15 @@ class Reduction:
         response = self.service.moment(request)
         return (response.value.x, response.value.y, response.value.z)
 
-    def sum(self, expression, locations, weight, ctxt=None) -> Any:
+    def sum(self, expression, locations, weight: str | Weight, ctxt=None) -> Any:
         """Get sum."""
         request = self._make_request("SumRequest", locations, ctxt, expression, weight)
         response = self.service.sum(request)
         return _convert_variant_to_value(response.value)
 
-    def sum_if(self, expression, condition, locations, weight, ctxt=None) -> Any:
+    def sum_if(
+        self, expression, condition, locations, weight: str | Weight, ctxt=None
+    ) -> Any:
         """Compute the weighted sum of the expression at locations where the given condition is satisfied."""
         request = self._make_request(
             "SumIfRequest", locations, ctxt, expression, weight, condition

ansys/fluent/core/services/settings.py

@@ -335,6 +335,7 @@ class SettingsService:
         """
         request = SettingsModule.GetStaticInfoRequest()
         request.root = "fluent"
+        request.optional_attrs.append("allowed-values")
         response = self._service_impl.get_static_info(request)
         # The RPC calls no longer raise an exception. Force an exception if
         # type is empty

ansys/fluent/core/session.py

@@ -452,9 +452,18 @@ class BaseSession:
             "field_data_streaming",
             "start_journal",
             "stop_journal",
+            "scheme_eval",
         }
         return sorted(dir_list)
 
+    def enable_beta_features(self):
+        """Enable access to Fluent beta-features"""
+        self._app_utilities.enable_beta()
+
+    @property
+    def _is_beta_enabled(self):
+        return self._app_utilities.is_beta_enabled()
+
 
 class Fields:
     """Container for field and solution variables."""
@@ -468,7 +477,7 @@ class Fields:
         self._is_solution_data_valid = (
             _session._app_utilities.is_solution_data_available
         )
-        self.field_info = service_creator("field_info").create(
+        self._field_info = service_creator("field_info").create(
             _session._field_data_service,
             self._is_solution_data_valid,
         )
@@ -488,3 +497,9 @@ class Fields:
             self._is_solution_data_valid,
             _session.scheme,
         )
+
+    @property
+    @deprecated(version="0.34.0", reason="Use relevant ``field_data`` methods..")
+    def field_info(self):
+        """Field Information."""
+        return self._field_info

ansys/fluent/core/session_pure_meshing.py

@@ -27,6 +27,7 @@ from typing import Any, Dict
 
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.data_model_cache import DataModelCache, NameKey
+from ansys.fluent.core.exceptions import BetaFeaturesNotEnabled
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.services import SchemeEval
 from ansys.fluent.core.session import BaseSession
@@ -175,13 +176,12 @@ class PureMeshing(BaseSession):
 
         Raises
         ------
-        RuntimeError
+        AttributeError
             If beta features are not enabled in Fluent.
         """
-        if not self._app_utilities.is_beta_enabled():
-            raise RuntimeError("Topology-based Meshing is a beta feature in Fluent.")
-        self._base_meshing.topology_based_meshing_workflow.initialize()
-        return self._base_meshing.topology_based_meshing_workflow
+        if not self._is_beta_enabled:
+            raise BetaFeaturesNotEnabled("Topology-based meshing")
+        return self._base_meshing.topology_based_meshing_workflow()
 
     @property
     def PartManagement(self):

ansys/fluent/core/session_pure_meshing.pyi

@@ -66,3 +66,4 @@ class PureMeshing:
         clean_up_mesh_file: bool = ...,
         overwrite_previous: bool = ...,
     ): ...
+    def enable_beta_features(self): ...

ansys/fluent/core/session_solver.py

@@ -30,6 +30,7 @@ import weakref
 
 from ansys.api.fluent.v0 import svar_pb2 as SvarProtoModule
 import ansys.fluent.core as pyfluent
+from ansys.fluent.core.exceptions import BetaFeaturesNotEnabled
 from ansys.fluent.core.pyfluent_warnings import PyFluentDeprecationWarning
 from ansys.fluent.core.services import SchemeEval, service_creator
 from ansys.fluent.core.services.field_data import ZoneInfo, ZoneType
@@ -353,16 +354,40 @@ class Solver(BaseSession):
                 raise ex
 
     def __dir__(self):
-        if self._fluent_connection is None:
-            return ["is_active"]
-        dir_list = set(list(self.__dict__.keys()) + dir(type(self))) - {
+        dir_list = set(super().__dir__()) - {
             "svar_data",
             "svar_info",
             "reduction",
-            "field_data",
-            "field_info",
-            "field_data_streaming",
-            "start_journal",
-            "stop_journal",
         }
         return sorted(dir_list)
+
+    def switch_to_meshing(self):
+        """Switch to meshing mode and return a meshing session object. Deactivate this
+        object's public interface and streaming services.
+
+        Raises
+        ------
+        AttributeError
+            If beta features are not enabled in Fluent.
+
+        Returns
+        -------
+        Meshing
+        """
+        if not self._is_beta_enabled:
+            raise BetaFeaturesNotEnabled("switch_to_meshing")
+        from ansys.fluent.core.session_meshing import Meshing
+
+        self.settings.switch_to_meshing_mode()
+        for cb in self._fluent_connection.finalizer_cbs:
+            cb()
+        meshing_session = Meshing(
+            fluent_connection=self._fluent_connection,
+            scheme_eval=self.scheme,
+            file_transfer_service=self._file_transfer_service,
+        )
+        self._fluent_connection = None
+        self.__doc__ = (
+            "The solver session is no longer usable after switching to meshing mode."
+        )
+        return meshing_session

ansys/fluent/core/session_solver.pyi

@@ -44,3 +44,4 @@ class Solver:
     def write_case(self, file_name: str): ...
     @property
     def settings(self) -> settings_root.root: ...
+    def enable_beta_features(self): ...