ansys-fluent-core 0.31.dev1__py3-none-any.whl → 0.32.dev0__py3-none-any.whl

ansys/fluent/core/generated/solver/tui_252.py

@@ -2436,12 +2436,14 @@ class main_menu(TUIMenu):
                         self.average_each_step = self.__class__.average_each_step(service, version, mode, path + ["average_each_step"])
                         self.average_kernel = self.__class__.average_kernel(service, version, mode, path + ["average_kernel"])
                         self.average_source_terms = self.__class__.average_source_terms(service, version, mode, path + ["average_source_terms"])
+                        self.consider_pressure_drho_dt = self.__class__.consider_pressure_drho_dt(service, version, mode, path + ["consider_pressure_drho_dt"])
                         self.coupled_heat_mass_update = self.__class__.coupled_heat_mass_update(service, version, mode, path + ["coupled_heat_mass_update"])
                         self.drag_law = self.__class__.drag_law(service, version, mode, path + ["drag_law"])
                         self.dynamic_interaction = self.__class__.dynamic_interaction(service, version, mode, path + ["dynamic_interaction"])
                         self.enable_node_based_averaging = self.__class__.enable_node_based_averaging(service, version, mode, path + ["enable_node_based_averaging"])
                         self.enhanced_packing_limit_numerics = self.__class__.enhanced_packing_limit_numerics(service, version, mode, path + ["enhanced_packing_limit_numerics"])
                         self.error_control = self.__class__.error_control(service, version, mode, path + ["error_control"])
+                        self.fluid_formulation_momentum = self.__class__.fluid_formulation_momentum(service, version, mode, path + ["fluid_formulation_momentum"])
                         self.gaussian_factor = self.__class__.gaussian_factor(service, version, mode, path + ["gaussian_factor"])
                         self.granular_stress_tensor = self.__class__.granular_stress_tensor(service, version, mode, path + ["granular_stress_tensor"])
                         self.limit_granular_forces = self.__class__.limit_granular_forces(service, version, mode, path + ["limit_granular_forces"])
@@ -2452,6 +2454,7 @@ class main_menu(TUIMenu):
                         self.predictor_corrector = self.__class__.predictor_corrector(service, version, mode, path + ["predictor_corrector"])
                         self.re_randomize_every_iteration = self.__class__.re_randomize_every_iteration(service, version, mode, path + ["re_randomize_every_iteration"])
                         self.re_randomize_every_timestep = self.__class__.re_randomize_every_timestep(service, version, mode, path + ["re_randomize_every_timestep"])
+                        self.set_overpacking_force_model = self.__class__.set_overpacking_force_model(service, version, mode, path + ["set_overpacking_force_model"])
                         self.source_terms_cell_cloud_limit = self.__class__.source_terms_cell_cloud_limit(service, version, mode, path + ["source_terms_cell_cloud_limit"])
                         self.tracking_parameters = self.__class__.tracking_parameters(service, version, mode, path + ["tracking_parameters"])
                         self.tracking_scheme = self.__class__.tracking_scheme(service, version, mode, path + ["tracking_scheme"])
@@ -2459,6 +2462,7 @@ class main_menu(TUIMenu):
                         self.underrelax_film_height = self.__class__.underrelax_film_height(service, version, mode, path + ["underrelax_film_height"])
                         self.use_advanced_settings_for_epln = self.__class__.use_advanced_settings_for_epln(service, version, mode, path + ["use_advanced_settings_for_epln"])
                         self.use_cell_based_vof_for_epln = self.__class__.use_cell_based_vof_for_epln(service, version, mode, path + ["use_cell_based_vof_for_epln"])
+                        self.use_improved_limiters = self.__class__.use_improved_limiters(service, version, mode, path + ["use_improved_limiters"])
                         self.vaporization_limiting_factors = self.__class__.vaporization_limiting_factors(service, version, mode, path + ["vaporization_limiting_factors"])
                         self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                         super().__init__(service, version, mode, path)
@@ -2482,6 +2486,10 @@ class main_menu(TUIMenu):
                         """
                         No help available.
                         """
