ansys-fluent-core 0.20.dev7__py3-none-any.whl → 0.20.dev8__py3-none-any.whl

ansys/fluent/core/launcher/pim_launcher.py

@@ -1,15 +1,36 @@
-"""Provides a module for launching Fluent in pim mode."""
+"""Provides a module for launching Fluent in pim mode.
+
+Examples
+--------
+
+>>> from ansys.fluent.core.launcher.launcher import create_launcher
+>>> from ansys.fluent.core.launcher.pyfluent_enums import LaunchMode
+
+>>> pim_meshing_launcher = create_launcher(LaunchMode.PIM, mode="meshing")
+>>> pim_meshing_session = pim_meshing_launcher()
+
+>>> pim_solver_launcher = create_launcher(LaunchMode.PIM)
+>>> pim_solver_session = pim_solver_launcher()
+"""
 
 import logging
 import os
 from typing import Any, Dict, Optional, Union
 
-from ansys.fluent.core.launcher.launcher_utils import (
+from ansys.fluent.core.fluent_connection import FluentConnection
+from ansys.fluent.core.launcher.error_handler import _process_invalid_args
+from ansys.fluent.core.launcher.pyfluent_enums import (
+    FluentLinuxGraphicsDriver,
     FluentMode,
-    _process_invalid_args,
-    launch_remote_fluent,
+    FluentUI,
+    FluentWindowsGraphicsDriver,
 )
+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
+from ansys.fluent.core.session_solver_icing import SolverIcing
 from ansys.fluent.core.utils.file_transfer_service import PimFileTransferService
+import ansys.platform.instancemanagement as pypim
 
 _THIS_DIR = os.path.dirname(__file__)
 _OPTIONS_FILE = os.path.join(_THIS_DIR, "fluent_launcher_options.json")
@@ -17,11 +38,13 @@ logger = logging.getLogger("pyfluent.launcher")
 
 
 class PIMLauncher:
-    """Instantiates Fluent session in `PIM<https://pypim.docs.pyansys.com/version/stable/>` mode."""
+    """Instantiates Fluent session in `PIM <https://pypim.docs.pyansys.com/version/stable/>`_ mode."""
 
     def __init__(
         self,
         mode: FluentMode,
+        ui: FluentUI,
+        graphics_driver: Union[FluentWindowsGraphicsDriver, FluentLinuxGraphicsDriver],
         product_version: Optional[str] = None,
         version: Optional[str] = None,
         precision: Optional[str] = None,
@@ -35,7 +58,6 @@ class PIMLauncher:
         dry_run: bool = False,
         cleanup_on_exit: bool = True,
         start_transcript: bool = True,
-        show_gui: Optional[bool] = None,
         case_file_name: Optional[str] = None,
         case_data_file_name: Optional[str] = None,
         lightweight_mode: Optional[bool] = None,
@@ -47,15 +69,21 @@ class PIMLauncher:
         scheduler_options: Optional[dict] = None,
         file_transfer_service: Optional[Any] = None,
     ):
-        """Launch Fluent session in `PIM<https://pypim.docs.pyansys.com/version/stable/>` mode.
+        """Launch Fluent session in `PIM <https://pypim.docs.pyansys.com/version/stable/>`_ mode.
 
         Parameters
         ----------
         mode : FluentMode
             Launch mode of Fluent to point to a specific session type.
+        ui : FluentUI
+            Fluent user interface mode. Options are the values of the ``FluentUI`` enum.
+        graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
+            Graphics driver of Fluent. Options are the values of the
+            ``FluentWindowsGraphicsDriver`` enum in Windows or the values of the
+            ``FluentLinuxGraphicsDriver`` enum in Linux.
         product_version : str, optional
-            Select an installed version of ANSYS. The string must be in a format like
-            ``"23.2.0"`` (for 2023 R2) matching the documented version format in the
+            Version of Ansys Fluent to launch. The string must be in a format like
+            ``"23.2.0"`` (for 2023 R2), matching the documented version format in the
             FluentVersion class. The default is ``None``, in which case the newest installed
             version is used.
         version : str, optional
@@ -101,11 +129,6 @@ class PIMLauncher:
             default is ``True``. You can stop and start the streaming of the
             Fluent transcript subsequently via the method calls, ``transcript.start()``
             and ``transcript.stop()`` on the session object.
-        show_gui : bool, optional
-            Whether to display the Fluent GUI. The default is ``None``, which does not
-            cause the GUI to be shown. If a value of ``False`` is
-            not explicitly provided, the GUI will also be shown if
-            the environment variable ``PYFLUENT_SHOW_SERVER_GUI`` is set to 1.
         case_file_name : str, optional
             If provided, the case file at ``case_file_name`` is read into the Fluent session.
         case_data_file_name : str, optional
@@ -200,3 +223,85 @@ class PIMLauncher:
             launcher_args=self.argvals,
             file_transfer_service=self.file_transfer_service,
         )
