ansys-fluent-core 0.28.dev0__py3-none-any.whl → 0.28.1__py3-none-any.whl

ansys/fluent/core/journaling.py

@@ -4,14 +4,14 @@
 class Journal:
     """Control the writing of Fluent Python journals."""
 
-    def __init__(self, scheme_eval):
+    def __init__(self, app_utilities):
         """__init__ method of Journal class."""
-        self.scheme_eval = scheme_eval
+        self._app_utilities = app_utilities
 
     def start(self, file_name: str):
         """Start writing a Fluent Python journal at the specified file_name."""
-        self.scheme_eval.exec([f'(api-start-python-journal "{file_name}")'])
+        self._app_utilities.start_python_journal(journal_name=file_name)
 
     def stop(self):
         """Stop writing the Fluent Python journal."""
-        self.scheme_eval.exec(["(api-stop-python-journal)"])
+        self._app_utilities.stop_python_journal()

ansys/fluent/core/launcher/fluent_container.py

@@ -240,14 +240,15 @@ def configure_container_dict(
         f"Starting Fluent container mounted to {mount_source}, with this path available as {mount_target} for the Fluent session running inside the container."
     )
 
-    if "ports" not in container_dict:
-        if not port:
-            port = get_free_port()
-        container_dict.update(ports={str(port): port})  # container port : host port
-    else:
+    if not port and "ports" in container_dict:
         # take the specified 'port', OR the first port value from the specified 'ports', for Fluent to use
-        if not port:
-            port = next(iter(container_dict["ports"].values()))
+        port = next(iter(container_dict["ports"].values()))
+    if not port and pyfluent.LAUNCH_FLUENT_PORT:
+        port = pyfluent.LAUNCH_FLUENT_PORT
+    if not port:
+        port = get_free_port()
+
+    container_dict.update(ports={str(port): port})  # container port : host port
 
     if "environment" not in container_dict:
         if not license_server:
@@ -318,6 +319,29 @@ 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 "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"
+
+    if pyfluent.LAUNCH_FLUENT_IP or os.getenv("REMOTING_SERVER_ADDRESS"):
+        if "environment" not in container_dict:
+            container_dict["environment"] = {}
+        container_dict["environment"]["REMOTING_SERVER_ADDRESS"] = (
+            pyfluent.LAUNCH_FLUENT_IP or os.getenv("REMOTING_SERVER_ADDRESS")
+        )
+
+    if pyfluent.LAUNCH_FLUENT_SKIP_PASSWORD_CHECK:
+        if "environment" not in container_dict:
+            container_dict["environment"] = {}
+        container_dict["environment"]["FLUENT_LAUNCHED_FROM_PYFLUENT"] = "1"
+
     fluent_commands = ["-gu", f"-sifile={container_server_info_file}"] + args
 
     container_dict_default = {}

ansys/fluent/core/launcher/launcher.py

@@ -168,8 +168,9 @@ def launch_fluent(
         See also :mod:`~ansys.fluent.core.launcher.fluent_container`.
     dry_run : bool, optional
         Defaults to False. If True, will not launch Fluent, and will instead print configuration information
-        that would be used as if Fluent was being launched. If dry running a container start,
-        ``launch_fluent()`` will return the configured ``container_dict``.
+        that would be used as if Fluent was being launched. If dry running a standalone start
+        ``launch_fluent()`` will return a tuple containing Fluent launch string and the server info file name.
+        If dry running a container start, ``launch_fluent()`` will return the configured ``container_dict``.
     cleanup_on_exit : bool, optional
         Whether to shut down the connected Fluent session when PyFluent is
         exited, or the ``exit()`` method is called on the session instance,

ansys/fluent/core/launcher/launcher_utils.py

@@ -43,6 +43,15 @@ def _get_subprocess_kwargs_for_fluent(env: Dict[str, Any], argvals) -> Dict[str,
         del fluent_env["PARA_NPROCS"]
         del fluent_env["PARA_MESH_NPROCS"]
 
+    if pyfluent.LAUNCH_FLUENT_IP:
+        fluent_env["REMOTING_SERVER_ADDRESS"] = pyfluent.LAUNCH_FLUENT_IP
+
+    if pyfluent.LAUNCH_FLUENT_PORT:
+        fluent_env["REMOTING_PORTS"] = f"{pyfluent.LAUNCH_FLUENT_PORT}/portspan=2"
+
+    if pyfluent.LAUNCH_FLUENT_SKIP_PASSWORD_CHECK:
+        fluent_env["FLUENT_LAUNCHED_FROM_PYFLUENT"] = "1"
+
     if not is_slurm:
         if pyfluent.INFER_REMOTING_IP and "REMOTING_SERVER_ADDRESS" not in fluent_env:
             remoting_ip = find_remoting_ip()

ansys/fluent/core/launcher/process_launch_string.py

@@ -137,7 +137,14 @@ def get_fluent_exe_path(**launch_argvals) -> Path:
             return fluent_root / "bin" / "fluent"
 
     # Look for Fluent exe path in the following order:
-    # 1. product_version parameter passed with launch_fluent
+    # 1. Custom Path provided by the user in launch_fluent
+    fluent_path = launch_argvals.get("fluent_path")
+    if fluent_path:
+        # Return the fluent_path string verbatim. The path may not even exist
+        # in the current machine if user wants to launch fluent externally (dry_run use case).
+        return fluent_path
+
+    # 2. product_version parameter passed with launch_fluent
     product_version = launch_argvals.get("product_version")
     if product_version:
         return get_exe_path(get_fluent_root(FluentVersion(product_version)))
@@ -147,10 +154,5 @@ def get_fluent_exe_path(**launch_argvals) -> Path:
     if fluent_root:
         return get_exe_path(Path(fluent_root))
 
-    # 2. Custom Path provided by the user in launch_fluent
-    fluent_path = launch_argvals.get("fluent_path")
-    if fluent_path:
-        return Path(fluent_path)
-
     # 3. the latest ANSYS version from AWP_ROOT environment variables
     return get_exe_path(get_fluent_root(FluentVersion.get_latest_installed()))

ansys/fluent/core/launcher/pyfluent_enums.py

@@ -276,9 +276,7 @@ def _get_running_session_mode(
     return session_mode.get_fluent_value()
 
 
-def _get_standalone_launch_fluent_version(
-    product_version: FluentVersion | str | float | int | None,
-) -> FluentVersion | None:
+def _get_standalone_launch_fluent_version(argvals) -> FluentVersion | None:
     """Determine the Fluent version during the execution of the ``launch_fluent()``
     method in standalone mode.
 
@@ -295,9 +293,14 @@ def _get_standalone_launch_fluent_version(
 
     # Look for Fluent version in the following order:
     # 1. product_version parameter passed with launch_fluent
+    product_version = argvals.get("product_version")
     if product_version:
         return FluentVersion(product_version)
 
+    # If fluent_path is provided, we cannot determine the Fluent version, so returning None.
+    if argvals.get("fluent_path"):
+        return None
+
     # (DEV) if "PYFLUENT_FLUENT_ROOT" environment variable is defined, we cannot
     # determine the Fluent version, so returning None.
     if os.getenv("PYFLUENT_FLUENT_ROOT"):

ansys/fluent/core/launcher/server_info.py

@@ -10,7 +10,27 @@ from ansys.fluent.core.launcher.error_handler import IpPortNotProvided
 from ansys.fluent.core.session import _parse_server_info_file
 
 
-def _get_server_info_file_name(use_tmpdir=True):
+def _get_server_info_file_names(use_tmpdir=True) -> tuple[str, str]:
+    """Returns a tuple containing server and client-side file names with the server connection information.
+    When server and client are in a different machine, the environment variable SERVER_INFO_DIR
+    can be set to a shared directory between the two machines and the server-info file will be
+    created in that directory. The value of the environment variable SERVER_INFO_DIR can be
+    different for the server and client machines. The relative path of the server-side server-info
+    file is passed to Fluent launcher and PyFluent connects to the server using the absolute path
+    of the client-side server-info file. A typical use case of the environment variable
+    SERVER_INFO_DIR is as follows:
+    - Server machine environment variable: SERVER_INFO_DIR=/mnt/shared
+    - Client machine environment variable: SERVER_INFO_DIR=\\\\server\\shared
+    - Server-side server-info file: /mnt/shared/serverinfo-xyz.txt
+    - Client-side server-info file: \\\\server\\shared\\serverinfo-xyz.txt
+    - Fluent launcher command: fluent ... -sifile=serverinfo-xyz.txt ...
+    - From PyFluent: connect_to_fluent(server_info_file_name="\\\\server\\shared\\serverinfo-xyz.txt")
+
+    When the environment variable SERVER_INFO_DIR is not set, the server-side and client-side
+    file paths for the server-info file are identical. The server-info file is created in the
+    temporary directory if ``use_tmpdir`` is True, otherwise it is created in the current working
+    directory.
+    """
     server_info_dir = os.getenv("SERVER_INFO_DIR")
     dir_ = (
         Path(server_info_dir)
@@ -19,7 +39,10 @@ def _get_server_info_file_name(use_tmpdir=True):
     )
     fd, file_name = tempfile.mkstemp(suffix=".txt", prefix="serverinfo-", dir=str(dir_))
     os.close(fd)
-    return file_name
+    if server_info_dir:
+        return Path(file_name).name, file_name
+    else:
+        return file_name, file_name
 
 
 def _get_server_info(

ansys/fluent/core/launcher/slurm_launcher.py

@@ -64,7 +64,7 @@ from ansys.fluent.core.launcher.pyfluent_enums import (
     UIMode,
     _get_argvals_and_session,
 )
-from ansys.fluent.core.launcher.server_info import _get_server_info_file_name
+from ansys.fluent.core.launcher.server_info import _get_server_info_file_names
 from ansys.fluent.core.session_meshing import Meshing
 from ansys.fluent.core.session_pure_meshing import PureMeshing
 from ansys.fluent.core.session_solver import Solver
@@ -416,11 +416,14 @@ class SlurmLauncher:
                     )
 
     def _prepare(self):
-        self._server_info_file_name = _get_server_info_file_name(use_tmpdir=False)
+        server_info_file_name_for_server, server_info_file_name_for_client = (
+            _get_server_info_file_names(use_tmpdir=False)
+        )
+        self._server_info_file_name = server_info_file_name_for_client
         self._argvals.update(self._argvals["scheduler_options"])
         launch_cmd = _generate_launch_string(
             self._argvals,
-            self._server_info_file_name,
+            server_info_file_name_for_server,
         )
 
         self._sifile_last_mtime = Path(self._server_info_file_name).stat().st_mtime

ansys/fluent/core/launcher/standalone_launcher.py

@@ -43,7 +43,7 @@ from ansys.fluent.core.launcher.pyfluent_enums import (
 )
 from ansys.fluent.core.launcher.server_info import (
     _get_server_info,
-    _get_server_info_file_name,
+    _get_server_info_file_names,
 )
 import ansys.fluent.core.launcher.watchdog as watchdog
 from ansys.fluent.core.utils.fluent_version import FluentVersion
@@ -128,8 +128,9 @@ class StandaloneLauncher:
             exited, or the ``exit()`` method is called on the session instance,
             or if the session instance becomes unreferenced. The default is ``True``.
         dry_run : bool, optional
-            Defaults to False. If True, will not launch Fluent, and will instead print configuration information
-            that would be used as if Fluent was being launched.
+            Defaults to False. If True, will not launch Fluent, and will print configuration information
+            that would be used as if Fluent was being launched. If True, the ``call()`` method will return
+            a tuple containing Fluent launch string and the server info file name.
         start_transcript : bool, optional
             Whether to start streaming the Fluent transcript in the client. The
             default is ``True``. You can stop and start the streaming of the
@@ -188,9 +189,7 @@ class StandaloneLauncher:
             self.argvals["start_timeout"] = 60
         if self.argvals["lightweight_mode"] is None:
             self.argvals["lightweight_mode"] = False
-        fluent_version = _get_standalone_launch_fluent_version(
-            self.argvals["product_version"]
-        )
+        fluent_version = _get_standalone_launch_fluent_version(self.argvals)
         if fluent_version:
             _raise_non_gui_exception_in_windows(self.argvals["ui_mode"], fluent_version)
 
@@ -200,10 +199,13 @@ class StandaloneLauncher:
         if os.getenv("PYFLUENT_FLUENT_DEBUG") == "1":
             self.argvals["fluent_debug"] = True
 
-        self._server_info_file_name = _get_server_info_file_name()
+        server_info_file_name_for_server, server_info_file_name_for_client = (
+            _get_server_info_file_names()
+        )
+        self._server_info_file_name = server_info_file_name_for_client
         self._launch_string = _generate_launch_string(
             self.argvals,
-            self._server_info_file_name,
+            server_info_file_name_for_server,
         )
 
         self._sifile_last_mtime = Path(self._server_info_file_name).stat().st_mtime
@@ -232,7 +234,7 @@ class StandaloneLauncher:
     def __call__(self):
         if self.argvals["dry_run"]:
             print(f"Fluent launch string: {self._launch_string}")
-            return
+            return self._launch_string, self._server_info_file_name
         try:
             logger.debug(f"Launching Fluent with command: {self._launch_cmd}")
 

ansys/fluent/core/post_objects/post_helper.py

@@ -2,6 +2,9 @@
 
 import re
 
+from ansys.fluent.core.solver.flunits import get_si_unit_for_fluent_quantity
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+
 
 class IncompleteISOSurfaceDefinition(RuntimeError):
     """Raised when iso-surface definition is incomplete."""
@@ -94,11 +97,9 @@ class PostAPIHelper:
         def delete_surface_on_server(self):
             """Deletes the surface on server."""
             if self.obj.definition.type() == "iso-surface":
-                self._get_api_handle().iso_surface.delete(self._surface_name_on_server)
+                del self._get_api_handle().iso_surface[self._surface_name_on_server]
             elif self.obj.definition.type() == "plane-surface":
-                self._get_api_handle().plane_surface.delete(
-                    self._surface_name_on_server
-                )
+                del self._get_api_handle().plane_surface[self._surface_name_on_server]
 
     def __init__(self, obj):
         """__init__ method of PostAPIHelper class."""
@@ -127,15 +128,20 @@ class PostAPIHelper:
     # Following functions will be deprecated in future.
     def get_vector_fields(self):
         """Returns vector field."""
-        return self.field_info.get_vector_fields_info()
+        return self.field_info().get_vector_fields_info()
 
     def get_field_unit(self, field):
         """Returns the unit of the field."""
-        quantity = self._field_unit_quantity(field)
-        if quantity == "*null*":
-            return ""
-        scheme_eval_str = f"(units/get-pretty-wb-units-from-dimension (units/inquire-dimension '{quantity}))"
-        return " ".join(self._scheme_str_to_py_list(scheme_eval_str))
+        session = self.obj.get_root().session
+        if FluentVersion(session.scheme_eval.version) < FluentVersion.v252:
+            quantity = self._field_unit_quantity(field)
+            if quantity == "*null*":
+                return ""
+            scheme_eval_str = f"(units/get-pretty-wb-units-from-dimension (units/inquire-dimension '{quantity}))"
+            return " ".join(self._scheme_str_to_py_list(scheme_eval_str))
+        else:
+            fields_info = self.field_info().get_scalar_fields_info()
+            return get_si_unit_for_fluent_quantity(fields_info[field]["quantity_name"])
 
     def _field_unit_quantity(self, field):
         scheme_eval_str = f"(cdr (assq 'units (%fill-render-info '{field})))"

ansys/fluent/core/services/__init__.py

@@ -1,5 +1,6 @@
 """Provides a module to create gRPC services."""
 
+from ansys.fluent.core.services.app_utilities import AppUtilities
 from ansys.fluent.core.services.batch_ops import BatchOpsService
 from ansys.fluent.core.services.datamodel_se import (
     DatamodelService as DatamodelService_SE,
@@ -22,6 +23,7 @@ from ansys.fluent.core.services.solution_variables import (
 from ansys.fluent.core.services.transcript import TranscriptService
 
 _service_cls_by_name = {
+    "app_utilities": AppUtilities,
     "health_check": HealthCheckService,
     "datamodel": DatamodelService_SE,
     "tui": DatamodelService_TUI,

ansys/fluent/core/services/api_upgrade.py

@@ -3,7 +3,7 @@
 import os
 from typing import TypeVar
 
-from ansys.fluent.core.services.scheme_eval import SchemeEval
+from ansys.fluent.core.services.app_utilities import AppUtilities
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 _TApiUpgradeAdvisor = TypeVar("_TApiUpgradeAdvisor", bound="ApiUpgradeAdvisor")
@@ -12,11 +12,17 @@ _TApiUpgradeAdvisor = TypeVar("_TApiUpgradeAdvisor", bound="ApiUpgradeAdvisor")
 class ApiUpgradeAdvisor:
     """API upgrade advisor."""
 
-    def __init__(self, scheme_eval: SchemeEval, version: str, mode: str) -> None:
+    def __init__(
+        self,
+        app_utilities: AppUtilities,
+        version: str,
+        mode: str,
+    ) -> None:
         """Initialize ApiUpgradeAdvisor."""
-        self._scheme_eval = scheme_eval.scheme_eval
+        self._app_utilities = app_utilities
         self._version = version
         self._mode = mode
+        self._id = None
 
     def _can_advise(self) -> bool:
         return (
@@ -27,16 +33,12 @@ class ApiUpgradeAdvisor:
 
     def __enter__(self) -> _TApiUpgradeAdvisor:
         if self._can_advise():
-            self._scheme_eval("(define pyfluent-journal-str-port (open-output-string))")
-            self._scheme_eval("(api-echo-python-port pyfluent-journal-str-port)")
+            self._id = self._app_utilities.start_python_journal()
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb) -> None:
         if self._can_advise():
-            self._scheme_eval("(api-unecho-python-port pyfluent-journal-str-port)")
-            journal_str = self._scheme_eval(
-                "(close-output-port pyfluent-journal-str-port)"
-            ).strip()
+            journal_str = (self._app_utilities.stop_python_journal(self._id)).strip()
             if (
                 journal_str.startswith("solver.")
                 and not journal_str.startswith("solver.tui")