+                    class consider_pressure_drho_dt(TUIMethod):
+                        """
+                        Consider drho/dt term in pressure correction equation.
+                        """
                     class coupled_heat_mass_update(TUIMethod):
                         """
                         Enable/disable coupled heat and mass update.
@@ -2506,6 +2514,10 @@ class main_menu(TUIMenu):
                         """
                         Set the adapt integration step length based on a maximum error.
                         """
+                    class fluid_formulation_momentum(TUIMethod):
+                        """
+                        Compute momemtum sources based on fluid force formulation instead of change of momentum between entry and exit of cell.
+                        """
                     class gaussian_factor(TUIMethod):
                         """
                         No help available.
@@ -2546,6 +2558,10 @@ class main_menu(TUIMenu):
                         """
                         Decide whether pseudo-random number sequences shall vary from timestep to timestep or not.
                         """
+                    class set_overpacking_force_model(TUIMethod):
+                        """
+                        Set overpacking force model (0 = off, 1 = enabled.
+                        """
                     class source_terms_cell_cloud_limit(TUIMethod):
                         """
                         Limiting particle source terms based on minimum of particle cloud volume and cell volume.
@@ -2574,6 +2590,10 @@ class main_menu(TUIMenu):
                         """
                         Use cell based VOF for enhanced packing limit numerics.
                         """
+                    class use_improved_limiters(TUIMethod):
+                        """
+                        Use improved limiters in combination with granular force limiting.
+                        """
                     class vaporization_limiting_factors(TUIMethod):
                         """
                         Set Vaporization Fractional Change Limits.
@@ -14012,7 +14032,7 @@ class main_menu(TUIMenu):
             self.read_case = self.__class__.read_case(service, version, mode, path + ["read_case"])
             self.read_case_data = self.__class__.read_case_data(service, version, mode, path + ["read_case_data"])
             self.read_case_info = self.__class__.read_case_info(service, version, mode, path + ["read_case_info"])
-            self.read_case_settings = self.__class__.read_case_settings(service, version, mode, path + ["read_case_settings"])
+            self.read_case_lightweight = self.__class__.read_case_lightweight(service, version, mode, path + ["read_case_lightweight"])
             self.read_data = self.__class__.read_data(service, version, mode, path + ["read_data"])
             self.read_field_functions = self.__class__.read_field_functions(service, version, mode, path + ["read_field_functions"])
             self.read_injections = self.__class__.read_injections(service, version, mode, path + ["read_injections"])
@@ -14122,7 +14142,7 @@ class main_menu(TUIMenu):
             """
             Read basic case info.
             """
-        class read_case_settings(TUIMethod):
+        class read_case_lightweight(TUIMethod):
             """
             Read a case file while skipping mesh elements.
             """
@@ -31432,6 +31452,7 @@ class main_menu(TUIMenu):
                 self.overset = self.__class__.overset(service, version, mode, path + ["overset"])
                 self.p_v_coupling = self.__class__.p_v_coupling(service, version, mode, path + ["p_v_coupling"])
                 self.phase_based_vof_discretization = self.__class__.phase_based_vof_discretization(service, version, mode, path + ["phase_based_vof_discretization"])
+                self.poor_mesh_robustness = self.__class__.poor_mesh_robustness(service, version, mode, path + ["poor_mesh_robustness"])
                 self.pseudo_time_method = self.__class__.pseudo_time_method(service, version, mode, path + ["pseudo_time_method"])
                 self.reduced_rank_extrapolation_options = self.__class__.reduced_rank_extrapolation_options(service, version, mode, path + ["reduced_rank_extrapolation_options"])
                 self.spatial_discretization = self.__class__.spatial_discretization(service, version, mode, path + ["spatial_discretization"])