+
+
+def launch_remote_fluent(
+    session_cls,
+    start_transcript: bool,
+    product_version: Optional[str] = None,
+    cleanup_on_exit: bool = True,
+    mode: FluentMode = FluentMode.SOLVER,
+    dimensionality: Optional[str] = None,
+    launcher_args: Optional[Dict[str, Any]] = None,
+    file_transfer_service: Optional[Any] = None,
+) -> Union[Meshing, PureMeshing, Solver, SolverIcing]:
+    """Launch Fluent remotely using `PyPIM <https://pypim.docs.pyansys.com>`.
+
+    When calling this method, you must ensure that you are in an
+    environment where PyPIM is configured. You can use the :func:
+    `pypim.is_configured <ansys.platform.instancemanagement.is_configured>`
+    method to verify that PyPIM is configured.
+
+    Parameters
+    ----------
+    session_cls: Union[type(Meshing), type(PureMeshing), type(Solver), type(SolverIcing)]
+        Session type.
+    start_transcript: bool
+        Whether to start streaming the Fluent transcript in the client. The
+        default is ``True``. You can stop and start the streaming of the
+        Fluent transcript subsequently via method calls on the session object.
+    product_version : str, optional
+        Ansys version to use. The string must be in a format like
+        ``"23.2.0"`` (for 2023 R2), matching the documented version format in the
+        FluentVersion class. The default is ``None``, in which case the newest installed
+        version is used.
+    cleanup_on_exit : bool, optional
+        Whether to clean up and exit Fluent when Python exits or when garbage
+        is collected for the Fluent Python instance. The default is ``True``.
+    mode : FluentMode, optional
+        Whether to launch Fluent remotely in meshing mode. The default is
+        ``FluentMode.SOLVER``.
+    dimensionality : str, optional
+        Geometric dimensionality of the Fluent simulation. The default is ``None``,
+        in which case ``"3d"`` is used. Options are ``"3d"`` and ``"2d"``.
+    file_transfer_service : optional
+        File transfer service for uploading or downloading files to or from the server.
+
+    Returns
+    -------
+    :obj:`~typing.Union` [:class:`Meshing<ansys.fluent.core.session_meshing.Meshing>`, \
+    :class:`~ansys.fluent.core.session_pure_meshing.PureMeshing`, \
+    :class:`~ansys.fluent.core.session_solver.Solver`, \
+    :class:`~ansys.fluent.core.session_solver_icing.SolverIcing`]
+        Session object.
+    """
+    pim = pypim.connect()
+    instance = pim.create_instance(
+        product_name=(
+            "fluent-meshing"
+            if FluentMode.is_meshing(mode)
+            else "fluent-2ddp" if dimensionality == "2d" else "fluent-3ddp"
+        ),
+        product_version=product_version,
+    )
+    instance.wait_for_ready()
+    # nb pymapdl sets max msg len here:
+    channel = instance.build_grpc_channel()
+
+    fluent_connection = FluentConnection(
+        channel=channel,
+        cleanup_on_exit=cleanup_on_exit,
+        remote_instance=instance,
+        start_transcript=start_transcript,
+        launcher_args=launcher_args,
+    )
+
+    file_transfer_service = (
+        file_transfer_service
+        if file_transfer_service
+        else PimFileTransferService(pim_instance=fluent_connection._remote_instance)
+    )
+
+    return session_cls(
+        fluent_connection=fluent_connection, file_transfer_service=file_transfer_service
+    )

