ansys-fluent-core 0.34.dev0__py3-none-any.whl → 0.35.dev0__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/health_check.py

@@ -80,7 +80,9 @@ class HealthCheckService:
         """
         request = HealthCheckModule.HealthCheckRequest()
         response = self._stub.Check(
-            request, metadata=self._metadata, timeout=pyfluent.CHECK_HEALTH_TIMEOUT
+            request,
+            metadata=self._metadata,
+            timeout=pyfluent.config.check_health_timeout,
         )
         return HealthCheckService.Status(response.status)
 

ansys/fluent/core/services/interceptors.py

@@ -24,7 +24,6 @@
 
 import builtins
 import logging
-import os
 from typing import Any
 
 from google.protobuf.json_format import MessageToDict
@@ -34,8 +33,6 @@ import grpc
 from ansys.fluent.core.services.batch_ops import BatchOps
 
 network_logger: logging.Logger = logging.getLogger("pyfluent.networking")
-log_bytes_limit: int = int(os.getenv("PYFLUENT_GRPC_LOG_BYTES_LIMIT", 1000))
-truncate_len: int = log_bytes_limit // 5
 
 
 def _upper_snake_case_to_camel_case(name: str) -> str:
@@ -43,14 +40,17 @@ def _upper_snake_case_to_camel_case(name: str) -> str:
 
 
 def _truncate_grpc_str(message: Message) -> str:
+    from ansys.fluent.core import config
+
+    truncate_len = config.grpc_log_bytes_limit // 5
     message_bytes = message.ByteSize()
     message_str = str(MessageToDict(message))
-    if not log_bytes_limit or message_bytes < log_bytes_limit:
+    if not config.grpc_log_bytes_limit or message_bytes < config.grpc_log_bytes_limit:
         return message_str
     else:
         network_logger.debug(
             f"GRPC_TRACE: message partially hidden, {message_bytes} bytes > "
-            f"{log_bytes_limit} bytes limit. To see the full message, set PYFLUENT_GRPC_LOG_BYTES_LIMIT to 0."
+            f"{config.grpc_log_bytes_limit} bytes limit. To see the full message, set PYFLUENT_GRPC_LOG_BYTES_LIMIT to 0."
         )
         return f"{message_str[:truncate_len]} < ... > {message_str[-truncate_len:]}"
 
@@ -68,6 +68,8 @@ class TracingInterceptor(grpc.UnaryUnaryClientInterceptor):
         client_call_details: grpc.ClientCallDetails,
         request: Any,
     ) -> Any:
+        from ansys.fluent.core import config
+
         network_logger.debug(
             f"GRPC_TRACE: RPC = {client_call_details.method}, request = {_truncate_grpc_str(request)}"
         )
@@ -75,7 +77,7 @@ class TracingInterceptor(grpc.UnaryUnaryClientInterceptor):
         if not response.exception():
             # call _truncate_grpc_str early to get the size warning even when hiding secrets
             response_str = _truncate_grpc_str(response.result())
-            if os.getenv("PYFLUENT_HIDE_LOG_SECRETS") != "1":
+            if not config.hide_log_secrets:
                 network_logger.debug(f"GRPC_TRACE: response = {response_str}")
         return response
 

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