ansys-fluent-core 0.31.dev1__py3-none-any.whl → 0.31.1__py3-none-any.whl

ansys/fluent/core/session.py

@@ -29,8 +29,11 @@ from typing import Any, Callable, Dict
 import warnings
 import weakref
 
+from deprecated.sphinx import deprecated
+
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.journaling import Journal
+from ansys.fluent.core.launcher.launcher_utils import is_compose
 from ansys.fluent.core.pyfluent_warnings import (
     PyFluentDeprecationWarning,
     PyFluentUserWarning,
@@ -149,6 +152,7 @@ class BaseSession:
             event_type,
             get_zones_info,
         )
+        self.register_finalizer_callback = fluent_connection.register_finalizer_cb
 
     def _build_from_fluent_connection(
         self,
@@ -270,30 +274,23 @@ class BaseSession:
         return True if self._fluent_connection else False
 
     @property
+    @deprecated(version="0.20.dev9", reason="Use ``session.fields.field_info``.")
     def field_info(self):
         """Provides access to Fluent field information."""
-        warnings.warn(
-            "field_info is deprecated. Use fields.field_info instead.",
-            PyFluentDeprecationWarning,
-        )
         return self.fields.field_info
 
     @property
+    @deprecated(version="0.20.dev9", reason="Use ``session.fields.field_data``.")
     def field_data(self):
         """Fluent field data on surfaces."""
-        warnings.warn(
-            "field_data is deprecated. Use fields.field_data instead.",
-            PyFluentDeprecationWarning,
-        )
         return self.fields.field_data
 
     @property
+    @deprecated(
+        version="0.20.dev9", reason="Use ``session.fields.field_data_streaming``."
+    )
     def field_data_streaming(self):
         """Field gRPC streaming service of Fluent."""
-        warnings.warn(
-            "field_data_streaming is deprecated. Use fields.field_data_streaming instead.",
-            PyFluentDeprecationWarning,
-        )
         return self.fields.field_data_streaming
 
     @property
@@ -369,15 +366,21 @@ class BaseSession:
         """Gets and returns the fluent version."""
         return FluentVersion(self.scheme_eval.version)
 
+    def _exit_compose_service(self):
+        if self._fluent_connection._container and is_compose():
+            self._fluent_connection._container.stop()
+
     def exit(self, **kwargs) -> None:
         """Exit session."""
         logger.debug("session.exit() called")
         if self._fluent_connection:
+            self._exit_compose_service()
             self._fluent_connection.exit(**kwargs)
             self._fluent_connection = None
 
     def force_exit(self) -> None:
         """Forces the Fluent session to exit, losing unsaved progress and data."""
+        self._exit_compose_service()
         self._fluent_connection.force_exit()
 
     def file_exists_on_remote(self, file_name: str) -> bool:

ansys/fluent/core/session_meshing.py

@@ -89,6 +89,9 @@ class Meshing(PureMeshing):
             file_transfer_service=self._file_transfer_service,
         )
         self._fluent_connection = None
+        self.__doc__ = (
+            "The meshing session is no longer usable after switching to solution mode."
+        )
         return solver_session
 
     def __getattribute__(self, item: str):

ansys/fluent/core/session_solver.py

@@ -77,19 +77,6 @@ def _set_state_safe(obj: SettingsBase, state: StateType):
             datamodel_logger.debug(f"set_state failed at {obj.path}")
 
 