ansys/fluent/core/launcher/process_launch_string.py

@@ -0,0 +1,138 @@
+import json
+import os
+from pathlib import Path
+
+from ansys.fluent.core.launcher import launcher_utils
+from ansys.fluent.core.launcher.pyfluent_enums import FluentMode
+from ansys.fluent.core.scheduler import build_parallel_options, load_machines
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+
+_THIS_DIR = os.path.dirname(__file__)
+_OPTIONS_FILE = os.path.join(_THIS_DIR, "fluent_launcher_options.json")
+
+
+def _build_fluent_launch_args_string(**kwargs) -> str:
+    """Build Fluent's launch arguments string from keyword arguments.
+
+    Returns
+    -------
+    str
+        Fluent's launch arguments string.
+    """
+    all_options = None
+    with open(_OPTIONS_FILE, encoding="utf-8") as fp:
+        all_options = json.load(fp)
+    launch_args_string = ""
+    for k, v in all_options.items():
+        argval = kwargs.get(k)
+        default = v.get("default")
+        if argval is None and v.get("fluent_required") is True:
+            argval = default
+        if argval is not None:
+            allowed_values = v.get("allowed_values")
+            if allowed_values and argval not in allowed_values:
+                if default is not None:
+                    old_argval = argval
+                    argval = default
+                    launcher_utils.logger.warning(
+                        f"Specified value '{old_argval}' for argument '{k}' is not an allowed value ({allowed_values})."
+                        f" Default value '{argval}' is going to be used instead."
+                    )
+                else:
+                    launcher_utils.logger.warning(
+                        f"{k} = {argval} is discarded as it is not an allowed value. Allowed values: {allowed_values}"
+                    )
+                    continue
+            fluent_map = v.get("fluent_map")
+            if fluent_map:
+                if isinstance(argval, str):
+                    json_key = argval
+                else:
+                    json_key = json.dumps(argval)
+                argval = fluent_map[json_key]
+            launch_args_string += v["fluent_format"].replace("{}", str(argval))
+    addArgs = kwargs.get("additional_arguments")
+    if addArgs and "-t" not in addArgs and "-cnf=" not in addArgs:
+        parallel_options = build_parallel_options(
+            load_machines(ncores=kwargs["processor_count"])
+        )
+        if parallel_options:
+            launch_args_string += " " + parallel_options
+    gpu = kwargs.get("gpu")
+    if gpu is True:
+        launch_args_string += " -gpu"
+    elif isinstance(gpu, list):
+        launch_args_string += f" -gpu={','.join(map(str, gpu))}"
+    ui = kwargs.get("ui")
+    if ui and ui.value[0]:
+        launch_args_string += f" -{ui.value[0]}"
+    graphics_driver = kwargs.get("graphics_driver")
+    if graphics_driver and graphics_driver.value[0]:
+        launch_args_string += f" -driver {graphics_driver.value[0]}"
+    return launch_args_string
+
+
+def _generate_launch_string(
+    argvals,
+    mode: FluentMode,
+    additional_arguments: str,
+    server_info_file_name: str,
+):
+    """Generates the launch string to launch fluent."""
+    if launcher_utils.is_windows():
+        exe_path = str(get_fluent_exe_path(**argvals))
+        if " " in exe_path:
+            exe_path = '"' + exe_path + '"'
+    else:
+        exe_path = str(get_fluent_exe_path(**argvals))
+    launch_string = exe_path
+    if mode == FluentMode.SOLVER_ICING:
+        argvals["fluent_icing"] = True
+    launch_string += _build_fluent_launch_args_string(**argvals)
+    if FluentMode.is_meshing(mode):
+        launch_string += " -meshing"
+    if additional_arguments:
+        launch_string += f" {additional_arguments}"
+    if " " in server_info_file_name:
+        server_info_file_name = '"' + server_info_file_name + '"'
+    launch_string += f" -sifile={server_info_file_name}"
+    launch_string += " -nm"
+    return launch_string
+
+
+def get_fluent_exe_path(**launch_argvals) -> Path:
+    """Get the path for the Fluent executable file.
+    The search for the path is performed in this order:
+
+    1. ``product_version`` parameter passed with the ``launch_fluent`` method.
+    2. The latest Ansys version from ``AWP_ROOTnnn``` environment variables.
+
+    Returns
+    -------
+    Path
+        Fluent executable path
+    """
+
+    def get_fluent_root(version: FluentVersion) -> Path:
+        awp_root = os.environ[version.awp_var]
+        return Path(awp_root) / "fluent"
+
+    def get_exe_path(fluent_root: Path) -> Path:
+        if launcher_utils.is_windows():
+            return fluent_root / "ntbin" / "win64" / "fluent.exe"
+        else:
+            return fluent_root / "bin" / "fluent"
+
+    # (DEV) "PYFLUENT_FLUENT_ROOT" environment variable
+    fluent_root = os.getenv("PYFLUENT_FLUENT_ROOT")
+    if fluent_root:
+        return get_exe_path(Path(fluent_root))
+
+    # Look for Fluent exe path in the following order:
+    # 1. 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)))
+
+    # 2. 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