@@ -32687,6 +32708,89 @@ class main_menu(TUIMenu):
                     No help available.
                     """
 
+            class poor_mesh_robustness(TUIMenu):
+                """
+                No help available.
+                """
+                def __init__(self, service, version, mode, path):
+                    self.poor_mesh_numerics = self.__class__.poor_mesh_numerics(service, version, mode, path + ["poor_mesh_numerics"])
+                    self.poor_mesh_removal = self.__class__.poor_mesh_removal(service, version, mode, path + ["poor_mesh_removal"])
+                    super().__init__(service, version, mode, path)
+
+                class poor_mesh_numerics(TUIMenu):
+                    """
+                    No help available.
+                    """
+                    def __init__(self, service, version, mode, path):
+                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
+                        self.orthogonal_quality_threshold = self.__class__.orthogonal_quality_threshold(service, version, mode, path + ["orthogonal_quality_threshold"])
+                        self.orthogonal_quality_threshold_enabled = self.__class__.orthogonal_quality_threshold_enabled(service, version, mode, path + ["orthogonal_quality_threshold_enabled"])
+                        self.tangent_skewness_threshold = self.__class__.tangent_skewness_threshold(service, version, mode, path + ["tangent_skewness_threshold"])
+                        self.tangent_skewness_threshold_enabled = self.__class__.tangent_skewness_threshold_enabled(service, version, mode, path + ["tangent_skewness_threshold_enabled"])
+                        super().__init__(service, version, mode, path)
+                    class enable(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class orthogonal_quality_threshold(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class orthogonal_quality_threshold_enabled(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class tangent_skewness_threshold(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class tangent_skewness_threshold_enabled(TUIMethod):
+                        """
+                        No help available.
+                        """
+
+                class poor_mesh_removal(TUIMenu):
+                    """
+                    No help available.
+                    """
+                    def __init__(self, service, version, mode, path):
+                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
+                        self.orthogonal_quality_threshold = self.__class__.orthogonal_quality_threshold(service, version, mode, path + ["orthogonal_quality_threshold"])
+                        self.orthogonal_quality_threshold_enabled = self.__class__.orthogonal_quality_threshold_enabled(service, version, mode, path + ["orthogonal_quality_threshold_enabled"])
+                        self.tangent_skewness_threshold = self.__class__.tangent_skewness_threshold(service, version, mode, path + ["tangent_skewness_threshold"])
+                        self.tangent_skewness_threshold_enabled = self.__class__.tangent_skewness_threshold_enabled(service, version, mode, path + ["tangent_skewness_threshold_enabled"])
+                        self.warpage_threshold = self.__class__.warpage_threshold(service, version, mode, path + ["warpage_threshold"])
+                        self.warpage_threshold_enabled = self.__class__.warpage_threshold_enabled(service, version, mode, path + ["warpage_threshold_enabled"])
+                        super().__init__(service, version, mode, path)
+                    class enable(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class orthogonal_quality_threshold(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class orthogonal_quality_threshold_enabled(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class tangent_skewness_threshold(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class tangent_skewness_threshold_enabled(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class warpage_threshold(TUIMethod):
+                        """
+                        No help available.
+                        """
+                    class warpage_threshold_enabled(TUIMethod):
+                        """
+                        No help available.
+                        """
+
             class pseudo_time_method(TUIMenu):
                 """
                 No help available.
@@ -39199,6 +39303,10 @@ class main_menu(TUIMenu):
                         self.global_exterma_tracker = self.__class__.global_exterma_tracker(service, version, mode, path + ["global_exterma_tracker"])
                         self.inspector = self.__class__.inspector(service, version, mode, path + ["inspector"])
                         self.local_divergence_tracker = self.__class__.local_divergence_tracker(service, version, mode, path + ["local_divergence_tracker"])
+                        self.mark_cell_neighbors_by_id = self.__class__.mark_cell_neighbors_by_id(service, version, mode, path + ["mark_cell_neighbors_by_id"])
+                        self.mark_cell_neighbors_by_register = self.__class__.mark_cell_neighbors_by_register(service, version, mode, path + ["mark_cell_neighbors_by_register"])
+                        self.report_cell_info_by_id = self.__class__.report_cell_info_by_id(service, version, mode, path + ["report_cell_info_by_id"])
+                        self.report_cell_info_by_register = self.__class__.report_cell_info_by_register(service, version, mode, path + ["report_cell_info_by_register"])
                         super().__init__(service, version, mode, path)
                     class clear_divergence_tracker_files(TUIMethod):
                         """
@@ -39220,6 +39328,22 @@ class main_menu(TUIMenu):
                         """
                         Stop simulation after divergence incident detected.
                         """
+                    class mark_cell_neighbors_by_id(TUIMethod):
+                        """
+                        Mark cells' neighbors based on cell ids.
+                        """
+                    class mark_cell_neighbors_by_register(TUIMethod):
+                        """
+                        Mark cells' neighbors based on the provided id or name of a register.
+                        """
+                    class report_cell_info_by_id(TUIMethod):
+                        """
+                        Report cells information based on cell ids.
+                        """
+                    class report_cell_info_by_register(TUIMethod):
+                        """
+                        Report cells information based on the provided id or name of a register.
+                        """
 
             class transient_controls(TUIMenu):
                 """

ansys/fluent/core/launcher/container_launcher.py

@@ -38,6 +38,7 @@ Examples
 import inspect
 import logging
 import os
+import time
 from typing import Any
 
 from ansys.fluent.core.fluent_connection import FluentConnection
@@ -45,6 +46,7 @@ from ansys.fluent.core.launcher.fluent_container import (
     configure_container_dict,
     start_fluent_container,
 )
+from ansys.fluent.core.launcher.launcher_utils import is_compose
 from ansys.fluent.core.launcher.process_launch_string import (
     _build_fluent_launch_args_string,
 )
@@ -58,6 +60,7 @@ from ansys.fluent.core.launcher.pyfluent_enums import (
     _get_argvals_and_session,
 )
 import ansys.fluent.core.launcher.watchdog as watchdog
+from ansys.fluent.core.session import _parse_server_info_file
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 _THIS_DIR = os.path.dirname(__file__)
@@ -65,6 +68,21 @@ _OPTIONS_FILE = os.path.join(_THIS_DIR, "fluent_launcher_options.json")
 logger = logging.getLogger("pyfluent.launcher")
 
 
+def _get_server_info_from_container(config_dict):
+    """Retrieve the server info from a specified file in a container."""
+
+    host_server_info_file = config_dict["host_server_info_file"]
+
+    time_limit = 0
+    while not host_server_info_file.exists():
+        time.sleep(2)
+        time_limit += 2
+        if time_limit > 60:
+            raise FileNotFoundError(f"{host_server_info_file} not found.")
+
+    return _parse_server_info_file(str(host_server_info_file))
+
+
 class DockerLauncher:
     """Instantiates Fluent session in container mode."""
 
@@ -198,9 +216,16 @@ class DockerLauncher:
                 del config_dict_h
             return config_dict
 
-        port, password, container = start_fluent_container(
-            self._args, self.argvals["container_dict"]
-        )
+        if is_compose():
+            port, config_dict, container = start_fluent_container(
+                self._args, self.argvals["container_dict"]
+            )
+
+            _, _, password = _get_server_info_from_container(config_dict=config_dict)
+        else:
+            port, password, container = start_fluent_container(
+                self._args, self.argvals["container_dict"]
+            )
 
         fluent_connection = FluentConnection(
             port=port,
@@ -209,6 +234,7 @@ class DockerLauncher:
             cleanup_on_exit=self.argvals["cleanup_on_exit"],
             slurm_job_id=self.argvals and self.argvals.get("slurm_job_id"),
             inside_container=True,
+            container=container,
         )
 
         session = self.new_session(
@@ -217,12 +243,17 @@ class DockerLauncher:
             file_transfer_service=self.file_transfer_service,
             start_transcript=self.argvals["start_transcript"],
         )
+
         session._container = container
 
-        if self.argvals["start_watchdog"] is None and self.argvals["cleanup_on_exit"]:
-            self.argvals["start_watchdog"] = True
-        if self.argvals["start_watchdog"]:
-            logger.debug("Launching Watchdog for Fluent container...")
-            watchdog.launch(os.getpid(), port, password)
+        if not is_compose():
+            if (
+                self.argvals["start_watchdog"] is None
+                and self.argvals["cleanup_on_exit"]
+            ):
+                self.argvals["start_watchdog"] = True
+            if self.argvals["start_watchdog"]:
+                logger.debug("Launching Watchdog for Fluent container...")
+                watchdog.launch(os.getpid(), port, password)
 
         return session

ansys/fluent/core/launcher/fluent_container.py

@@ -78,8 +78,10 @@ import tempfile
 from typing import Any, List
 
 import ansys.fluent.core as pyfluent
+from ansys.fluent.core.docker.docker_compose import ComposeBasedLauncher
+from ansys.fluent.core.launcher.launcher_utils import is_compose
 from ansys.fluent.core.session import _parse_server_info_file
-from ansys.fluent.core.utils.deprecate import deprecate_argument
+from ansys.fluent.core.utils.deprecate import all_deprecators
 from ansys.fluent.core.utils.execution import timeout_loop
 from ansys.fluent.core.utils.networking import get_free_port
 
@@ -116,8 +118,24 @@ class LicenseServerNotSpecified(KeyError):
         )
 
 
-@deprecate_argument("container_mount_path", "mount_target")
-@deprecate_argument("host_mount_path", "mount_source")
+@all_deprecators(
+    deprecate_arg_mappings=[
+        {
+            "old_arg": "container_mount_path",
+            "new_arg": "mount_target",
+            "converter": lambda old_arg_val: old_arg_val,
+        },
+        {
+            "old_arg": "host_mount_path",
+            "new_arg": "mount_source",
+            "converter": lambda old_arg_val: old_arg_val,
+        },
+    ],
+    data_type_converter=None,
+    deprecated_version="v0.23.dev1",
+    deprecated_reason="'container_mount_path' and 'host_mount_path' are deprecated. Use 'mount_target' and 'mount_source' instead.",
+    warn_message="",
+)
 def configure_container_dict(
     args: List[str],
     mount_source: str | Path | None = None,
@@ -381,6 +399,11 @@ def configure_container_dict(
 
     host_server_info_file = Path(mount_source) / container_server_info_file.name
 
+    if is_compose():
+        container_dict["host_server_info_file"] = host_server_info_file
+        container_dict["mount_source"] = mount_source
+        container_dict["mount_target"] = mount_target
+
     return (
         container_dict,
         timeout,
@@ -451,34 +474,49 @@ def start_fluent_container(
         del container_vars_tmp
 
     try:
-        if not host_server_info_file.exists():
-            host_server_info_file.parents[0].mkdir(exist_ok=True)
+        if is_compose():
+            config_dict["fluent_port"] = port
 
-        host_server_info_file.touch(exist_ok=True)
-        last_mtime = host_server_info_file.stat().st_mtime
+            compose_container = ComposeBasedLauncher(container_dict=config_dict)
 
-        import docker
+            if not compose_container.check_image_exists():
+                logger.debug(
+                    f"Fluent image {config_dict['fluent_image']} not found. Pulling image..."
+                )
+                compose_container.pull_image()
 
-        docker_client = docker.from_env()
+            compose_container.start()
 
-        logger.debug("Starting Fluent docker container...")
+            return port, config_dict, compose_container
+        else:
+            if not host_server_info_file.exists():
+                host_server_info_file.parents[0].mkdir(exist_ok=True)
 
-        container = docker_client.containers.run(
-            config_dict.pop("fluent_image"), **config_dict
-        )
+            host_server_info_file.touch(exist_ok=True)
+            last_mtime = host_server_info_file.stat().st_mtime
 
-        success = timeout_loop(
-            lambda: host_server_info_file.stat().st_mtime > last_mtime, timeout
-        )
+            import docker
+
+            docker_client = docker.from_env()
 
-        if not success:
-            raise TimeoutError(
-                "Fluent container launch has timed out, stop container manually."
+            logger.debug("Starting Fluent docker container...")
+
+            container = docker_client.containers.run(
+                config_dict.pop("fluent_image"), **config_dict
             )
-        else:
-            _, _, password = _parse_server_info_file(str(host_server_info_file))
 
-            return port, password, container
+            success = timeout_loop(
+                lambda: host_server_info_file.stat().st_mtime > last_mtime, timeout
+            )
+
+            if not success:
+                raise TimeoutError(
+                    "Fluent container launch has timed out, stop container manually."
+                )
+            else:
+                _, _, password = _parse_server_info_file(str(host_server_info_file))
+
+                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

@@ -54,12 +54,11 @@ from ansys.fluent.core.launcher.server_info import _get_server_info
 from ansys.fluent.core.launcher.slurm_launcher import SlurmFuture, SlurmLauncher
 from ansys.fluent.core.launcher.standalone_launcher import StandaloneLauncher
 import ansys.fluent.core.launcher.watchdog as watchdog
-from ansys.fluent.core.pyfluent_warnings import PyFluentDeprecationWarning
 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.deprecate import deprecate_argument
+from ansys.fluent.core.utils.deprecate import all_deprecators
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 _THIS_DIR = os.path.dirname(__file__)
@@ -127,17 +126,23 @@ def _version_to_dimension(old_arg_val):
 
 
 #   pylint: disable=unused-argument
-@deprecate_argument(
-    old_arg="show_gui",
-    new_arg="ui_mode",
-    converter=_show_gui_to_ui_mode,
-    warning_cls=PyFluentDeprecationWarning,
-)
-@deprecate_argument(
-    old_arg="version",
-    new_arg="dimension",
-    converter=_version_to_dimension,
-    warning_cls=PyFluentDeprecationWarning,
+@all_deprecators(
+    deprecate_arg_mappings=[
+        {
+            "old_arg": "show_gui",
+            "new_arg": "ui_mode",
+            "converter": _show_gui_to_ui_mode,
+        },
+        {
+            "old_arg": "version",
+            "new_arg": "dimension",
+            "converter": _version_to_dimension,
+        },
+    ],
+    data_type_converter=None,
+    deprecated_version="v0.22.dev0",
+    deprecated_reason="'show_gui' and 'version' are deprecated. Use 'ui_mode' and 'dimension' instead.",
+    warn_message="",
 )
 def launch_fluent(
     product_version: FluentVersion | str | float | int | None = None,
@@ -179,6 +184,12 @@ def launch_fluent(
         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.
+        PyFluent uses the ``AWP_ROOT<ver>`` environment variable to locate the Fluent
+        installation, where ``<ver>`` is the Ansys release number such as ``251``.
+        The ``AWP_ROOT<ver>`` environment variable is automatically configured on Windows
+        system when Fluent is installed. On Linux systems, ``AWP_ROOT<ver>`` must be
+        configured to point to the absolute path of an Ansys installation such as
+        ``/apps/ansys_inc/v251``.
     dimension : Dimension or int, optional
         Geometric dimensionality of the Fluent simulation. The default is ``None``,
         in which case ``Dimension.THREE`` is used. Options are either the values of the

ansys/fluent/core/launcher/launcher_utils.py

@@ -37,6 +37,14 @@ from ansys.fluent.core.utils.networking import find_remoting_ip
 logger = logging.getLogger("pyfluent.launcher")
 
 
+def is_compose() -> bool:
+    """Check if the Fluent launch is through compose."""
+    return (
+        os.getenv("PYFLUENT_USE_DOCKER_COMPOSE") == "1"
+        or os.getenv("PYFLUENT_USE_PODMAN_COMPOSE") == "1"
+    )
+
+
 def is_windows():
     """Check if the current operating system is Windows."""
     return platform.system() == "Windows"

ansys/fluent/core/launcher/process_launch_string.py

@@ -150,10 +150,6 @@ def get_fluent_exe_path(**launch_argvals) -> 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"
@@ -171,7 +167,7 @@ def get_fluent_exe_path(**launch_argvals) -> 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)))
+        return FluentVersion(product_version).get_fluent_exe_path()
 
     # (DEV) "PYFLUENT_FLUENT_ROOT" environment variable
     fluent_root = os.getenv("PYFLUENT_FLUENT_ROOT")
@@ -179,4 +175,4 @@ def get_fluent_exe_path(**launch_argvals) -> Path:
         return get_exe_path(Path(fluent_root))
 
     # 3. the latest ANSYS version from AWP_ROOT environment variables
-    return get_exe_path(get_fluent_root(FluentVersion.get_latest_installed()))
+    return FluentVersion.get_latest_installed().get_fluent_exe_path()

ansys/fluent/core/report.py

@@ -56,6 +56,8 @@ ANSYS_ENV_VARS = [
     "REMOTING_PORTS",
     "REMOTING_SERVER_ADDRESS",
     "SERVER_INFO_DIR",
+    "PYFLUENT_USE_DOCKER_COMPOSE",
+    "PYFLUENT_USE_PODMAN_COMPOSE",
 ]