-def _import_settings_root(root):
-    _class_dict = {}
-    api_keys = []
-    if hasattr(root, "child_names"):
-        api_keys = root.child_names
-
-    for root_item in api_keys:
-        _class_dict[root_item] = root.__dict__[root_item]
-
-    settings_api_root = type("SettingsRoot", (object,), _class_dict)
-    return settings_api_root()
-
-
 class Solver(BaseSession):
     """Encapsulates a Fluent solver session.
 
@@ -143,9 +130,17 @@ class Solver(BaseSession):
         self._tui = None
         self._workflow = None
         self._system_coupling = None
-        self._settings_root = None
         self._fluent_version = None
         self._bg_session_threads = []
+
+        #: Root settings object.
+        self.settings = flobject.get_root(
+            flproxy=self._settings_service,
+            version=self._version,
+            interrupt=Solver._interrupt,
+            file_transfer_service=self._file_transfer_service,
+            scheme_eval=self.scheme_eval.scheme_eval,
+        )
         self._solution_variable_service = service_creator("svar").create(
             fluent_connection._channel, fluent_connection._metadata
         )
@@ -161,12 +156,12 @@ class Solver(BaseSession):
             )
         else:
             self.fields.reduction = reduction_old
-        self._settings_api_root = None
         self.fields.solution_variable_data = self._solution_variable_data()
 
         monitors_service = service_creator("monitors").create(
             fluent_connection._channel, fluent_connection._metadata, self._error_state
         )
+        #: Manage Fluent's solution monitors.
         self.monitors = MonitorsManager(fluent_connection._id, monitors_service)
         self.events.register_callback(
             (SolverEvent.SOLUTION_INITIALIZED, SolverEvent.DATA_LOADED),
@@ -269,19 +264,6 @@ class Solver(BaseSession):
             if command.path in interruptible_commands:
                 command._root.solution.run_calculation.interrupt()
 
-    @property
-    def settings(self):
-        """Root settings object."""
-        if self._settings_root is None:
-            self._settings_root = flobject.get_root(
-                flproxy=self._settings_service,
-                version=self._version,
-                interrupt=Solver._interrupt,
-                file_transfer_service=self._file_transfer_service,
-                scheme_eval=self.scheme_eval.scheme_eval,
-            )
-        return self._settings_root
-
     @property
     def system_coupling(self):
         """System coupling object."""
@@ -351,28 +333,23 @@ class Solver(BaseSession):
     def __call__(self):
         return self.get_state()
 
-    def _populate_settings_api_root(self):
-        if not self._settings_api_root:
-            self._settings_api_root = _import_settings_root(self.settings)
-
-    def __getattr__(self, attr):
-        self._populate_settings_api_root()
-        if attr in [x for x in dir(self._settings_api_root) if not x.startswith("_")]:
-            if self.get_fluent_version() > FluentVersion.v242:
+    def __getattr__(self, name):
+        try:
+            return super().__getattribute__(name)
+        except AttributeError as ex:
+            if name in self.settings.child_names:
                 warnings.warn(
-                    f"'{attr}' is deprecated. Use 'settings.{attr}' instead.",
+                    f"'{name}' is deprecated. Use 'settings.{name}' instead.",
                     DeprecatedSettingWarning,
                 )
-        return getattr(self._settings_api_root, attr)
+                return getattr(self.settings, name)
+            else:
+                raise ex
 
     def __dir__(self):
         if self._fluent_connection is None:
             return ["is_active"]
-        settings_dir = []
-        if self.get_fluent_version() <= FluentVersion.v242:
-            self._populate_settings_api_root()
-            settings_dir = dir(self._settings_api_root)
-        dir_list = set(list(self.__dict__.keys()) + dir(type(self)) + settings_dir) - {
+        dir_list = set(list(self.__dict__.keys()) + dir(type(self))) - {
             "svar_data",
             "svar_info",
             "reduction",

ansys/fluent/core/session_utilities.py

@@ -0,0 +1,429 @@
+# Copyright (C) 2021 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Session utilities."""
+
+from typing import Any, Dict
+
+import ansys.fluent.core as pyfluent
+from ansys.fluent.core.launcher.container_launcher import DockerLauncher
+from ansys.fluent.core.launcher.pim_launcher import PIMLauncher
+from ansys.fluent.core.launcher.pyfluent_enums import (
+    Dimension,
+    FluentLinuxGraphicsDriver,
+    FluentMode,
+    FluentWindowsGraphicsDriver,
+    Precision,
+    UIMode,
+)
+from ansys.fluent.core.launcher.standalone_launcher import StandaloneLauncher
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+
+
+class SessionBase:
+    """Base class for Fluent sessions.
+
+    This class is not intended to be used directly. Instead, use
+    the `from_connection`, `from_container`, `from_install`,
+    or `from_pim` functions to create a session.
+    """
+
+    _session_mode = {
+        "Meshing": FluentMode.MESHING,
+        "PureMeshing": FluentMode.PURE_MESHING,
+        "PrePost": FluentMode.PRE_POST,
+        "Solver": FluentMode.SOLVER,
+        "SolverAero": FluentMode.SOLVER_AERO,
+        "SolverIcing": FluentMode.SOLVER_ICING,
+    }
+
+    @classmethod
+    def from_install(
+        cls,
+        ui_mode: UIMode | str | None = None,
+        graphics_driver: (
+            FluentWindowsGraphicsDriver | FluentLinuxGraphicsDriver | str
+        ) = None,
+        product_version: FluentVersion | str | float | int | None = None,
+        dimension: Dimension | int | None = None,
+        precision: Precision | str | None = None,
+        processor_count: int | None = None,
+        journal_file_names: None | str | list[str] = None,
+        start_timeout: int = 60,
+        additional_arguments: str = "",
+        env: Dict[str, Any] = {},  # noqa: B006
+        cleanup_on_exit: bool = True,
+        dry_run: bool = False,
+        start_transcript: bool = True,
+        case_file_name: str | None = None,
+        case_data_file_name: str | None = None,
+        lightweight_mode: bool | None = None,
+        py: bool | None = None,
+        gpu: bool | None = None,
+        cwd: str | None = None,
+        fluent_path: str | None = None,
+        topy: str | list | None = None,
+        start_watchdog: bool | None = None,
+        file_transfer_service: Any | None = None,
+    ):
+        """
+        Launch a Fluent session in standalone mode.
+
+        Parameters
+        ----------
+        ui_mode : UIMode
+            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+        graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
+            Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
+            (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
+        product_version : FluentVersion or str or float or int, optional
+            Indicates the version of Ansys Fluent to launch. For example, to use version 2025 R1, pass
+            ``FluentVersion.v251``, ``"25.1.0"``, ``"25.1"``, ``25.1``, or ``251``. Defaults to ``None``,
+            which uses the newest installed version.
+        dimension : Dimension or int, optional
+            Specifies the geometric dimensionality of the Fluent simulation. Defaults to ``None``,
+            which corresponds to ``Dimension.THREE``. Acceptable values are from the ``Dimension`` enum
+            (``Dimension.TWO`` or ``Dimension.THREE``) or integers ``2`` and ``3``.
+        precision : Precision or str, optional
+            Defines the floating point precision. Defaults to ``None``, which corresponds to
+            ``Precision.DOUBLE``. Acceptable values are from the ``Precision`` enum (``Precision.SINGLE``
+            or ``Precision.DOUBLE``) or strings ``"single"`` and ``"double"``.
+        processor_count : int, optional
+            Specifies the number of processors to use. Defaults to ``None``, which uses 1 processor.
+            In job scheduler environments, this value limits the total number of allocated cores.
+        journal_file_names : str or list of str, optional
+            Path(s) to a Fluent journal file(s) that Fluent will execute. Defaults to ``None``.
+        start_timeout : int, optional
+            Maximum time in seconds allowed for connecting to the Fluent server. Defaults to 60 seconds.
+        additional_arguments : str, optional
+            Additional command-line arguments for Fluent, formatted as they would be on the command line.
+        env : dict[str, str], optional
+            A mapping for modifying environment variables in Fluent. Defaults to ``None``.
+        cleanup_on_exit : bool, optional
+            Determines whether to shut down the connected Fluent session when exiting PyFluent or calling
+            the session's `exit()` method. Defaults to True.
+        dry_run : bool, optional
+            If True, does not launch Fluent but prints configuration information instead. The `call()` method
+            returns a tuple containing the launch string and server info file name. Defaults to False.
+        start_transcript : bool, optional
+            Indicates whether to start streaming the Fluent transcript in the client. Defaults to True;
+            streaming can be controlled via `transcript.start()` and `transcript.stop()` methods on the session object.
+        case_file_name : str, optional
+            Name of the case file to read into the Fluent session. Defaults to None.
+        case_data_file_name : str, optional
+            Name of the case data file. If both case and data files are provided, they are read into the session.
+        lightweight_mode : bool, optional
+            If True, runs in lightweight mode where mesh settings are read into a background solver session,
+            replacing it once complete. This parameter is only applicable when `case_file_name` is provided; defaults to False.
+        py : bool, optional
+            If True, runs Fluent in Python mode. Defaults to None.
+        gpu : bool, optional
+            If True, starts Fluent with GPU Solver enabled.
+        cwd : str, optional
+            Working directory for the Fluent client.
+        fluent_path: str, optional
+            User-specified path for Fluent installation.
+        topy :  bool or str, optional
+            A flag indicating whether to write equivalent Python journals from provided journal files; can also specify
+            a filename for the new Python journal.
+        start_watchdog : bool, optional
+            When `cleanup_on_exit` is True, defaults to True; an independent watchdog process ensures that any local
+            GUI-less Fluent sessions started by PyFluent are properly closed when the current Python process ends.
+        file_transfer_service : Any
+            Service for uploading/downloading files to/from the server.
+
+        Raises
+        ------
+        UnexpectedKeywordArgument
+            If an unexpected keyword argument is provided.
+
+        Notes
+        -----
+        In job scheduler environments (e.g., SLURM, LSF, PBS), resources and compute nodes are allocated,
+        and core counts are queried from these environments before being passed to Fluent.
+        """
+        mode = cls._session_mode[cls.__name__]
+        argvals = locals().copy()
+        argvals.pop("cls", None)  # Remove the class reference from the arguments
+        launcher = StandaloneLauncher(**argvals)
+        return launcher()
+
+    @classmethod
+    def from_container(
+        cls,
+        ui_mode: UIMode | str | None = None,
+        graphics_driver: (
+            FluentWindowsGraphicsDriver | FluentLinuxGraphicsDriver | str | None
+        ) = None,
+        product_version: FluentVersion | str | float | int | None = None,
+        dimension: Dimension | int | None = None,
+        precision: Precision | str | None = None,
+        processor_count: int | None = None,
+        start_timeout: int = 60,
+        additional_arguments: str = "",
+        container_dict: dict | None = None,
+        dry_run: bool = False,
+        cleanup_on_exit: bool = True,
+        start_transcript: bool = True,
+        py: bool | None = None,
+        gpu: bool | None = None,
+        start_watchdog: bool | None = None,
+        file_transfer_service: Any | None = None,
+    ):
+        """
+        Launch a Fluent session in container mode.
+
+        Parameters
+        ----------
+        ui_mode : UIMode
+            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+        graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
+            Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
+            (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
+        product_version :  FluentVersion or str or float or int, optional
+            Indicates the version of Ansys Fluent to launch. For example, to use version 2025 R1, pass
+            any of ``FluentVersion.v251``, ``"25.1.0"``, ``"25.1"``, ``25.1``, or ``251``. Defaults to ``None``,
+            which uses the newest installed version.
+        dimension : Dimension or int, optional
+            Specifies the geometric dimensionality of the Fluent simulation. Defaults to ``None``,
+            which corresponds to ``Dimension.THREE``. Acceptable values include ``Dimension.TWO``,
+            ``Dimension.THREE``, or integers ``2`` and ``3``.
+        precision : Precision or str, optional
+            Defines the floating point precision. Defaults to ``None``, which corresponds to
+            ``Precision.DOUBLE``. Acceptable values include ``Precision.SINGLE``,
+            ``Precision.DOUBLE``, or strings ``"single"`` and ``"double"``.
+        processor_count : int, optional
+            Specifies the number of processors to use. Defaults to ``None``, which uses 1 processor.
+            In job scheduler environments, this value limits the total number of allocated cores.
+        start_timeout : int, optional
+            Maximum allowable time in seconds for connecting to the Fluent server. Defaults to 60 seconds.
+        additional_arguments : str, optional
+            Additional command-line arguments for Fluent, formatted as they would be on the command line.
+        container_dict : dict, optional
+            Configuration dictionary for launching Fluent inside a Docker container. See also
+            :mod:`~ansys.fluent.core.launcher.fluent_container`.
+        dry_run : bool, optional
+            If True, does not launch Fluent but prints configuration information instead. If dry running a
+            container start, this method will return the configured ``container_dict``. Defaults to False.
+        cleanup_on_exit : bool
+            Determines whether to shut down the connected Fluent session upon exit or when calling
+            the session's `exit()` method. Defaults to True.
+        start_transcript : bool
+            Indicates whether to start streaming the Fluent transcript in the client. Defaults to True;
+            streaming can be controlled via `transcript.start()` and `transcript.stop()` methods on the session object.
+        py : bool, optional
+            If True, runs Fluent in Python mode. Defaults to None.
+        gpu : bool, optional
+            If True, starts Fluent with GPU Solver enabled.
+        start_watchdog : bool, optional
+            If True and `cleanup_on_exit` is True, an independent watchdog process is run to ensure that any local
+            GUI-less Fluent sessions started by PyFluent are properly closed when the current Python process ends.
+        file_transfer_service : Any, optional
+            Service for uploading/downloading files to/from the server.
+
+        Returns
+        -------
+        Meshing | PureMeshing | Solver | SolverIcing | dict
+            Session object or configuration dictionary if ``dry_run`` is True.
+
+        Raises
+        ------
+        UnexpectedKeywordArgument
+            If an unexpected keyword argument is provided.
+
+        Notes
+        -----
+        In job scheduler environments (e.g., SLURM, LSF, PBS), resources and compute nodes are allocated,
+        and core counts are queried from these environments before being passed to Fluent.
+        """
+        mode = cls._session_mode[cls.__name__]
+        argvals = locals().copy()
+        argvals.pop("cls", None)
+        launcher = DockerLauncher(**argvals)
+        return launcher()
+
+    @classmethod
+    def from_pim(
+        cls,
+        graphics_driver: (
+            FluentWindowsGraphicsDriver | FluentLinuxGraphicsDriver | str | None
+        ) = None,
+        product_version: FluentVersion | str | float | int | None = None,
+        dimension: Dimension | int | None = None,
+        precision: Precision | str | None = None,
+        processor_count: int | None = None,
+        start_timeout: int = 60,
+        additional_arguments: str = "",
+        cleanup_on_exit: bool = True,
+        start_transcript: bool = True,
+        gpu: bool | None = None,
+        start_watchdog: bool | None = None,
+        file_transfer_service: Any | None = None,
+    ):
+        """
+        Launch a Fluent session in `PIM <https://pypim.docs.pyansys.com/version/stable/>`_ mode.
+
+        Parameters
+        ----------
+        graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
+            Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
+            (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
+        product_version : FluentVersion or str or float or int, optional
+            Indicates the version of Ansys Fluent to launch. For example, to use version 2025 R1, pass
+            any of ``FluentVersion.v251``, ``"25.1.0"``, ``"25.1"``, ``25.1``, or ``251``. Defaults to ``None``,
+            which uses the newest installed version.
+        dimension : Dimension or int, optional
+            Specifies the geometric dimensionality of the Fluent simulation. Defaults to ``None``,
+            which corresponds to ``Dimension.THREE``. Acceptable values include ``Dimension.TWO``,
+            ``Dimension.THREE``, or integers ``2`` and ``3``.
+        precision : Precision or str, optional
+            Defines the floating point precision. Defaults to ``None``, which corresponds to
+            ``Precision.DOUBLE``. Acceptable values include ``Precision.SINGLE``,
+            ``Precision.DOUBLE``, or strings ``"single"`` and ``"double"``.
+        processor_count : int, optional
+            Specifies the number of processors to use. Defaults to ``None``, which uses 1 processor.
+            In job scheduler environments, this value limits the total number of allocated cores.
+        start_timeout : int, optional
+            Maximum allowable time in seconds for connecting to the Fluent server. Defaults to 60 seconds.
+        additional_arguments : str, optional
+            Additional command-line arguments for Fluent, formatted as they would be on the command line.
+        cleanup_on_exit : bool
+            Determines whether to shut down the connected Fluent session upon exit or when calling
+            the session's `exit()` method. Defaults to True.
+        start_transcript : bool
+            Indicates whether to start streaming the Fluent transcript in the client. Defaults to True;
+            streaming can be controlled via `transcript.start()` and `transcript.stop()` methods on the session object.
+        gpu : bool, optional
+            If True, starts Fluent with GPU Solver enabled.
+        start_watchdog : bool, optional
+            If True and `cleanup_on_exit` is True, an independent watchdog process is run to ensure that any local
+            GUI-less Fluent sessions started by PyFluent are properly closed when the current Python process ends.
+        file_transfer_service : Any, optional
+            Service for uploading/downloading files to/from the server.
+
+        Returns
+        -------
+        Union[Meshing, PureMeshing, Solver, SolverIcing, dict]
+            Session object or configuration dictionary if ``dry_run`` is True.
+
+        Raises
+        ------
+        UnexpectedKeywordArgument
+            If an unexpected keyword argument is provided.
+
+        Notes
+        -----
+        In job scheduler environments (e.g., SLURM, LSF, PBS), resources and compute nodes are allocated,
+        and core counts are queried from these environments before being passed to Fluent.
+        """
+        mode = cls._session_mode[cls.__name__]
+        argvals = locals().copy()
+        argvals.pop("cls", None)
+        launcher = PIMLauncher(**argvals)
+        return launcher()
+
+    @classmethod
+    def from_connection(
+        cls,
+        ip: str | None = None,
+        port: int | None = None,
+        server_info_file_name: str | None = None,
+        password: str | None = None,
+    ):
+        """Connect to an existing Fluent server instance.
+
+        Parameters
+        ----------
+        ip : str, optional
+            IP address for connecting to an existing Fluent instance. The
+            IP address defaults to ``"127.0.0.1"``. You can also use the environment
+            variable ``PYFLUENT_FLUENT_IP=<ip>`` to set this parameter.
+            The explicit value of ``ip`` takes precedence over ``PYFLUENT_FLUENT_IP=<ip>``.
+        port : int, optional
+            Port to listen on for an existing Fluent instance. You can use the
+            environment variable ``PYFLUENT_FLUENT_PORT=<port>`` to set a default
+            value. The explicit value of ``port`` takes precedence over
+            ``PYFLUENT_FLUENT_PORT=<port>``.
+        server_info_file_name: str
+            Path to server-info file written out by Fluent server. The default is
+            ``None``. PyFluent uses the connection information in the file to
+            connect to a running Fluent session.
+        password : str, optional
+            Password to connect to existing Fluent instance.
+
+        Raises
+        ------
+        TypeError
+            If the session type does not match the expected session type.
+        """
+        session = pyfluent.connect_to_fluent(
+            ip=ip,
+            port=port,
+            server_info_file_name=server_info_file_name,
+            password=password,
+        )
+
+        expected = "Solver" if cls.__name__ == "PrePost" else cls.__name__
+        actual = session.__class__.__name__
+
+        if actual != expected:
+            raise TypeError(
+                f"Session type mismatch: expected {expected}, got {actual}."
+            )
+
+        return session
+
+
+class Meshing(SessionBase):
+    """Encapsulates a Fluent server for meshing session connection."""
+
+    pass
+
+
+class PureMeshing(SessionBase):
+    """Encapsulates a Fluent server for pure meshing session connection."""
+
+    pass
+
+
+class PrePost(SessionBase):
+    """Encapsulates a Fluent server for pre-post session connection."""
+
+    pass
+
+
+class Solver(SessionBase):
+    """Encapsulates a Fluent server for solver session connection."""
+
+    pass
+
+
+class SolverAero(SessionBase):
+    """Encapsulates a Fluent server for solver aero session connection."""
+
+    pass
+
+
+class SolverIcing(SessionBase):
+    """Encapsulates a Fluent server for solver icing session connection."""
+
+    pass