@@ -0,0 +1,233 @@
+from enum import Enum
+from functools import total_ordering
+import os
+from typing import Optional, Union
+
+from ansys.fluent.core.exceptions import DisallowedValuesError
+from ansys.fluent.core.fluent_connection import FluentConnection
+import ansys.fluent.core.launcher.error_handler as exceptions
+from ansys.fluent.core.launcher.launcher_utils import check_docker_support
+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
+from ansys.fluent.core.session_solver_icing import SolverIcing
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+import ansys.platform.instancemanagement as pypim
+
+
+class LaunchMode(Enum):
+    """Enumerates over supported Fluent launch modes."""
+
+    STANDALONE = 1
+    PIM = 2
+    CONTAINER = 3
+    SLURM = 4
+
+
+class FluentMode(Enum):
+    """Enumerates over supported Fluent modes."""
+
+    MESHING_MODE = (Meshing, "meshing")
+    PURE_MESHING_MODE = (PureMeshing, "pure-meshing")
+    SOLVER = (Solver, "solver")
+    SOLVER_ICING = (SolverIcing, "solver-icing")
+
+    @staticmethod
+    def get_mode(mode: str) -> "FluentMode":
+        """Get the FluentMode based on the provided mode string.
+
+        Parameters
+        ----------
+        mode : str
+            Mode
+
+        Returns
+        -------
+        FluentMode
+            Fluent mode.
+
+        Raises
+        ------
+        DisallowedValuesError
+            If an unknown mode is passed.
+        """
+        allowed_modes = []
+        for m in FluentMode:
+            allowed_modes.append(m.value[1])
+            if mode == m.value[1]:
+                return m
+        raise DisallowedValuesError("mode", mode, allowed_modes)
+
+    @staticmethod
+    def is_meshing(mode: "FluentMode") -> bool:
+        """Check if the current mode is meshing.
+
+        Parameters
+        ----------
+        mode : FluentMode
+            mode
+
+        Returns
+        -------
+        bool
+            ``True`` if the mode is ``FluentMode.MESHING_MODE`` or ``FluentMode.PURE_MESHING_MODE``,
+            ``False`` otherwise.
+        """
+        return mode in [FluentMode.MESHING_MODE, FluentMode.PURE_MESHING_MODE]
+
+
+@total_ordering
+class FluentEnum(Enum):
+    """Provides the base class for Fluent-related enums.
+
+    Accepts lowercase member names as values and supports comparison operators.
+    """
+
+    @classmethod
+    def _missing_(cls, value: str):
+        for member in cls:
+            if str(member) == value:
+                return member
+        raise ValueError(
+            f"The specified value '{value}' is a supported value of {cls.__name__}."
+            f""" The supported values are: '{", '".join(str(member) for member in cls)}'."""
+        )
+
+    def __str__(self):
+        return self.name.lower()
+
+    def __lt__(self, other):
+        if not isinstance(other, type(self)):
+            raise TypeError(
+                f"Cannot compare between {type(self).__name__} and {type(other).__name__}"
+            )
+        if self == other:
+            return False
+        for member in type(self):
+            if self == member:
+                return True
+            if other == member:
+                return False
+
+
+class FluentUI(FluentEnum):
+    """Provides supported user interface mode of Fluent."""
+
+    NO_GUI_OR_GRAPHICS = ("g",)
+    NO_GRAPHICS = ("gr",)
+    NO_GUI = ("gu",)
+    HIDDEN_GUI = ("hidden",)
+    GUI = ("",)
+
+
+class FluentWindowsGraphicsDriver(FluentEnum):
+    """Provides supported graphics driver of Fluent in Windows."""
+
+    NULL = ("null",)
+    MSW = ("msw",)
+    DX11 = ("dx11",)
+    OPENGL2 = ("opengl2",)
+    OPENGL = ("opengl",)
+    AUTO = ("",)
+
+
+class FluentLinuxGraphicsDriver(FluentEnum):
+    """Provides supported graphics driver of Fluent in Linux."""
+
+    NULL = ("null",)
+    X11 = ("x11",)
+    OPENGL2 = ("opengl2",)
+    OPENGL = ("opengl",)
+    AUTO = ("",)
+
+
+def _get_mode(mode: Optional[Union[FluentMode, str, None]] = None):
+    """Update the session information."""
+    if mode is None:
+        mode = FluentMode.SOLVER
+
+    if isinstance(mode, str):
+        mode = FluentMode.get_mode(mode)
+
+    return mode
+
+
+def _get_running_session_mode(
+    fluent_connection: FluentConnection, mode: Optional[FluentMode] = None
+):
+    """Get the mode of the running session if the mode has not been explicitly given."""
+    if mode:
+        session_mode = mode
+    else:
+        try:
+            session_mode = FluentMode.get_mode(
+                "solver"
+                if fluent_connection.scheme_eval.scheme_eval("(cx-solver-mode?)")
+                else "meshing"
+            )
+        except Exception as ex:
+            raise exceptions.InvalidPassword() from ex
+    return session_mode.value[0]
+
+
+def _get_fluent_launch_mode(start_container, container_dict, scheduler_options):
+    """Get the Fluent launch mode.
+
+    Parameters
+    ----------
+    start_container: bool
+        Whether to launch a Fluent Docker container image.
+    container_dict: dict
+        Dictionary for Fluent Docker container configuration.
+
+    Returns
+    -------
+    fluent_launch_mode: LaunchMode
+        Fluent launch mode.
+    """
+    if pypim.is_configured():
+        fluent_launch_mode = LaunchMode.PIM
+    elif start_container is True or (
+        start_container is None
+        and (container_dict or os.getenv("PYFLUENT_LAUNCH_CONTAINER") == "1")
+    ):
+        if check_docker_support():
+            fluent_launch_mode = LaunchMode.CONTAINER
+        else:
+            raise exceptions.DockerContainerLaunchNotSupported()
+    elif scheduler_options and scheduler_options["scheduler"] == "slurm":
+        fluent_launch_mode = LaunchMode.SLURM
+    else:
+        fluent_launch_mode = LaunchMode.STANDALONE
+    return fluent_launch_mode
+
+
+def _get_standalone_launch_fluent_version(
+    product_version: Union[FluentVersion, str, None]
+) -> Optional[FluentVersion]:
+    """Determine the Fluent version during the execution of the ``launch_fluent()``
+    method in standalone mode.
+
+    The search for the version is performed in this order:
+
+    1. The ``product_version`` parameter passed with the ``launch_fluent`` method.
+    2. The latest Ansys version from ``AWP_ROOTnnn``` environment variables.
+
+    Returns
+    -------
+    FluentVersion, optional
+        Fluent version or ``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"):
+        return None
+
+    # Look for Fluent version in the following order:
+    # 1. product_version parameter passed with launch_fluent
+    if product_version:
+        return FluentVersion(product_version)
+
+    # 2. the latest ANSYS version from AWP_ROOT environment variables
+    return FluentVersion.get_latest_installed()

ansys/fluent/core/launcher/server_info.py

@@ -0,0 +1,47 @@
+import os
+from pathlib import Path
+import tempfile
+from typing import Optional
+
+from ansys.fluent.core.fluent_connection import PortNotProvided
+from ansys.fluent.core.launcher import launcher_utils
+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):
+    server_info_dir = os.getenv("SERVER_INFO_DIR")
+    dir_ = (
+        Path(server_info_dir)
+        if server_info_dir
+        else tempfile.gettempdir() if use_tmpdir else Path.cwd()
+    )
+    fd, file_name = tempfile.mkstemp(suffix=".txt", prefix="serverinfo-", dir=str(dir_))
+    os.close(fd)
+    return file_name
+
+
+def _get_server_info(
+    server_info_file_name: str,
+    ip: Optional[str] = None,
+    port: Optional[int] = None,
+    password: Optional[str] = None,
+):
+    """Get server connection information of an already running session."""
+    if not (ip and port) and not server_info_file_name:
+        raise IpPortNotProvided()
+    if (ip or port) and server_info_file_name:
+        launcher_utils.logger.warning(
+            "The IP address and port are extracted from the server-info file "
+            "and their explicitly specified values are ignored."
+        )
+    else:
+        if server_info_file_name:
+            ip, port, password = _parse_server_info_file(server_info_file_name)
+        ip = ip or os.getenv("PYFLUENT_FLUENT_IP", "127.0.0.1")
+        port = port or os.getenv("PYFLUENT_FLUENT_PORT")
+
+    if not port:
+        raise PortNotProvided()
+
+    return ip, port, password

ansys/fluent/core/launcher/slurm_launcher.py

@@ -36,15 +36,15 @@ import time
 from typing import Any, Callable, Union
 
 from ansys.fluent.core.exceptions import InvalidArgument
+from ansys.fluent.core.launcher.error_handler import _process_invalid_args
 from ansys.fluent.core.launcher.launcher_utils import (
     _await_fluent_launch,
     _build_journal_argument,
-    _generate_launch_string,
-    _get_mode,
-    _get_server_info_file_name,
     _get_subprocess_kwargs_for_fluent,
-    _process_invalid_args,
 )
+from ansys.fluent.core.launcher.process_launch_string import _generate_launch_string
+from ansys.fluent.core.launcher.pyfluent_enums import _get_mode
+from ansys.fluent.core.launcher.server_info import _get_server_info_file_name
 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
@@ -214,7 +214,6 @@ class SlurmLauncher:
         launch_cmd = _generate_launch_string(
             self._argvals,
             self.mode,
-            self._show_gui,
             self._additional_arguments,
             self._server_info_file_name,
         )