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

ansys/fluent/core/systemcoupling.py

@@ -44,10 +44,9 @@ class SystemCoupling:
     def __init__(self, solver):
         self._solver = solver
         # version check - this requires Fluent 2024 R1 or newer.
-        current_fluent_version = FluentVersion(self._solver.get_fluent_version())
-        if current_fluent_version < FluentVersion.v241:
+        if self._solver.get_fluent_version() < FluentVersion.v241:
             raise RuntimeError(
-                f"Fluent version is {current_fluent_version.value}. PySystemCoupling integration requires Fluent 24.1.0 or later."
+                f"Fluent version is {self._solver.get_fluent_version().value}. PySystemCoupling integration requires Fluent {FluentVersion.v241.value} or later."
             )
 
     @property

ansys/fluent/core/utils/fluent_version.py

@@ -30,7 +30,7 @@ def get_version(session=None):
             return image_tag.lstrip("v")
         session = pyfluent.launch_fluent(mode="solver")
 
-    return session.get_fluent_version()
+    return session.get_fluent_version().value
 
 
 def get_version_for_file_name(version: Optional[str] = None, session=None):
@@ -123,3 +123,7 @@ class FluentVersion(Enum):
         if isinstance(other, FluentVersion):
             return self.value < other.value
         raise ComparisonError()
+
+    def __repr__(self) -> str:
+        """Return a string representation for the Fluent version."""
+        return self.value

ansys/fluent/core/utils/search.py

@@ -60,11 +60,11 @@ def _get_version_path_prefix_from_obj(obj: Any):
     prefix = None
     if isinstance(obj, PureMeshing):
         path = ["<meshing_session>"]
-        version = get_version_for_file_name(obj.get_fluent_version())
+        version = get_version_for_file_name(obj.get_fluent_version().value)
         prefix = "<search_root>"
     elif isinstance(obj, Solver):
         path = ["<solver_session>"]
-        version = get_version_for_file_name(obj.get_fluent_version())
+        version = get_version_for_file_name(obj.get_fluent_version().value)
         prefix = "<search_root>"
     elif isinstance(obj, TUIMenu):
         module = obj.__class__.__module__

ansys/fluent/core/warnings.py

@@ -0,0 +1,4 @@
+class PyFluentDeprecationWarning(FutureWarning):
+    """Provides the common warning class for all deprecated PyFluent feature."""
+
+    pass

ansys/fluent/tests/integration/test_optislang/test_optislang_integration.py

@@ -7,6 +7,7 @@ from util.meshing_workflow import mixing_elbow_geometry  # noqa: F401
 
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core import examples
+from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
 @pytest.mark.nightly
@@ -49,7 +50,7 @@ def test_simple_solve(load_mixing_elbow_param_case_dat):
     solver_session.tui.file.read_case(case_path)
 
     # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if float(solver_session.get_fluent_version()[:-2]) < 23.0:
+    if solver_session.get_fluent_version() < FluentVersion.v231:
         input_parameters = input_parameters["inlet2_temp"]
         output_parameters = output_parameters["outlet_temp-op"]
 
@@ -133,7 +134,7 @@ def test_generate_read_mesh(mixing_elbow_geometry):
         os.mkdir(temporary_resource_path)
 
     # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if float(meshing.get_fluent_version()[:-2]) < 23.0:
+    if meshing.get_fluent_version() < FluentVersion.v231:
         # Step 3 Generate mesh from geometry with default workflow settings
         meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
         geo_import = meshing.workflow.TaskObject["Import Geometry"]

ansys/fluent/tests/test_cad_to_post_ftm.py

@@ -25,6 +25,8 @@ from util.meshing_workflow import (  # noqa: F401
 )
 from util.solver import check_report_definition_result
 
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+
 
 @pytest.mark.nightly
 @pytest.mark.codegen_required
@@ -433,7 +435,7 @@ def test_exhaust_system(new_fault_tolerant_workflow_session, exhaust_system_geom
     ###############################################################################
     # Check the mesh in Meshing mode
     # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if float(meshing_session.get_fluent_version()[:-2]) < 23.0:
+    if meshing_session.get_fluent_version() < FluentVersion.v231:
         meshing_session.tui.mesh.check_mesh()
 
     ###############################################################################
@@ -456,7 +458,7 @@ def test_exhaust_system(new_fault_tolerant_workflow_session, exhaust_system_geom
     # Set the velocity and turbulence boundary conditions for the first inlet
     # (inlet-1).
     # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if float(meshing_session.get_fluent_version()[:-2]) < 23.0:
+    if meshing_session.get_fluent_version() < FluentVersion.v231:
         boundary_conditions = tui.define.boundary_conditions
         boundary_conditions.set.velocity_inlet("inlet-1", [], "vmag", "no", 1, "quit")
         ###############################################################################

ansys/fluent/tests/test_cad_to_post_wtm.py

@@ -27,6 +27,8 @@ from util.meshing_workflow import (  # noqa: F401
 )
 from util.solver import check_report_definition_result
 
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+
 
 @pytest.mark.nightly
 @pytest.mark.codegen_required
@@ -129,7 +131,7 @@ def test_mixing_elbow(new_watertight_workflow_session, mixing_elbow_geometry):
     ###############################################################################
     # Check the mesh in Meshing mode
     # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if float(meshing_session.get_fluent_version()[:-2]) < 23.0:
+    if meshing_session.get_fluent_version() < FluentVersion.v231:
         meshing_session.tui.mesh.check_mesh()
 
     ###############################################################################
@@ -157,7 +159,7 @@ def test_mixing_elbow(new_watertight_workflow_session, mixing_elbow_geometry):
     # Set up the cell zone conditions for the fluid zone (elbow-fluid). Select
     # water-liquid from the Material list.
     # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if float(solver_session.get_fluent_version()[:-2]) < 23.0:
+    if solver_session.get_fluent_version() < FluentVersion.v231:
         define.boundary_conditions.fluid(
             "elbow-fluid",
             "yes",

ansys/fluent/tests/test_flobject.py

@@ -12,6 +12,7 @@ from util.solver_workflow import new_solver_session_no_transcript  # noqa: F401
 from ansys.fluent.core.examples import download_file
 from ansys.fluent.core.solver import flobject
 from ansys.fluent.core.solver.flobject import InactiveObjectError, find_children
+from ansys.fluent.core.utils.fluent_version import FluentVersion
 import ansys.units
 
 
@@ -667,7 +668,7 @@ def test_accessor_methods_on_settings_object(load_static_mixer_settings_only):
     modified = velocity_inlet.user_creatable()
     assert existing == modified
 
-    if solver.get_fluent_version() < "24.2.0":
+    if solver.get_fluent_version() < FluentVersion.v242:
         turbulent_viscosity_ratio = velocity_inlet[
             "inlet1"
         ].turbulence.turbulent_viscosity_ratio_real
@@ -698,7 +699,7 @@ def test_accessor_methods_on_settings_object(load_static_mixer_settings_only):
     assert count_key_recursive(default_attrs, "default") > 5
 
     mesh = solver.results.graphics.mesh.create("mesh-1")
-    if solver.get_fluent_version() < "24.2.0":
+    if solver.get_fluent_version() < FluentVersion.v242:
         assert mesh.name.is_read_only()
     else:
         assert not mesh.name.is_read_only()
@@ -708,9 +709,8 @@ def test_accessor_methods_on_settings_object(load_static_mixer_settings_only):
     solver.results.graphics.mesh["mesh-1"].rename("mesh_new")
     assert solver.results.graphics.mesh.get_object_names() == ["mesh_new"]
 
-    if solver.get_fluent_version() >= "24.2.0":
-        solver.results.graphics.mesh.rename(new="mesh_242", old="mesh_new")
-        assert solver.results.graphics.mesh.get_object_names() == ["mesh_242"]
+    solver.results.graphics.mesh.rename(new="mesh_242", old="mesh_new")
+    assert solver.results.graphics.mesh.get_object_names() == ["mesh_242"]
 
 
 @pytest.mark.fluent_version("latest")
@@ -725,7 +725,7 @@ def test_accessor_methods_on_settings_object_types(load_static_mixer_settings_on
     accuracy_control = (
         solver.setup.models.discrete_phase.numerics.tracking.accuracy_control
     )
-    if solver.get_fluent_version() < "24.1.0":
+    if solver.get_fluent_version() < FluentVersion.v241:
         max_refinements = accuracy_control.max_number_of_refinements
     else:
         max_refinements = accuracy_control.max_num_refinements
@@ -799,7 +799,7 @@ def test_find_children_from_fluent_solver_session(load_static_mixer_settings_onl
         if path.endswith("geom_dir_spec")
     )
 
-    if load_static_mixer_settings_only.get_fluent_version() < "24.2.0":
+    if load_static_mixer_settings_only.get_fluent_version() < FluentVersion.v242:
         assert set(
             find_children(
                 load_mixer.materials.fluid["air"].density.piecewise_polynomial
@@ -1037,6 +1037,7 @@ def test_ansys_units_integration(load_mixing_elbow_mesh):
     assert hot_inlet.momentum.velocity.value.state_with_units() == velocity
     velocity = ansys.units.Quantity(12.0, "m s^-1")
     hot_inlet.momentum.velocity = velocity
+    assert hot_inlet.momentum.velocity.value() == velocity.value
     assert hot_inlet.momentum.velocity.value.as_quantity() == velocity
     assert hot_inlet.momentum.velocity.state_with_units() == {
         "option": "value",
@@ -1087,6 +1088,30 @@ def test_ansys_units_integration_nested_state(load_mixing_elbow_mesh):
     }
 
 
+@pytest.mark.fluent_version(">=24.2")
+def test_bug_1001124_quantity_assignment(load_mixing_elbow_mesh):
+    speed = ansys.units.Quantity(100, "m s^-1")
+    solver = load_mixing_elbow_mesh
+    solver.setup.boundary_conditions.velocity_inlet[
+        "hot-inlet"
+    ].momentum.velocity.value = speed.value
+    assert (
+        solver.setup.boundary_conditions.velocity_inlet[
+            "hot-inlet"
+        ].momentum.velocity.value()
+        == speed.value
+    )
+    solver.setup.boundary_conditions.velocity_inlet["hot-inlet"].momentum.velocity = (
+        speed
+    )
+    assert (
+        solver.setup.boundary_conditions.velocity_inlet[
+            "hot-inlet"
+        ].momentum.velocity.value()
+        == speed.value
+    )
+
+
 def test_assert_type():
     types = [
         bool,

ansys/fluent/tests/test_fluent_session.py

@@ -15,15 +15,15 @@ from util.solver_workflow import (  # noqa: F401
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.examples import download_file
 from ansys.fluent.core.fluent_connection import WaitTypeError, get_container
-from ansys.fluent.core.launcher.launcher_utils import IpPortNotProvided
+from ansys.fluent.core.launcher.error_handler import IpPortNotProvided
 from ansys.fluent.core.utils.execution import asynchronous, timeout_loop
+from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
 def _read_case(session, lightweight_setup=True):
     case_path = download_file("Static_Mixer_main.cas.h5", "pyfluent/static_mixer")
-    fluent_version_str = session.get_fluent_version()[:-2]
     # Ignore lightweight_setup variable for Fluent < 23.1 because not supported
-    if float(fluent_version_str) < 23.1:
+    if session.get_fluent_version() < FluentVersion.v231:
         session.file.read(file_name=case_path, file_type="case")
     else:
         session.file.read(

ansys/fluent/tests/test_launcher.py

@@ -5,19 +5,33 @@ import pytest
 from util.fixture_fluent import download_input_file
 
 import ansys.fluent.core as pyfluent
+from ansys.fluent.core import PyFluentDeprecationWarning  # noqa: F401
 from ansys.fluent.core.exceptions import DisallowedValuesError, InvalidArgument
 from ansys.fluent.core.launcher import launcher_utils
-from ansys.fluent.core.launcher.launcher import create_launcher
-from ansys.fluent.core.launcher.launcher_utils import (
+from ansys.fluent.core.launcher.error_handler import (
     DockerContainerLaunchNotSupported,
-    FluentMode,
     GPUSolverSupportError,
     LaunchFluentError,
     UnexpectedKeywordArgument,
+    _raise_non_gui_exception_in_windows,
+)
+from ansys.fluent.core.launcher.launcher import create_launcher
+from ansys.fluent.core.launcher.launcher_utils import (
     _build_journal_argument,
     check_docker_support,
+    is_windows,
+)
+from ansys.fluent.core.launcher.process_launch_string import (
+    _build_fluent_launch_args_string,
     get_fluent_exe_path,
 )
+from ansys.fluent.core.launcher.pyfluent_enums import (
+    FluentLinuxGraphicsDriver,
+    FluentMode,
+    FluentUI,
+    FluentWindowsGraphicsDriver,
+    LaunchMode,
+)
 from ansys.fluent.core.utils.fluent_version import AnsysVersionNotFound, FluentVersion
 import ansys.platform.instancemanagement as pypim
 
@@ -57,23 +71,48 @@ def test_unsuccessful_fluent_connection():
         pyfluent.launch_fluent(mode="solver", start_timeout=2)
 
 
-def test_additional_argument_g_gu():
-    default_windows_flag = launcher_utils._is_windows()
-    launcher_utils._is_windows = lambda: True
+@pytest.mark.fluent_version("<24.1")
+def test_non_gui_in_windows_throws_exception():
+    default_windows_flag = launcher_utils.is_windows()
+    launcher_utils.is_windows = lambda: True
     try:
-        with pytest.raises(InvalidArgument) as msg:
-            pyfluent.launch_fluent(
-                mode="solver",
-                show_gui=True,
-                additional_arguments="-g",
-                start_container=False,
+        with pytest.raises(InvalidArgument):
+            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v232)
+        with pytest.raises(InvalidArgument):
+            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v231)
+        with pytest.raises(InvalidArgument):
+            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v222)
+        with pytest.raises(InvalidArgument):
+            _raise_non_gui_exception_in_windows(
+                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v232
+            )
+        with pytest.raises(InvalidArgument):
+            _raise_non_gui_exception_in_windows(
+                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v231
             )
-        with pytest.raises(InvalidArgument) as msg:
-            pyfluent.launch_fluent(
-                mode="solver", additional_arguments="-gu", start_container=False
+        with pytest.raises(InvalidArgument):
+            _raise_non_gui_exception_in_windows(
+                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v222
             )
     finally:
-        launcher_utils._is_windows = lambda: default_windows_flag
+        launcher_utils.is_windows = lambda: default_windows_flag
+
+
+@pytest.mark.fluent_version(">=24.1")
+def test_non_gui_in_windows_does_not_throw_exception():
+    default_windows_flag = launcher_utils.is_windows()
+    launcher_utils.is_windows = lambda: True
+    try:
+        _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v241)
+        _raise_non_gui_exception_in_windows(
+            FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v241
+        )
+        _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v242)
+        _raise_non_gui_exception_in_windows(
+            FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v242
+        )
+    finally:
+        launcher_utils.is_windows = lambda: default_windows_flag
 
 
 def test_container_launcher():
@@ -107,8 +146,7 @@ def test_case_load():
     # Case loaded
     assert session.setup.boundary_conditions.is_active()
     # Mesh available because not lightweight
-    fluent_version = float(session.get_fluent_version()[:-2])
-    if not fluent_version < 23.1:
+    if not session.get_fluent_version() < FluentVersion.v231:
         assert session.mesh.quality.is_active()
     # Data not loaded
     assert not session.field_data.is_data_valid()
@@ -150,8 +188,7 @@ def test_case_data_load():
     # Case loaded
     assert session.setup.boundary_conditions.is_active()
     # Mesh available because not lightweight
-    fluent_version = float(session.get_fluent_version()[:-2])
-    if not fluent_version < 23.1:
+    if not session.get_fluent_version() < FluentVersion.v231:
         assert session.mesh.quality.is_active()
     # Data loaded
     assert session.field_data.is_data_valid()
@@ -267,36 +304,50 @@ def test_watchdog_launch(monkeypatch):
 
 
 def test_fluent_launchers():
+    kwargs = dict(
+        ui=FluentUI.NO_GUI,
+        graphics_driver=(
+            FluentWindowsGraphicsDriver.AUTO
+            if is_windows()
+            else FluentLinuxGraphicsDriver.AUTO
+        ),
+    )
     if not check_docker_support() and not pypim.is_configured():
         standalone_meshing_launcher = create_launcher(
-            "standalone", mode=FluentMode.MESHING_MODE
+            LaunchMode.STANDALONE, mode=FluentMode.MESHING_MODE, **kwargs
         )
         standalone_meshing_session = standalone_meshing_launcher()
         assert standalone_meshing_session
 
         standalone_solver_launcher = create_launcher(
-            "standalone", mode=FluentMode.SOLVER
+            LaunchMode.STANDALONE, mode=FluentMode.SOLVER, **kwargs
         )
         standalone_solver_session = standalone_solver_launcher()
         assert standalone_solver_session
 
     if check_docker_support():
         container_meshing_launcher = create_launcher(
-            "container", mode=FluentMode.MESHING_MODE
+            LaunchMode.CONTAINER, mode=FluentMode.MESHING_MODE, **kwargs
         )
         container_meshing_session = container_meshing_launcher()
         assert container_meshing_session
 
-        container_solver_launcher = create_launcher("container", mode=FluentMode.SOLVER)
+        container_solver_launcher = create_launcher(
+            LaunchMode.CONTAINER, mode=FluentMode.SOLVER, **kwargs
+        )
         container_solver_session = container_solver_launcher()
         assert container_solver_session
 
     if pypim.is_configured():
-        pim_meshing_launcher = create_launcher("pim", mode=FluentMode.MESHING_MODE)
+        pim_meshing_launcher = create_launcher(
+            LaunchMode.PIM, mode=FluentMode.MESHING_MODE, **kwargs
+        )
         pim_meshing_session = pim_meshing_launcher()
         assert pim_meshing_session
 
-        pim_solver_launcher = create_launcher("pim", mode=FluentMode.SOLVER)
+        pim_solver_launcher = create_launcher(
+            LaunchMode.PIM, mode=FluentMode.SOLVER, **kwargs
+        )
         pim_solver_session = pim_solver_launcher()
         assert pim_solver_session
 
@@ -322,3 +373,40 @@ def test_fluent_launchers():
 def test_build_journal_argument(topy, journal_file_names, result, raises):
     with raises:
         assert _build_journal_argument(topy, journal_file_names) == result
+
+
+@pytest.mark.filterwarnings("error::FutureWarning")
+def test_show_gui_raises_warning():
+    with pytest.raises(PyFluentDeprecationWarning):
+        pyfluent.launch_fluent(show_gui=True)
+
+
+def test_fluent_enums():
+    assert str(FluentUI.GUI) == "gui"
+    assert FluentUI("gui") == FluentUI.GUI
+    with pytest.raises(ValueError):
+        FluentUI("")
+    assert FluentUI.NO_GUI < FluentUI.GUI
+    with pytest.raises(TypeError):
+        FluentUI.NO_GUI < FluentWindowsGraphicsDriver.AUTO
+
+
+def test_exposure_and_graphics_driver_arguments():
+    with pytest.raises(ValueError):
+        pyfluent.launch_fluent(ui="gu")
+    with pytest.raises(ValueError):
+        pyfluent.launch_fluent(graphics_driver="x11" if is_windows() else "dx11")
+    for m in FluentUI:
+        assert (
+            _build_fluent_launch_args_string(ui=m).strip() == f"3ddp -{m.value[0]}"
+            if m.value[0]
+            else " 3ddp"
+        )
+    for e in (FluentWindowsGraphicsDriver, FluentLinuxGraphicsDriver):
+        for m in e:
+            assert (
+                _build_fluent_launch_args_string(graphics_driver=m).strip()
+                == f"3ddp -driver {m.value[0]}"
+                if m.value[0]
+                else " 3ddp"
+            )

ansys/fluent/tests/test_meshing_workflow.py

@@ -12,6 +12,7 @@ from util.meshing_workflow import (  # noqa: F401; model_object_throws_on_invali
 )
 
 from ansys.fluent.core.meshing.faulttolerant import fault_tolerant_workflow
+from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
 @pytest.mark.fluent_version(">=23.1")
@@ -120,7 +121,7 @@ def test_mixing_elbow_meshing_workflow(
     ###############################################################################
     # Check the mesh in Meshing mode
     # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if float(meshing_session.get_fluent_version()[:-2]) < 23.0:
+    if meshing_session.get_fluent_version() < FluentVersion.v231:
         meshing_session.tui.mesh.check_mesh()
 
 

ansys/fluent/tests/test_session.py

@@ -20,7 +20,7 @@ from ansys.api.fluent.v0.scheme_pointer_pb2 import SchemePointer
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core import connect_to_fluent, examples, session
 from ansys.fluent.core.fluent_connection import FluentConnection, PortNotProvided
-from ansys.fluent.core.launcher.launcher_utils import LaunchFluentError
+from ansys.fluent.core.launcher.error_handler import LaunchFluentError
 from ansys.fluent.core.session import BaseSession
 from ansys.fluent.core.utils.execution import timeout_loop
 from ansys.fluent.core.utils.networking import get_free_port

ansys/fluent/tests/test_settings_api.py

@@ -3,6 +3,7 @@ from util.solver_workflow import new_solver_session  # noqa: F401
 
 from ansys.fluent.core.examples import download_file
 from ansys.fluent.core.solver.flobject import DeprecatedSettingWarning, _Alias
+from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
 @pytest.mark.nightly
@@ -52,7 +53,7 @@ def test_wildcard(new_solver_session):
         "inlet1": {"momentum": {"velocity": {"option": "value", "value": 10}}},
     }
     cell_zone_conditions = solver.setup.cell_zone_conditions
-    if solver.get_fluent_version() >= "24.2.0":
+    if solver.get_fluent_version() >= FluentVersion.v242:
         sources = cell_zone_conditions.fluid["*"].source_terms.sources
         key = "sources"
     else: