ansys-fluent-core 0.34.dev0__py3-none-any.whl → 0.35.dev0__py3-none-any.whl

ansys/fluent/core/file_session.py

@@ -25,14 +25,15 @@
 from typing import Dict, List
 import warnings
 
+from deprecated.sphinx import deprecated
 import numpy as np
 
 from ansys.api.fluent.v0.field_data_pb2 import DataLocation
 from ansys.fluent.core import PyFluentDeprecationWarning
 from ansys.fluent.core.field_data_interfaces import (
     BaseFieldInfo,
+    FieldBatch,
     FieldDataSource,
-    FieldTransaction,
     PathlinesFieldDataRequest,
     ScalarFieldDataRequest,
     SurfaceDataType,
@@ -41,6 +42,11 @@ from ansys.fluent.core.field_data_interfaces import (
     _AllowedScalarFieldNames,
     _AllowedSurfaceNames,
     _ReturnFieldData,
+    _ScalarFields,
+    _SurfaceIds,
+    _SurfaceNames,
+    _transform_faces_connectivity_data,
+    _VectorFields,
 )
 from ansys.fluent.core.filereader.case_file import CaseFile
 from ansys.fluent.core.filereader.data_file import (
@@ -81,8 +87,8 @@ def _data_type_convertor(args_dict):
     return args_dict
 
 
-class TransactionFieldData:
-    """Provides access to Fluent field data on surfaces collected via transactions."""
+class BatchFieldData:
+    """Provides access to Fluent field data on surfaces collected via batches."""
 
     def __init__(
         self,
@@ -91,7 +97,7 @@ class TransactionFieldData:
         allowed_surface_names,
         allowed_scalar_field_names,
     ):
-        """__init__ method of TransactionFieldData class."""
+        """__init__ method of BatchFieldData class."""
         self.data = data
         self._field_info = field_info
         self._allowed_surface_names = allowed_surface_names
@@ -133,6 +139,7 @@ class TransactionFieldData:
             kwargs.get("surfaces"),
             self.get_surface_ids(kwargs.get("surfaces")),
             surface_data,
+            flatten_connectivity=kwargs.get("flatten_connectivity"),
         )
 
     def _get_vector_field_data(
@@ -179,7 +186,20 @@ class TransactionFieldData:
             | 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):
@@ -196,7 +216,7 @@ class TransactionFieldData:
         return self.data
 
 
-class Transaction(FieldTransaction):
+class Batch(FieldBatch):
     """Populates field data on surfaces."""
 
     class _SurfaceTransaction:
@@ -218,10 +238,10 @@ class Transaction(FieldTransaction):
             self.surface_ids = surface_ids
 
     def __init__(self, file_session, field_info):
-        """__init__ method of Transaction class."""
-        self._surface_transactions = []
-        self._scalar_field_transactions = []
-        self._vector_field_transactions = []
+        """__init__ method of Batch class."""
+        self._surface_batches = []
+        self._scalar_field_batches = []
+        self._vector_field_batches = []
         self._file_session = file_session
         self._field_info = field_info
         self._cache_requests = []
@@ -287,10 +307,8 @@ class Transaction(FieldTransaction):
         provide_vertices = SurfaceDataType.Vertices in data_types
         provide_faces = SurfaceDataType.FacesConnectivity in data_types
         for surface_id in self.get_surface_ids(surfaces):
-            self._surface_transactions.append(
-                Transaction._SurfaceTransaction(
-                    surface_id, provide_vertices, provide_faces
-                )
+            self._surface_batches.append(
+                Batch._SurfaceTransaction(surface_id, provide_vertices, provide_faces)
             )
 
     @all_deprecators(
@@ -360,14 +378,14 @@ class Transaction(FieldTransaction):
         if len(self._file_session._data_file.get_phases()) > 1:
             if not field_name.startswith("phase-"):
                 raise InvalidMultiPhaseFieldName()
-            self._scalar_field_transactions.append(
-                Transaction._ScalarFieldTransaction(
+            self._scalar_field_batches.append(
+                Batch._ScalarFieldTransaction(
                     field_name, surface_ids, field_name.split(":")[0]
                 )
             )
         else:
-            self._scalar_field_transactions.append(
-                Transaction._ScalarFieldTransaction(field_name, surface_ids)
+            self._scalar_field_batches.append(
+                Batch._ScalarFieldTransaction(field_name, surface_ids)
             )
 
     @all_deprecators(
@@ -422,14 +440,14 @@ class Transaction(FieldTransaction):
         if len(self._file_session._data_file.get_phases()) > 1:
             if not field_name.startswith("phase-"):
                 raise InvalidMultiPhaseFieldName()
-            self._vector_field_transactions.append(
-                Transaction._VectorFieldTransaction(
+            self._vector_field_batches.append(
+                Batch._VectorFieldTransaction(
                     field_name, surface_ids, field_name.split(":")[0]
                 )
             )
         else:
-            self._vector_field_transactions.append(
-                Transaction._VectorFieldTransaction(field_name, surface_ids)
+            self._vector_field_batches.append(
+                Batch._VectorFieldTransaction(field_name, surface_ids)
             )
 
     @all_deprecators(
@@ -503,14 +521,14 @@ class Transaction(FieldTransaction):
                 )
             elif isinstance(req, ScalarFieldDataRequest):
                 self._add_scalar_fields_request(
-                    field_name=req.field_name,
+                    field_name=_to_scalar_field_name(req.field_name),
                     surfaces=req.surfaces,
                     node_value=req.node_value,
                     boundary_value=req.boundary_value,
                 )
             elif isinstance(req, VectorFieldDataRequest):
                 self._add_vector_fields_request(
-                    field_name=req.field_name,
+                    field_name=_to_vector_field_name(req.field_name),
                     surfaces=req.surfaces,
                 )
             elif isinstance(req, PathlinesFieldDataRequest):
@@ -555,47 +573,47 @@ class Transaction(FieldTransaction):
             ("boundaryValues", False),
         )
 
-        for transaction in self._scalar_field_transactions:
+        for batch in self._scalar_field_batches:
             if scalar_field_tag not in field_data:
                 field_data[scalar_field_tag] = {}
             field_data_surface = field_data[scalar_field_tag]
-            for surface_id in transaction.surface_ids:
+            for surface_id in batch.surface_ids:
                 field_data_surface[surface_id] = {}
-                field_data_surface[surface_id][transaction.field_name] = (
+                field_data_surface[surface_id][batch.field_name] = (
                     self._file_session._data_file.get_face_scalar_field_data(
-                        transaction.phase_name, transaction.field_name, surface_id
+                        batch.phase_name, batch.field_name, surface_id
                     )
                 )
 
         vector_field_tag = (("type", "vector-field"),)
 
-        for transaction in self._vector_field_transactions:
-            if "velocity" not in transaction.field_name:
+        for batch in self._vector_field_batches:
+            if "velocity" not in batch.field_name:
                 raise InvalidFieldName()
             if vector_field_tag not in field_data:
                 field_data[vector_field_tag] = {}
             field_data_surface = field_data[vector_field_tag]
-            for surface_id in transaction.surface_ids:
+            for surface_id in batch.surface_ids:
                 field_data_surface[surface_id] = {}
-                field_data_surface[surface_id][transaction.field_name] = (
+                field_data_surface[surface_id][batch.field_name] = (
                     self._file_session._data_file.get_face_vector_field_data(
-                        transaction.phase_name, surface_id
+                        batch.phase_name, surface_id
                     )
                 )
                 field_data_surface[surface_id]["vector-scale"] = np.array([0.1])
 
-        for transaction in self._surface_transactions:
+        for batch in self._surface_batches:
             if (("type", "surface-data"),) not in field_data:
                 field_data[(("type", "surface-data"),)] = {}
             field_data_surface = field_data[(("type", "surface-data"),)]
-            field_data_surface[transaction.surface_id] = {}
-            field_data_surface[transaction.surface_id]["faces"] = mesh.get_connectivity(
-                transaction.surface_id
+            field_data_surface[batch.surface_id] = {}
+            field_data_surface[batch.surface_id]["faces"] = mesh.get_connectivity(
+                batch.surface_id
             )
-            field_data_surface[transaction.surface_id]["vertices"] = mesh.get_vertices(
-                transaction.surface_id
+            field_data_surface[batch.surface_id]["vertices"] = mesh.get_vertices(
+                batch.surface_id
             )
-        return TransactionFieldData(
+        return BatchFieldData(
             field_data,
             self._field_info,
             _AllowedSurfaceNames(self._field_info),
@@ -610,10 +628,29 @@ class FileFieldData(FieldDataSource):
         """Initialize FileFieldData."""
         self._file_session = file_session
         self._field_info = field_info
+        self.scalar_fields = _ScalarFields(
+            self._field_info._get_scalar_fields_info, self._field_info
+        )
+        self.vector_fields = _VectorFields(self._field_info._get_vector_fields_info)
+        self.surfaces = _SurfaceNames(self._field_info._get_surfaces_info)
+
+    @property
+    def surface_ids(self):
+        """Get the surface ids."""
+        return _SurfaceIds(
+            _get_surface_ids(
+                self._field_info, list(self._field_info._get_surfaces_info())
+            )
+        )
+
+    def new_batch(self):
+        """Create a new field batch."""
+        return Batch(self._file_session, self._field_info)
 
+    @deprecated(version="0.34", reason="Use `new_batch` instead.")
     def new_transaction(self):
         """Create a new field transaction."""
-        return Transaction(self._file_session, self._field_info)
+        return self.new_batch()
 
     def get_surface_ids(self, surfaces: List[str | int]) -> List[int]:
         """Get a list of surface ids based on surfaces provided as inputs."""
@@ -650,6 +687,7 @@ class FileFieldData(FieldDataSource):
         data_types: List[SurfaceDataType] | List[str],
         surfaces: List[int | str],
         overset_mesh: bool | None = False,
+        flatten_connectivity: bool = False,
     ):
         """Get surface data (vertices and faces connectivity).
 
@@ -661,6 +699,8 @@ class FileFieldData(FieldDataSource):
             List of surface IDS or surface names for the surface data.
         overset_mesh : bool, optional
             Whether to provide the overset method. The default is ``False``.
+        flatten_connectivity: bool, optional
+            Whether to provide faces connectivity data in flattened format.
 
         Returns
         -------
@@ -673,6 +713,7 @@ class FileFieldData(FieldDataSource):
             data_types=data_types,
             surfaces=surfaces,
             overset_mesh=overset_mesh,
+            flatten_connectivity=flatten_connectivity,
         )
 
     def _get_surface_data(
@@ -680,6 +721,7 @@ class FileFieldData(FieldDataSource):
         data_types: List[SurfaceDataType] | List[str],
         surfaces: List[int | str],
         overset_mesh: bool | None = False,
+        flatten_connectivity: bool = False,
     ):
         for d_type in data_types:
             if isinstance(d_type, str):
@@ -697,24 +739,28 @@ class FileFieldData(FieldDataSource):
             }
 
         if SurfaceDataType.FacesConnectivity in data_types:
-            return {
-                surface: self._get_faces_connectivity_data(
-                    self._file_session._case_file.get_mesh().get_connectivity(
+            if flatten_connectivity:
+                return {
+                    surface: self._file_session._case_file.get_mesh().get_connectivity(
                         surface_ids[count]
                     )
+                    for count, surface in enumerate(surfaces)
+                }
+            else:
+                warnings.warn(
+                    "Structured face connectivity output is deprecated and will be replaced by the flat format "
+                    "in a future release. In the current release, pass 'flatten_connectivity=True' argument while creating the "
+                    "'SurfaceFieldDataRequest' to request data in the flat format.",
+                    PyFluentDeprecationWarning,
                 )
-                for count, surface in enumerate(surfaces)
-            }
-
-    @staticmethod
-    def _get_faces_connectivity_data(data):
-        faces_data = []
-        i = 0
-        while i < len(data):
-            end = i + 1 + data[i]
-            faces_data.append(data[i + 1 : end])
-            i = end
-        return faces_data
+                return {
+                    surface: _transform_faces_connectivity_data(
+                        self._file_session._case_file.get_mesh().get_connectivity(
+                            surface_ids[count]
+                        )
+                    )
+                    for count, surface in enumerate(surfaces)
+                }
 
     @all_deprecators(
         deprecate_arg_mappings=[
@@ -940,7 +986,20 @@ class FileFieldData(FieldDataSource):
             | 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):
@@ -951,11 +1010,11 @@ class FileFieldData(FieldDataSource):
             return self._get_pathlines_field_data(**obj._asdict())
 
 
-class FileFieldInfo((BaseFieldInfo)):
+class _FileFieldInfo(BaseFieldInfo):
     """File field info."""
 
     def __init__(self, file_session):
-        """Initialize FileFieldInfo."""
+        """Initialize _FileFieldInfo."""
         self._file_session = file_session
 
     def get_scalar_field_range(
@@ -975,6 +1034,16 @@ class FileFieldInfo((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]:
         minimum = None
         maximum = None
         if not surface_ids:
@@ -997,6 +1066,14 @@ class FileFieldInfo((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):
         phases = self._file_session._data_file.get_phases()
 
         scalar_field_info = {}
@@ -1032,6 +1109,14 @@ class FileFieldInfo((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):
         phases = self._file_session._data_file.get_phases()
 
         if len(phases) > 1:
@@ -1061,6 +1146,14 @@ class FileFieldInfo((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):
         mesh = self._file_session._case_file.get_mesh()
         surface_names = mesh.get_surface_names()
         surface_ids = mesh.get_surface_ids()
@@ -1076,6 +1169,19 @@ class FileFieldInfo((BaseFieldInfo)):
         return info
 
 
+class FileFieldInfo(_FileFieldInfo):
+    """File field info."""
+
+    def __init__(self, file_session):
+        """Initialize FileFieldInfo"""
+        warnings.warn(
+            "'FieldInfo' is deprecated and will be removed in a future release. "
+            "Please use relevant methods from 'FieldData' instead",
+            PyFluentDeprecationWarning,
+        )
+        super().__init__(file_session)
+
+
 class FileSession:
     """File session to read case and data file."""
 
@@ -1141,7 +1247,7 @@ def _get_surface_ids(
     surface_ids = []
     for surf in surfaces:
         if isinstance(surf, str):
-            surface_ids.extend(field_info.get_surfaces_info()[surf]["surface_id"])
+            surface_ids.extend(field_info._get_surfaces_info()[surf]["surface_id"])
         else:
             surface_ids.append(surf)
     return surface_ids
@@ -1152,5 +1258,5 @@ class Fields:
 
     def __init__(self, _session: FileSession):
         """Initialize Fields."""
-        self.field_info = FileFieldInfo(_session)
+        self.field_info = _FileFieldInfo(_session)
         self.field_data = FileFieldData(_session, self.field_info)

ansys/fluent/core/fluent_connection.py

@@ -42,11 +42,12 @@ from deprecated.sphinx import deprecated
 import grpc
 
 import ansys.fluent.core as pyfluent
-from ansys.fluent.core.launcher.launcher_utils import is_compose
+from ansys.fluent.core.launcher.launcher_utils import ComposeConfig
 from ansys.fluent.core.services import service_creator
 from ansys.fluent.core.services.app_utilities import (
     AppUtilitiesOld,
     AppUtilitiesService,
+    AppUtilitiesV252,
 )
 from ansys.fluent.core.services.scheme_eval import SchemeEvalService
 from ansys.fluent.core.utils.execution import timeout_exec, timeout_loop
@@ -251,9 +252,9 @@ class FluentConnectionProperties:
 
 def _get_ip_and_port(ip: str | None = None, port: int | None = None) -> (str, int):
     if not ip:
-        ip = os.getenv("PYFLUENT_FLUENT_IP", "127.0.0.1")
+        ip = pyfluent.config.launch_fluent_ip or "127.0.0.1"
     if not port:
-        port = os.getenv("PYFLUENT_FLUENT_PORT")
+        port = pyfluent.config.launch_fluent_port
     if not port:
         raise PortNotProvided()
     return ip, port
@@ -277,18 +278,22 @@ class _ConnectionInterface:
         self.scheme_eval = service_creator("scheme_eval").create(
             self._scheme_eval_service
         )
-        if (
-            pyfluent.FluentVersion(self.scheme_eval.version)
-            < pyfluent.FluentVersion.v252
-        ):
-            self._app_utilities = AppUtilitiesOld(self.scheme_eval)
-        else:
-            self._app_utilities_service = create_grpc_service(
-                AppUtilitiesService, error_state
-            )
-            self._app_utilities = service_creator("app_utilities").create(
-                self._app_utilities_service
-            )
+        self._app_utilities_service = create_grpc_service(
+            AppUtilitiesService, error_state
+        )
+        match pyfluent.FluentVersion(self.scheme_eval.version):
+            case v if v < pyfluent.FluentVersion.v252:
+                self._app_utilities = AppUtilitiesOld(self.scheme_eval)
+
+            case pyfluent.FluentVersion.v252:
+                self._app_utilities = AppUtilitiesV252(
+                    self._app_utilities_service, self.scheme_eval
+                )
+
+            case _:
+                self._app_utilities = service_creator("app_utilities").create(
+                    self._app_utilities_service
+                )
 
     @property
     def product_build_info(self) -> str:
@@ -376,6 +381,7 @@ class FluentConnection:
         slurm_job_id: str | None = None,
         inside_container: bool | None = None,
         container: ContainerT | None = None,
+        compose_config: ComposeConfig | None = None,
     ):
         """Initialize a Session.
 
@@ -415,12 +421,15 @@ class FluentConnection:
         container: ContainerT, optional
             The container instance if the Fluent session is running inside
             a container.
+        compose_config: ComposeConfig, optional
+            Configuration for Docker Compose or Podman Compose.
 
         Raises
         ------
         PortNotProvided
             If port is not provided.
         """
+        self._compose_config = compose_config if compose_config else ComposeConfig()
         self._error_state = ErrorState()
         self._data_valid = False
         self._channel_str = None
@@ -442,7 +451,7 @@ class FluentConnection:
         # At this point, the server must be running. If the following check_health()
         # throws, we should not proceed.
         # TODO: Show user-friendly error message.
-        if pyfluent.CHECK_HEALTH:
+        if pyfluent.config.check_health:
             self._health_check.check_health()
 
         self._slurm_job_id = slurm_job_id
@@ -467,7 +476,7 @@ class FluentConnection:
             and cortex_host is not None
         ):
             logger.info("Checking if Fluent is running inside a container.")
-            if not is_compose():
+            if not self._compose_config.is_compose:
                 inside_container = get_container(cortex_host)
                 logger.debug(f"get_container({cortex_host}): {inside_container}")
             if inside_container is False:
@@ -544,7 +553,10 @@ class FluentConnection:
         >>> session = pyfluent.launch_fluent()
         >>> session.force_exit()
         """
-        if self.connection_properties.inside_container or is_compose():
+        if (
+            self.connection_properties.inside_container
+            or self._compose_config.is_compose
+        ):
             self._force_exit_container()
         elif self._remote_instance is not None:
             logger.error("Cannot execute cleanup script, Fluent running remotely.")
@@ -596,7 +608,7 @@ class FluentConnection:
     def _force_exit_container(self):
         """Immediately terminates the Fluent client running inside a container, losing
         unsaved progress and data."""
-        if is_compose() and self._container:
+        if self._compose_config.is_compose and self._container:
             self._container.stop()
         else:
             container = self.connection_properties.inside_container
@@ -674,7 +686,10 @@ class FluentConnection:
         else:
             raise WaitTypeError()
 
-        if self.connection_properties.inside_container and not is_compose():
+        if (
+            self.connection_properties.inside_container
+            and not self._compose_config.is_compose
+        ):
             _response = timeout_loop(
                 get_container,
                 wait,
@@ -743,16 +758,16 @@ class FluentConnection:
             )
 
         if timeout is None:
-            env_timeout = os.getenv("PYFLUENT_TIMEOUT_FORCE_EXIT")
-
-            if env_timeout:
-                logger.debug("Found PYFLUENT_TIMEOUT_FORCE_EXIT env var")
+            config_timeout = pyfluent.config.force_exit_timeout
+            if config_timeout is not None:
+                logger.debug(f"Found force_exit_timeout config: '{config_timeout}'")
                 try:
-                    timeout = float(env_timeout)
+                    timeout = float(config_timeout)
                     logger.debug(f"Setting TIMEOUT_FORCE_EXIT to {timeout}")
                 except ValueError:
                     logger.debug(
-                        "Off or unrecognized PYFLUENT_TIMEOUT_FORCE_EXIT value, not enabling timeout force exit"
+                        "Invalid force_exit_timeout config. Must be a float or int. "
+                        "Timeout forced exit is disabled."
                     )
 
         if timeout is None: