ansys-fluent-core 0.28.2__py3-none-any.whl → 0.29.dev1__py3-none-any.whl

ansys/fluent/core/launcher/fluent_container.py

@@ -239,16 +239,23 @@ def configure_container_dict(
     logger.warning(
         f"Starting Fluent container mounted to {mount_source}, with this path available as {mount_target} for the Fluent session running inside the container."
     )
-
-    if not port and "ports" in container_dict:
+    port_mapping = {port: port} if port else {}
+    if not port_mapping and "ports" in container_dict:
         # take the specified 'port', OR the first port value from the specified 'ports', for Fluent to use
-        port = next(iter(container_dict["ports"].values()))
-    if not port and pyfluent.LAUNCH_FLUENT_PORT:
+        port_mapping = container_dict["ports"]
+    if not port_mapping and pyfluent.LAUNCH_FLUENT_PORT:
         port = pyfluent.LAUNCH_FLUENT_PORT
-    if not port:
+        port_mapping = {port: port}
+    if not port_mapping:
         port = get_free_port()
+        port_mapping = {port: port}
 
-    container_dict.update(ports={str(port): port})  # container port : host port
+    container_dict.update(
+        ports={str(x): y for x, y in port_mapping.items()}
+    )  # container port : host port
+    container_grpc_port = next(
+        iter(port_mapping.values())
+    )  # the first port in the mapping is chosen as the gRPC port
 
     if "environment" not in container_dict:
         if not license_server:
@@ -259,7 +266,7 @@ def configure_container_dict(
         container_dict.update(
             environment={
                 "ANSYSLMD_LICENSE_FILE": license_server,
-                "REMOTING_PORTS": f"{port}/portspan=2",
+                "REMOTING_PORTS": f"{container_grpc_port}/portspan=2",
             }
         )
 
@@ -319,16 +326,10 @@ def configure_container_dict(
             container_dict["environment"] = {}
         container_dict["environment"]["FLUENT_NO_AUTOMATIC_TRANSCRIPT"] = "1"
 
-    if (
-        os.getenv("REMOTING_NEW_DM_API") == "1"
-        or os.getenv("REMOTING_MAPPED_NEW_DM_API") == "1"
-    ):
+    if os.getenv("REMOTING_NEW_DM_API") == "1":
         if "environment" not in container_dict:
             container_dict["environment"] = {}
-        if os.getenv("REMOTING_NEW_DM_API") == "1":
-            container_dict["environment"]["REMOTING_NEW_DM_API"] = "1"
-        if os.getenv("REMOTING_MAPPED_NEW_DM_API") == "1":
-            container_dict["environment"]["REMOTING_MAPPED_NEW_DM_API"] = "1"
+        container_dict["environment"]["REMOTING_NEW_DM_API"] = "1"
 
     if pyfluent.LAUNCH_FLUENT_IP or os.getenv("REMOTING_SERVER_ADDRESS"):
         if "environment" not in container_dict:
@@ -360,7 +361,7 @@ def configure_container_dict(
     return (
         container_dict,
         timeout,
-        port,
+        container_grpc_port,
         host_server_info_file,
         remove_server_info_file,
     )
@@ -368,7 +369,7 @@ def configure_container_dict(
 
 def start_fluent_container(
     args: List[str], container_dict: dict | None = None
-) -> (int, str):
+) -> tuple[int, str, Any]:
     """Start a Fluent container.
 
     Parameters
@@ -439,7 +440,9 @@ def start_fluent_container(
 
         logger.debug("Starting Fluent docker container...")
 
-        docker_client.containers.run(config_dict.pop("fluent_image"), **config_dict)
+        container = docker_client.containers.run(
+            config_dict.pop("fluent_image"), **config_dict
+        )
 
         success = timeout_loop(
             lambda: host_server_info_file.stat().st_mtime > last_mtime, timeout
@@ -452,7 +455,7 @@ def start_fluent_container(
         else:
             _, _, password = _parse_server_info_file(str(host_server_info_file))
 
-            return port, password
+            return port, password, container
     finally:
         if remove_server_info_file and host_server_info_file.exists():
             host_server_info_file.unlink()

ansys/fluent/core/launcher/launcher.py

@@ -130,8 +130,8 @@ def launch_fluent(
     Parameters
     ----------
     product_version : FluentVersion or str or float or int, optional
-        Version of Ansys Fluent to launch. To use Fluent version 2024 R2, pass
-        any of  ``FluentVersion.v242``, ``"24.2.0"``, ``"24.2"``, ``24.2``or ``242``.
+        Version of Ansys Fluent to launch. To use Fluent version 2025 R1, pass
+        any of  ``FluentVersion.v251``, ``"25.1.0"``, ``"25.1"``, ``25.1``or ``251``.
         The default is ``None``, in which case the newest installed version is used.
     dimension : Dimension or int, optional
         Geometric dimensionality of the Fluent simulation. The default is ``None``,

ansys/fluent/core/launcher/pim_launcher.py

@@ -76,8 +76,8 @@ class PIMLauncher:
             ``FluentWindowsGraphicsDriver`` enum in Windows or the values of the
             ``FluentLinuxGraphicsDriver`` enum in Linux.
         product_version : FluentVersion or str or float or int, optional
-            Version of Ansys Fluent to launch. To use Fluent version 2024 R2, pass
-           ``FluentVersion.v242``, ``"24.2.0"``, ``"24.2"``, ``24.2``, or ``242``.
+            Version of Ansys Fluent to launch. To use Fluent version 2025 R1, pass
+           ``FluentVersion.v251``, ``"25.1.0"``, ``"25.1"``, ``25.1``, or ``251``.
             The default is ``None``, in which case the newest installed version is used.
         dimension : Dimension or int, optional
             Geometric dimensionality of the Fluent simulation. The default is ``None``,

ansys/fluent/core/launcher/slurm_launcher.py

@@ -301,8 +301,8 @@ class SlurmLauncher:
             ``FluentWindowsGraphicsDriver`` enum in Windows or the values of the
             ``FluentLinuxGraphicsDriver`` enum in Linux.
         product_version : FluentVersion or str or float or int, optional
-            Version of Ansys Fluent to launch. To use Fluent version 2024 R2, pass
-            ``FluentVersion.v242``, ``"24.2.0"``, ``"24.2"``, ``24.2``, or ``242``.
+            Version of Ansys Fluent to launch. To use Fluent version 2025 R1, pass
+            ``FluentVersion.v251``, ``"25.1.0"``, ``"25.1"``, ``25.1``, or ``251``.
             The default is ``None``, in which case the newest installed version is used.
         dimension : Dimension or int, optional
             Geometric dimensionality of the Fluent simulation. The default is ``None``,

ansys/fluent/core/launcher/standalone_launcher.py

@@ -96,8 +96,8 @@ class StandaloneLauncher:
             ``FluentWindowsGraphicsDriver`` enum in Windows or the values of the
             ``FluentLinuxGraphicsDriver`` enum in Linux.
         product_version : FluentVersion or str or float or int, optional
-            Version of Ansys Fluent to launch. To use Fluent version 2024 R2, pass
-           ``FluentVersion.v242``, ``"24.2.0"``, ``"24.2"``, ``24.2``, or ``242``.
+            Version of Ansys Fluent to launch. To use Fluent version 2025 R1, pass
+           ``FluentVersion.v251``, ``"25.1.0"``, ``"25.1"``, ``25.1``, or ``251``.
             The default is ``None``, in which case the newest installed version is used.
         dimension : Dimension or int, optional
             Geometric dimensionality of the Fluent simulation. The default is ``None``,

ansys/fluent/core/logging.py

@@ -61,6 +61,8 @@ def get_default_config() -> dict:
                                     'maxBytes': 10485760}},
      'loggers': {'pyfluent.datamodel': {'handlers': ['pyfluent_file'],
                                         'level': 'DEBUG'},
+                 'pyfluent.field_data': {'handlers': ['pyfluent_file'],
+                                         'level': 'DEBUG'},
                  'pyfluent.general': {'handlers': ['pyfluent_file'],
                                       'level': 'DEBUG'},
                  'pyfluent.launcher': {'handlers': ['pyfluent_file'],

ansys/fluent/core/logging_config.yaml

@@ -43,3 +43,6 @@ loggers:
   pyfluent.post_objects:
     level: DEBUG
     handlers: [pyfluent_file]
+  pyfluent.field_data:
+    level: DEBUG
+    handlers: [pyfluent_file]

ansys/fluent/core/services/datamodel_se.py

@@ -176,6 +176,8 @@ class DatamodelServiceImpl:
         self._stub = DataModelGrpcModule.DataModelStub(intercept_channel)
         self._metadata = metadata
         self.file_transfer_service = file_transfer_service
+        if os.getenv("REMOTING_MAPPED_NEW_DM_API") == "1":
+            self._metadata.append(("mapped", "1"))
 
     # TODO: Remove it from the proto interface
     def initialize_datamodel(
@@ -1969,7 +1971,8 @@ class PyCommand:
                 id,
                 static_info.get("args"),
             )
-        except RuntimeError:
+        # Possible error thrown from the grpc layer
+        except (RuntimeError, ValueError):
             logger.warning(
                 "Create command arguments object is available from 23.1 onwards"
             )

ansys/fluent/core/services/field_data.py

@@ -1,8 +1,12 @@
 """Wrappers over FieldData gRPC service of Fluent."""
 
+from dataclasses import dataclass, field
 from enum import Enum
 from functools import reduce
+import logging
+import time
 from typing import Callable, Dict, List, Tuple
+import weakref
 
 import grpc
 import numpy as np
@@ -19,6 +23,8 @@ from ansys.fluent.core.services.interceptors import (
 from ansys.fluent.core.services.streaming import StreamingService
 from ansys.fluent.core.utils.deprecate import deprecate_argument, deprecate_arguments
 
+logger = logging.getLogger("pyfluent.field_data")
+
 
 def override_help_text(func, func_to_be_wrapped):
     """Override function help text."""
@@ -82,6 +88,28 @@ class FieldDataService(StreamingService):
             )
         return chunk_iterator
 
+    def get_solver_mesh_nodes(
+        self, request: FieldDataProtoModule.GetSolverMeshNodesRequest
+    ):
+        """GetSolverMeshNodesDouble RPC of FieldData service."""
+        responses = self._stub.GetSolverMeshNodesDouble(
+            request, metadata=self._metadata
+        )
+        nested_nodes = []
+        for response in responses:
+            nested_nodes.append(response.nodes)
+        return nested_nodes
+
+    def get_solver_mesh_elements(
+        self, request: FieldDataProtoModule.GetSolverMeshElementsRequest
+    ):
+        """GetSolverMeshElements RPC of FieldData service."""
+        responses = self._stub.GetSolverMeshElements(request, metadata=self._metadata)
+        elementss = []
+        for response in responses:
+            elementss.append(response.elements)
+        return elementss
+
 
 class FieldInfo:
     """Provides access to Fluent field information.
@@ -922,6 +950,134 @@ class ChunkParser:
         return fields_data
 
 
+# Root domain id in Fluent.
+ROOT_DOMAIN_ID = 1
+
+
+class ZoneType(Enum):
+    """Zone types for mesh."""
+
+    CELL = 1
+    FACE = 2
+
+
+@dataclass
+class ZoneInfo:
+    """Zone information for mesh.
+
+    Attributes:
+    -----------
+    _id : int
+        Zone ID.
+    name : str
+        Name of the zone.
+    zone_type : ZoneType
+        Type of the zone for mesh.
+    """
+
+    _id: int
+    name: str
+    zone_type: ZoneType
+
+
+@dataclass
+class Node:
+    """Node class for mesh.
+
+    Attributes:
+    -----------
+    x : float
+        x-coordinate of the node.
+    y : float
+        y-coordinate of the node.
+    z : float
+        z-coordinate of the node.
+    """
+
+    _id: int
+    x: float
+    y: float
+    z: float
+
+
+class CellElementType(Enum):
+    """Element types for a cell element."""
+
+    # 3 nodes, 3 faces
+    TRIANGLE = 1
+    # 4 nodes, 4 faces
+    TETRAHEDRON = 2
+    # 4 nodes, 4 faces
+    QUADRILATERAL = 3
+    # 8 nodes, 6 faces
+    HEXAHEDRON = 4
+    # 5 nodes, 5 faces
+    PYRAMID = 5
+    # 6 nodes, 5 faces
+    WEDGE = 6
+    # Arbitrary number of nodes and faces
+    POLYHEDRON = 7
+    # 2 nodes, 1 face (only in 2D)
+    GHOST = 8
+    # 10 nodes, 4 faces
+    QUADRATIC_TETRAHEDRON = 9
+    # 20 nodes, 6 faces
+    QUADRATIC_HEXAHEDRON = 10
+    # 13 nodes, 5 faces
+    QUADRATIC_PYRAMID = 11
+    # 15 nodes, 5 faces
+    QUADRATIC_WEDGE = 12
+
+
+@dataclass
+class Facet:
+    """Facet class within a mesh element.
+
+    Attributes:
+    -----------
+    node_indices : list[int]
+        0-based node indices of the facet.
+    """
+
+    node_indices: list[int]
+
+
+@dataclass
+class Element:
+    """Element class for mesh.
+
+    Attributes:
+    -----------
+    element_type : CellElementType
+        Element type of the element.
+    node_indices : list[int]
+        0-based node indices of the element. Populated for standard elements.
+    facets : list[Facet]
+        List of facets of the element. Populated for polyhedral elements.
+    """
+
+    _id: int
+    element_type: CellElementType
+    node_indices: list[int] = field(default_factory=list)
+    facets: list[Facet] = field(default_factory=list)
+
+
+@dataclass
+class Mesh:
+    """Mesh class for Fluent field data.
+
+    Attributes:
+    -----------
+    nodes : list[Node]
+        List of nodes in the mesh.
+    elements : list[Element]
+        List of elements in the mesh.
+    """
+
+    nodes: list[Node]
+    elements: list[Element]
+
+
 class FieldData:
     """Provides access to Fluent field data on surfaces."""
 
@@ -931,12 +1087,14 @@ class FieldData:
         field_info: FieldInfo,
         is_data_valid: Callable[[], bool],
         scheme_eval=None,
+        get_zones_info: weakref.WeakMethod[Callable[[], list[ZoneInfo]]] | None = None,
     ):
         """__init__ method of FieldData class."""
         self._service = service
         self._field_info = field_info
         self.is_data_valid = is_data_valid
         self.scheme_eval = scheme_eval
+        self.get_zones_info = lambda: get_zones_info()()
 
         self._allowed_surface_names = _AllowedSurfaceNames(field_info)
 
@@ -1285,3 +1443,97 @@ class FieldData:
                 field_name: pathlines_data[surface_ids[count]][field_name],
             }
         return path_lines_dict
+
+    def get_mesh(self, zone: str | int) -> Mesh:
+        """Get mesh for a zone.
+
+        Parameters
+        ----------
+        zone : str | int
+            Zone name or id. Currently, only cell zones are supported.
+
+        Returns
+        -------
+        Mesh
+            Mesh object containing nodes and elements.
+
+        Raises
+        ------
+        ValueError
+            If the zone is not found.
+        NotImplementedError
+            If a face zone is provided.
+        """
+        zone_info = None
+        for zone_info in self.get_zones_info():
+            if zone_info.name == zone or zone_info._id == zone:
+                break
+        if zone_info is None:
+            raise ValueError(f"Zone {zone} not found.")
+        if zone_info.zone_type == ZoneType.FACE:
+            raise NotImplementedError("Face zone mesh is not supported.")
+
+        # Mesh data is retrieved from the root domain in Fluent
+        logger.info(f"Getting nodes data for zone {zone_info._id}")
+        start_time = time.time()
+        nodes_request = FieldDataProtoModule.GetSolverMeshNodesRequest(
+            domain_id=ROOT_DOMAIN_ID, thread_id=zone_info._id
+        )
+        nested_nodes = self._service.get_solver_mesh_nodes(nodes_request)
+        logger.info(f"Nodes data received in {time.time() - start_time} seconds")
+        logger.info(f"Getting elements for zone {zone_info._id}")
+        start_time = time.time()
+        elements_request = FieldDataProtoModule.GetSolverMeshElementsRequest(
+            domain_id=ROOT_DOMAIN_ID, thread_id=zone_info._id
+        )
+        elementss_pb = self._service.get_solver_mesh_elements(elements_request)
+        logger.info(f"Elements data received in {time.time() - start_time} seconds")
+        logger.info("Constructing nodes structure in PyFluent")
+        start_time = time.time()
+        node_count = sum(len(nodes) for nodes in nested_nodes)
+        nodes = np.empty(node_count, dtype=Node)
+        node_index_by_id = {}
+        i = 0
+        for nodes_pb in nested_nodes:
+            for node_pb in nodes_pb:
+                nodes[i] = Node(_id=node_pb.id, x=node_pb.x, y=node_pb.y, z=node_pb.z)
+                node_index_by_id[node_pb.id] = i
+                i += 1
+        logger.info(
+            f"Nodes structure constructed in {time.time() - start_time} seconds"
+        )
+        logger.info("Constructing elements structure in PyFluent")
+        start_time = time.time()
+        element_count = sum(len(elements) for elements in elementss_pb)
+        elements = np.empty(element_count, dtype=Element)
+        i = 0
+        for elements_pb in elementss_pb:
+            for element_pb in elements_pb:
+                element_type = CellElementType(element_pb.element_type)
+                if element_type == CellElementType.POLYHEDRON:
+                    facets = []
+                    for facet_pb in element_pb.facets:
+                        facet = Facet(
+                            node_indices=[node_index_by_id[id] for id in facet_pb.node]
+                        )
+                        facets.append(facet)
+                    element = Element(
+                        _id=element_pb.id,
+                        element_type=element_type,
+                        facets=facets,
+                    )
+                else:
+                    element = Element(
+                        _id=element_pb.id,
+                        element_type=element_type,
+                        node_indices=[
+                            node_index_by_id[id] for id in element_pb.node_ids
+                        ],
+                    )
+                elements[i] = element
+                i += 1
+        logger.info(
+            f"Elements structure constructed in {time.time() - start_time} seconds"
+        )
+        logger.info("Returning mesh")
+        return Mesh(nodes=nodes, elements=elements)

ansys/fluent/core/services/interceptors.py

@@ -1,11 +1,12 @@
 """Interceptor classes to use with gRPC services."""
 
+import builtins
 import logging
 import os
 from typing import Any
 
 from google.protobuf.json_format import MessageToDict
-from google.protobuf.message import Message
+from google.protobuf.message import DecodeError, Message
 import grpc
 
 from ansys.fluent.core.services.batch_ops import BatchOps
@@ -15,6 +16,10 @@ 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:
+    return "".join([word.capitalize() for word in name.split("_") if word])
+
+
 def _truncate_grpc_str(message: Message) -> str:
     message_bytes = message.ByteSize()
     message_str = str(MessageToDict(message))
@@ -107,7 +112,28 @@ class GrpcErrorInterceptor(grpc.UnaryUnaryClientInterceptor):
         response = continuation(client_call_details, request)
         if response.exception() is not None and response.code() != grpc.StatusCode.OK:
             ex = response.exception()
-            new_ex = RuntimeError(
+            new_ex_cls = RuntimeError
+            try:
+                from google.rpc import error_details_pb2
+                from grpc_status import rpc_status
+
+                status = rpc_status.from_call(ex)
+                if status:
+                    for detail in status.details:
+                        if detail.Is(error_details_pb2.ErrorInfo.DESCRIPTOR):
+                            info = error_details_pb2.ErrorInfo()
+                            detail.Unpack(info)
+                            if info.domain == "Python":
+                                reason = info.reason
+                                ex_cls_name = _upper_snake_case_to_camel_case(reason)
+                                if hasattr(builtins, ex_cls_name):
+                                    cls = getattr(builtins, ex_cls_name)
+                                    if issubclass(cls, Exception):
+                                        new_ex_cls = cls
+                                        break
+            except DecodeError:
+                pass
+            new_ex = new_ex_cls(
                 ex.details() if isinstance(ex, grpc.RpcError) else str(ex)
             )
             new_ex.__context__ = ex

ansys/fluent/core/session.py

@@ -3,7 +3,7 @@
 from enum import Enum
 import json
 import logging
-from typing import Any, Dict
+from typing import Any, Callable, Dict
 import warnings
 import weakref
 
@@ -11,7 +11,7 @@ from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.journaling import Journal
 from ansys.fluent.core.services import service_creator
 from ansys.fluent.core.services.app_utilities import AppUtilitiesOld
-from ansys.fluent.core.services.field_data import FieldDataService
+from ansys.fluent.core.services.field_data import FieldDataService, ZoneInfo
 from ansys.fluent.core.services.scheme_eval import SchemeEval
 from ansys.fluent.core.streaming_services.datamodel_event_streaming import (
     DatamodelEvents,
@@ -85,6 +85,7 @@ class BaseSession:
         Close the Fluent connection and exit Fluent.
     """
 
+    # We are passing around an WeakMethod to avoid circular references
     def __init__(
         self,
         fluent_connection: FluentConnection,
@@ -93,6 +94,7 @@ class BaseSession:
         start_transcript: bool = True,
         launcher_args: Dict[str, Any] | None = None,
         event_type: Enum | None = None,
+        get_zones_info: weakref.WeakMethod[Callable[[], list[ZoneInfo]]] | None = None,
     ):
         """BaseSession.
 
@@ -120,6 +122,7 @@ class BaseSession:
             scheme_eval,
             file_transfer_service,
             event_type,
+            get_zones_info,
         )
 
     def _build_from_fluent_connection(
@@ -128,6 +131,7 @@ class BaseSession:
         scheme_eval: SchemeEval,
         file_transfer_service: Any | None = None,
         event_type=None,
+        get_zones_info: weakref.WeakMethod[Callable[[], list[ZoneInfo]]] | None = None,
     ):
         """Build a BaseSession object from fluent_connection object."""
         self._fluent_connection = fluent_connection
@@ -205,6 +209,7 @@ class BaseSession:
                     self.field_info,
                     self._is_solution_data_valid,
                     _session.scheme_eval,
+                    get_zones_info,
                 )
                 self.field_data_streaming = FieldDataStreaming(
                     _session._fluent_connection._id, _session._field_data_service

ansys/fluent/core/session_solver.py

@@ -6,9 +6,12 @@ import logging
 import threading
 from typing import Any, Dict
 import warnings
+import weakref
 
+from ansys.api.fluent.v0 import svar_pb2 as SvarProtoModule
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.services import SchemeEval, service_creator
+from ansys.fluent.core.services.field_data import ZoneInfo, ZoneType
 from ansys.fluent.core.services.reduction import ReductionService
 from ansys.fluent.core.services.solution_variables import (
     SolutionVariableData,
@@ -106,6 +109,7 @@ class Solver(BaseSession):
             start_transcript=start_transcript,
             launcher_args=launcher_args,
             event_type=SolverEvent,
+            get_zones_info=weakref.WeakMethod(self._get_zones_info),
         )
         self._build_from_fluent_connection(fluent_connection, scheme_eval)
 
@@ -176,6 +180,23 @@ class Solver(BaseSession):
         )
         return self.fields.solution_variable_info
 
+    def _get_zones_info(self) -> list[ZoneInfo]:
+        zones_info = []
+        for (
+            zone_info
+        ) in self.fields.solution_variable_info.get_zones_info()._zones_info.values():
+            zone_type = (
+                ZoneType.CELL
+                if zone_info.thread_type == SvarProtoModule.ThreadType.CELL_THREAD
+                else ZoneType.FACE
+            )
+            zones_info.append(
+                ZoneInfo(
+                    _id=zone_info.zone_id, name=zone_info.name, zone_type=zone_type
+                )
+            )
+        return zones_info
+
     @property
     def reduction(self):
         """``Reduction`` handle."""

{ansys_fluent_core-0.28.2.dist-info → ansys_fluent_core-0.29.dev1.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 ANSYS, Inc. All rights reserved.
+Copyright (c) 2025 ANSYS, Inc. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal