ansys-fluent-core 0.20.dev9__py3-none-any.whl → 0.20.dev11__py3-none-any.whl

ansys/fluent/core/systemcoupling.py

@@ -90,7 +90,7 @@ class SystemCoupling:
             )
 
             # download the file locally in case Fluent is in a container
-            if self._solver.fluent_connection._remote_instance != None:
+            if self._solver._fluent_connection._remote_instance != None:
                 self._solver.download(scp_file_name)
 
             assert os.path.exists(

ansys/fluent/core/utils/setup_for_fluent.py

@@ -12,7 +12,7 @@ def setup_for_fluent(*args, **kwargs):
         globals["meshing"] = session
         globals["PartManagement"] = session.PartManagement
         globals["PMFileManagement"] = session.PMFileManagement
-        globals["solver"] = Solver(fluent_connection=session.fluent_connection)
+        globals["solver"] = Solver(fluent_connection=session._fluent_connection)
     else:
         globals["solver"] = session
 

ansys/fluent/core/workflow.py

@@ -349,7 +349,7 @@ class BaseTask:
             camel_attr = snake_to_camel_case(
                 str(attr), [*self._get_camel_case_arg_keys(), *dir(self._task)]
             )
-            attr = camel_attr if camel_attr else attr
+            attr = camel_attr or attr
         try:
             result = getattr(self._task, attr)
             if result:
@@ -706,7 +706,7 @@ class ArgumentWrapper(PyCallableStateObject):
                     f"Try using '{camel_to_snake_case(attr)}' instead."
                 )
             camel_attr = snake_to_camel_case(str(attr), self._get_camel_case_arg_keys())
-            attr = camel_attr if camel_attr else attr
+            attr = camel_attr or attr
         return getattr(self._arg, attr)
 
     def __setattr__(self, attr, value):
@@ -717,7 +717,7 @@ class ArgumentWrapper(PyCallableStateObject):
                 camel_attr = snake_to_camel_case(
                     str(attr), self._get_camel_case_arg_keys()
                 )
-                attr = camel_attr if camel_attr else attr
+                attr = camel_attr or attr
             self.set_state({attr: value})
 
     def __dir__(self):
@@ -1185,7 +1185,7 @@ class Workflow:
                     f"Try using '{camel_to_snake_case(attr)}' instead."
                 )
             camel_attr = snake_to_camel_case(str(attr), dir(self._workflow))
-            attr = camel_attr if camel_attr else attr
+            attr = camel_attr or attr
             obj = self._attr_from_wrapped_workflow(attr)
             if obj:
                 return obj

ansys/fluent/tests/test_field_data.py

@@ -3,6 +3,7 @@ import pytest
 from util.solver_workflow import new_solver_session  # noqa: F401
 
 from ansys.fluent.core import examples
+from ansys.fluent.core.examples.downloads import download_file
 from ansys.fluent.core.exceptions import DisallowedValuesError
 from ansys.fluent.core.services.field_data import FieldUnavailable, SurfaceDataType
 
@@ -369,3 +370,18 @@ def test_field_info_validators(new_solver_session) -> None:
 
     with pytest.raises(DisallowedValuesError) as surface_error:
         solver.fields.field_info.validate_surfaces(["out"])
+
+
+@pytest.mark.skip("https://github.com/ansys/pyfluent/issues/2404")
+@pytest.mark.fluent_version(">=24.2")
+def test_field_data_does_not_modify_case(new_solver_session):
+    solver = new_solver_session
+    case_path = download_file("mixing_elbow.cas.h5", "pyfluent/mixing_elbow")
+    download_file("mixing_elbow.dat.h5", "pyfluent/mixing_elbow")
+    solver.file.read_case_data(file_name=case_path)
+    solver.scheme_eval.scheme_eval("(%save-case-id)")
+    assert not solver.scheme_eval.scheme_eval("(case-modified?)")
+    solver.field_data.get_scalar_field_data(
+        field_name="absolute-pressure", surface_name="cold-inlet"
+    )
+    assert not solver.scheme_eval.scheme_eval("(case-modified?)")

ansys/fluent/tests/test_flobject.py

@@ -7,11 +7,16 @@ import weakref
 
 import pytest
 from test_utils import count_key_recursive
+from util.solver_workflow import new_solver_session  # noqa: F401
 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.solver.flobject import (
+    InactiveObjectError,
+    _gethash,
+    find_children,
+)
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 import ansys.units
 
@@ -38,6 +43,7 @@ class Setting:
 
     attrs = {
         "active?": lambda self: True,
+        "webui-release-active?": lambda self: True,
     }
 
 
@@ -294,6 +300,7 @@ class Root(Group):
             attrs = {
                 "active?": lambda self: not self.parent.objs["b-3"].get_state(),
                 "allowed-values": lambda self: ["foo", "bar"],
+                "webui-release-active?": lambda self: True,
             }
 
         children = {
@@ -365,7 +372,10 @@ class Proxy:
             return self.r
         obj = self.r
         for c in path.split("/"):
-            obj = obj.get_child(c)
+            try:
+                obj = obj.get_child(c)
+            except KeyError:
+                obj = obj.get_command(c)
         return obj
 
     def get_var(self, path):
@@ -739,7 +749,7 @@ def test_accessor_methods_on_settings_object_types(load_static_mixer_settings_on
 @pytest.mark.codegen_required
 def test_find_children_from_settings_root_231(load_static_mixer_settings_only):
     setup_cls = load_static_mixer_settings_only.setup.__class__
-    assert len(find_children(setup_cls())) >= 18514
+    assert len(find_children(setup_cls())) >= 10000
     assert len(find_children(setup_cls(), "gen*")) >= 9
     assert set(find_children(setup_cls(), "general*")) >= {
         "general",
@@ -764,7 +774,7 @@ def test_find_children_from_settings_root_231(load_static_mixer_settings_only):
 @pytest.mark.codegen_required
 def test_find_children_from_settings_root_232(load_static_mixer_settings_only):
     setup_cls = load_static_mixer_settings_only.setup.__class__
-    assert len(find_children(setup_cls())) >= 18514
+    assert len(find_children(setup_cls())) >= 10000
     assert len(find_children(setup_cls(), "gen*")) >= 9
     assert set(find_children(setup_cls(), "general*")) >= {
         "general",
@@ -1154,3 +1164,10 @@ def test_assert_type():
                 else:
                     with pytest.raises(TypeError):
                         flobject.assert_type(val, tp)
+
+
+def test_static_info_hash_identity(new_solver_session):
+    solver = new_solver_session
+    hash1 = _gethash(solver._settings_service.get_static_info())
+    hash2 = _gethash(solver._settings_service.get_static_info())
+    assert hash1 == hash2

ansys/fluent/tests/test_fluent_session.py

@@ -214,7 +214,7 @@ def test_fluent_freeze_kill(
     else:
         raise Exception("Test should have temporarily frozen Fluent, but did not.")
 
-    assert session.fluent_connection.wait_process_finished(wait=5)
+    assert session._fluent_connection.wait_process_finished(wait=5)
 
 
 @pytest.mark.fluent_version(">=23.1")
@@ -254,15 +254,15 @@ def test_fluent_exit(monkeypatch: pytest.MonkeyPatch):
 def test_fluent_exit_wait():
     session1 = pyfluent.launch_fluent()
     session1.exit()
-    assert not session1.fluent_connection.wait_process_finished(wait=0)
+    assert not session1._fluent_connection.wait_process_finished(wait=0)
 
     session2 = pyfluent.launch_fluent()
     session2.exit(wait=60)
-    assert session2.fluent_connection.wait_process_finished(wait=0)
+    assert session2._fluent_connection.wait_process_finished(wait=0)
 
     session3 = pyfluent.launch_fluent()
     session3.exit(wait=True)
-    assert session3.fluent_connection.wait_process_finished(wait=0)
+    assert session3._fluent_connection.wait_process_finished(wait=0)
 
     with pytest.raises(WaitTypeError) as msg:
         session4 = pyfluent.launch_fluent()

ansys/fluent/tests/test_launcher_remote.py

@@ -39,11 +39,13 @@ def test_launch_remote_instance(monkeypatch, new_solver_session):
         ready=True,
         status_message=None,
         services={
-            "grpc": pypim.Service(uri=fluent.fluent_connection._channel_str, headers={})
+            "grpc": pypim.Service(
+                uri=fluent._fluent_connection._channel_str, headers={}
+            )
         },
     )
     pim_channel = grpc.insecure_channel(
-        fluent.fluent_connection._channel_str,
+        fluent._fluent_connection._channel_str,
     )
     mock_instance.wait_for_ready = create_autospec(mock_instance.wait_for_ready)
     mock_instance.build_grpc_channel = create_autospec(
@@ -82,10 +84,10 @@ def test_launch_remote_instance(monkeypatch, new_solver_session):
     mock_instance.build_grpc_channel.assert_called_with()
 
     # And it connected using the channel created by PyPIM
-    assert fluent.fluent_connection._channel == pim_channel
+    assert fluent._fluent_connection._channel == pim_channel
 
     # and it kept track of the instance to be able to delete it
-    assert fluent.fluent_connection._remote_instance == mock_instance
+    assert fluent._fluent_connection._remote_instance == mock_instance
 
     server = grpc.server(futures.ThreadPoolExecutor(max_workers=1))
     ip = "127.0.0.1"
@@ -108,7 +110,7 @@ def test_launch_remote_instance(monkeypatch, new_solver_session):
             )
         )
         session.exit(wait=60)
-        session.fluent_connection.wait_process_finished(wait=60)
+        session._fluent_connection.wait_process_finished(wait=60)
 
 
 class TransferRequestRecorder:
@@ -141,7 +143,7 @@ def test_file_purpose_on_remote_instance(
     file_service = TransferRequestRecorder()
 
     solver_session = Solver(
-        fluent_connection=solver.fluent_connection,
+        fluent_connection=solver._fluent_connection,
         file_transfer_service=file_service,
     )
 
@@ -156,7 +158,7 @@ def test_file_purpose_on_remote_instance(
     meshing = new_mesh_session
 
     meshing_session = PureMeshing(
-        fluent_connection=meshing.fluent_connection,
+        fluent_connection=meshing._fluent_connection,
         file_transfer_service=file_service,
     )
 

ansys/fluent/tests/test_reduction.py

@@ -45,12 +45,12 @@ def _test_locn_extraction(solver1, solver2):
 def _test_context(solver):
     solver.solution.initialization.hybrid_initialize()
 
-    assert solver.reduction.area(
+    assert solver.fields.reduction.area(
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet1"]],
         ctxt=solver,
     )
 
-    assert solver.reduction.area(locations=["inlet1"], ctxt=solver)
+    assert solver.fields.reduction.area(locations=["inlet1"], ctxt=solver)
 
 
 def _test_area_average(solver):
@@ -62,7 +62,7 @@ def _test_area_average(solver):
     )
     expr_val = solver_named_expressions["test_expr_1"].get_value()
     assert type(expr_val) == float and expr_val != 0.0
-    val = solver.reduction.area_average(
+    val = solver.fields.reduction.area_average(
         expression="AbsolutePressure",
         locations=solver.setup.boundary_conditions.velocity_inlet,
     )
@@ -82,7 +82,7 @@ def _test_min(solver1, solver2):
     test_expr2 = solver2_named_expr["test_expr_2"]
     test_expr2.definition = "minimum(test_expr_2, ['outlet'])"
     expected_result = test_expr2.get_value()
-    result = solver1.reduction.minimum(
+    result = solver1.fields.reduction.minimum(
         expression=test_expr1.definition(),
         locations=[
             solver1.setup.boundary_conditions["outlet"],
@@ -107,9 +107,9 @@ def _test_count(solver):
     solver_named_expressions["test_expr_1"].definition = "Count(['inlet1', 'inlet2'])"
     expr_val_3 = solver_named_expressions["test_expr_1"].get_value()
     assert expr_val_3 == expr_val_1 + expr_val_2
-    red_val_1 = solver.reduction.count(locations=[s_velocity_inlet["inlet1"]])
-    red_val_2 = solver.reduction.count(locations=[s_velocity_inlet["inlet2"]])
-    red_val_3 = solver.reduction.count(locations=[s_velocity_inlet])
+    red_val_1 = solver.fields.reduction.count(locations=[s_velocity_inlet["inlet1"]])
+    red_val_2 = solver.fields.reduction.count(locations=[s_velocity_inlet["inlet2"]])
+    red_val_3 = solver.fields.reduction.count(locations=[s_velocity_inlet])
     assert red_val_1 == expr_val_1
     assert red_val_2 == expr_val_2
     assert red_val_3 == expr_val_3
@@ -129,9 +129,9 @@ def _test_centroid(solver):
         "Centroid(['inlet1', 'inlet2'])"
     )
     expr_val_3 = solver_named_expressions["test_expr_1"].get_value()
-    red_val_1 = solver.reduction.centroid(locations=[velocity_inlet["inlet1"]])
-    red_val_2 = solver.reduction.centroid(locations=[velocity_inlet["inlet2"]])
-    red_val_3 = solver.reduction.centroid(locations=[velocity_inlet])
+    red_val_1 = solver.fields.reduction.centroid(locations=[velocity_inlet["inlet1"]])
+    red_val_2 = solver.fields.reduction.centroid(locations=[velocity_inlet["inlet2"]])
+    red_val_3 = solver.fields.reduction.centroid(locations=[velocity_inlet])
     assert [red_val_1.x, red_val_1.y, red_val_1.z] == expr_val_1
     assert [red_val_2.x, red_val_2.y, red_val_2.z] == expr_val_2
     assert [red_val_3.x, red_val_3.y, red_val_3.z] == expr_val_3
@@ -163,15 +163,15 @@ def _test_area_integrated_average(solver1, solver2):
 
     assert expr_val_3 - (expr_val_1 + expr_val_2) <= 0.000000001
 
-    red_val_1 = solver1.reduction.area_integral(
+    red_val_1 = solver1.fields.reduction.area_integral(
         expression="AbsolutePressure",
         locations=[solver1_boundary_conditions.velocity_inlet["inlet1"]],
     )
-    red_val_2 = solver1.reduction.area_integral(
+    red_val_2 = solver1.fields.reduction.area_integral(
         expression="AbsolutePressure",
         locations=[solver1_boundary_conditions.velocity_inlet["inlet2"]],
     )
-    red_val_3 = solver1.reduction.area_integral(
+    red_val_3 = solver1.fields.reduction.area_integral(
         expression="AbsolutePressure",
         locations=[solver1_boundary_conditions.velocity_inlet],
     )
@@ -197,15 +197,15 @@ def _test_area_integrated_average(solver1, solver2):
 
     assert expr_val_6 - (expr_val_4 + expr_val_5) <= 0.000000001
 
-    red_val_4 = solver2.reduction.area_integral(
+    red_val_4 = solver2.fields.reduction.area_integral(
         expression="AbsolutePressure",
         locations=[solver2_boundary_conditions.velocity_inlet["inlet1"]],
     )
-    red_val_5 = solver2.reduction.area_integral(
+    red_val_5 = solver2.fields.reduction.area_integral(
         expression="AbsolutePressure",
         locations=[solver2_boundary_conditions.velocity_inlet["inlet2"]],
     )
-    red_val_6 = solver2.reduction.area_integral(
+    red_val_6 = solver2.fields.reduction.area_integral(
         expression="AbsolutePressure",
         locations=[solver2_boundary_conditions.velocity_inlet],
     )
@@ -214,7 +214,7 @@ def _test_area_integrated_average(solver1, solver2):
     assert red_val_5 == expr_val_5
     assert red_val_6 == expr_val_6
 
-    red_val_7 = solver2.reduction.area_integral(
+    red_val_7 = solver2.fields.reduction.area_integral(
         expression="AbsolutePressure",
         locations=[
             solver1_boundary_conditions.velocity_inlet,
@@ -230,7 +230,7 @@ def _test_area_integrated_average(solver1, solver2):
 def _test_error_handling(solver):
     if int(solver._version) < 241:
         with pytest.raises(RuntimeError) as msg:
-            solver.reduction.area_average(
+            solver.fields.reduction.area_average(
                 expression="AbsoluteVelocity",  # This is a wrong expression intentionally passed
                 locations=solver.setup.boundary_conditions.velocity_inlet,
             )
@@ -243,13 +243,13 @@ def _test_force(solver):
     solver_named_expressions["test_expr_1"].definition = "Force(['wall'])"
     expr_val_1 = solver_named_expressions["test_expr_1"].get_value()
 
-    red_total_force = solver.reduction.force(
+    red_total_force = solver.fields.reduction.force(
         locations=[solver.setup.boundary_conditions.wall]
     )
-    red_pressure_force = solver.reduction.pressure_force(
+    red_pressure_force = solver.fields.reduction.pressure_force(
         locations=[solver.setup.boundary_conditions.wall]
     )
-    red_viscous_force = solver.reduction.viscous_force(
+    red_viscous_force = solver.fields.reduction.viscous_force(
         locations=[solver.setup.boundary_conditions.wall]
     )
 
@@ -277,11 +277,11 @@ def _test_moment(solver):
     solver_named_expressions["test_expr_1"].definition = "Moment(['inlet1'],['wall'])"
     expr_val_2 = solver_named_expressions["test_expr_1"].get_value()
 
-    red_moment_force = solver.reduction.moment(
+    red_moment_force = solver.fields.reduction.moment(
         expression="Force(['wall'])", locations=[location]
     )
 
-    red_moment_location = solver.reduction.moment(
+    red_moment_location = solver.fields.reduction.moment(
         expression="['inlet1']", locations=[location]
     )
 
@@ -304,7 +304,7 @@ def _test_sum(solver):
     expr_val = solver.setup.named_expressions["test_expr_1"].get_value()
     assert type(expr_val) == float and expr_val != 0.0
 
-    val = solver.reduction.sum(
+    val = solver.fields.reduction.sum(
         expression="AbsolutePressure",
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet1"]],
         weight="Area",
@@ -323,7 +323,7 @@ def _test_sum_if(solver):
     expr_val = solver.setup.named_expressions["test_expr_1"].get_value()
     assert type(expr_val) == float and expr_val != 0.0
 
-    val = solver.reduction.sum_if(
+    val = solver.fields.reduction.sum_if(
         expression="AbsolutePressure",
         condition="AbsolutePressure > 0[Pa]",
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet1"]],
@@ -351,3 +351,14 @@ def test_reductions(load_static_mixer_case, load_static_mixer_case_2) -> None:
     _test_moment(solver1)
     _test_sum(solver1)
     _test_sum_if(solver1)
+
+
+@pytest.mark.fluent_version(">=24.2")
+def test_reduction_does_not_modify_case(load_static_mixer_case):
+    solver = load_static_mixer_case
+    assert not solver.scheme_eval.scheme_eval("(case-modified?)")
+    solver.reduction.area_average(
+        expression="AbsolutePressure",
+        locations=solver.setup.boundary_conditions.velocity_inlet,
+    )
+    assert not solver.scheme_eval.scheme_eval("(case-modified?)")

ansys/fluent/tests/test_session.py

@@ -337,9 +337,9 @@ def test_read_case_using_lightweight_mode():
         case_file_name=import_file_name, lightweight_mode=True
     )
     solver.setup.models.energy.enabled = False
-    old_fluent_connection_id = id(solver.fluent_connection)
+    old_fluent_connection_id = id(solver._fluent_connection)
     timeout_loop(
-        id(solver.fluent_connection) != old_fluent_connection_id,
+        id(solver._fluent_connection) != old_fluent_connection_id,
         timeout=60,
         idle_period=1,
     )
@@ -361,13 +361,13 @@ def test_build_from_fluent_connection(make_new_session):
     assert solver1.health_check_service.is_serving
     assert solver2.health_check_service.is_serving
     health_check_service1 = solver1.health_check_service
-    cortex_pid2 = solver2.fluent_connection.connection_properties.cortex_pid
-    solver1.build_from_fluent_connection(solver2.fluent_connection)
+    cortex_pid2 = solver2._fluent_connection.connection_properties.cortex_pid
+    solver1.build_from_fluent_connection(solver2._fluent_connection)
     assert solver1.health_check_service.is_serving
     assert solver2.health_check_service.is_serving
     assert not health_check_service1.is_serving
-    assert solver1.fluent_connection.connection_properties.cortex_pid == cortex_pid2
-    assert solver2.fluent_connection.connection_properties.cortex_pid == cortex_pid2
+    assert solver1._fluent_connection.connection_properties.cortex_pid == cortex_pid2
+    assert solver2._fluent_connection.connection_properties.cortex_pid == cortex_pid2
 
 
 @pytest.mark.standalone

ansys/fluent/tests/test_settings_api.py

@@ -2,7 +2,11 @@ import pytest
 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.solver.flobject import (
+    DeprecatedSettingWarning,
+    UnstableSettingWarning,
+    _Alias,
+)
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
@@ -156,6 +160,26 @@ def test_deprecated_settings(new_solver_session):
     with pytest.warns(DeprecatedSettingWarning):
         solver.file.rcd(file_name=case_path)
 
+    solver.setup.boundary_conditions.velocity_inlet.child_object_type._child_aliases[
+        "mom"
+    ] = "momentum"
+    with pytest.warns(DeprecatedSettingWarning):
+        solver.setup.boundary_conditions.velocity_inlet["hot-inlet"].mom.velocity = 20
+    assert (
+        solver.setup.boundary_conditions.velocity_inlet[
+            "hot-inlet"
+        ].momentum.velocity.value()
+        == 20
+    )
+    with pytest.warns(DeprecatedSettingWarning):
+        solver.setup.boundary_conditions.velocity_inlet["cold-inlet"].mom.velocity = 2
+    assert (
+        solver.setup.boundary_conditions.velocity_inlet[
+            "cold-inlet"
+        ].momentum.velocity.value()
+        == 2
+    )
+
     solver.setup.boundary_conditions.wall["wall-inlet"].thermal.thermal_bc = (
         "Temperature"
     )
@@ -182,7 +206,7 @@ def test_deprecated_settings(new_solver_session):
         > 0
     )
     assert isinstance(
-        solver.setup.boundary_conditions.wall["wall-inlet"].thermal.t._child_aliases[
+        solver.setup.boundary_conditions.wall["wall-inlet"].thermal.t._child_alias_objs[
             "constant"
         ],
         _Alias,
@@ -216,17 +240,15 @@ def test_deprecated_settings(new_solver_session):
     with pytest.warns(DeprecatedSettingWarning):
         solver.results.gr.contour.create("c1")
 
-    # disabling due to ansys/pyfluent#2526
-
-    # with pytest.warns(DeprecatedSettingWarning):
-    #     solver.results.gr.contour["c1"].field = "pressure"
+    with pytest.warns(DeprecatedSettingWarning):
+        solver.results.gr.contour["c1"].field = "pressure"
 
-    # assert solver.results.graphics.contour["c1"].field() == "pressure"
+    assert solver.results.graphics.contour["c1"].field() == "pressure"
 
-    # with pytest.warns(DeprecatedSettingWarning):
-    #     del solver.results.gr.contour["c1"]
+    with pytest.warns(DeprecatedSettingWarning):
+        del solver.results.gr.contour["c1"]
 
-    # assert "c1" not in solver.results.graphics.contour
+    assert "c1" not in solver.results.graphics.contour
 
     solver.setup.boundary_conditions.velocity_inlet[
         "hot-inlet"
@@ -242,8 +264,7 @@ def test_deprecated_settings(new_solver_session):
         == 10
     )
 
-    # TODO: Enable after Fluent image is updated
-    # solver.setup.cell_zone_conditions.fluid["elbow-fluid"] = {"material": "air"}
+    solver.setup.cell_zone_conditions.fluid["elbow-fluid"] = {"material": "air"}
 
 
 @pytest.mark.fluent_version(">=24.2")
@@ -258,3 +279,19 @@ def test_command_return_type(new_solver_session):
     )
     ret = solver.solution.report_definitions.compute(report_defs=["surface-1"])
     assert ret is not None
+
+
+@pytest.mark.fluent_version(">=24.2")
+def test_unstable_settings_warning(new_solver_session, recwarn):
+    solver = new_solver_session
+    solver.file.export
+    assert len(recwarn) == 1
+    assert recwarn.pop().category == UnstableSettingWarning
+    try:
+        solver.file.exp
+    except AttributeError:
+        pass
+    assert len(recwarn) == 0
+    solver.file.export
+    assert len(recwarn) == 1
+    assert recwarn.pop().category == UnstableSettingWarning

ansys/fluent/tests/test_solution_variables.py

@@ -6,6 +6,7 @@ from util.solver_workflow import (  # noqa: F401
 )
 
 from ansys.fluent.core import examples
+from ansys.fluent.core.examples.downloads import download_file
 
 
 @pytest.mark.fluent_version(">=23.2")
@@ -388,3 +389,19 @@ def test_svars_single_precision(new_solver_session_single_precision):
     fluid_temp = sv_p_wall_fluid["tank"]
     assert fluid_temp.size == 183424
     assert str(fluid_temp.dtype) == "float32"
+
+
+@pytest.mark.fluent_version(">=24.2")
+def test_solution_variable_does_not_modify_case(new_solver_session):
+    solver = new_solver_session
+    case_path = download_file("mixing_elbow.cas.h5", "pyfluent/mixing_elbow")
+    download_file("mixing_elbow.dat.h5", "pyfluent/mixing_elbow")
+    solver.file.read_case_data(file_name=case_path)
+    solver.scheme_eval.scheme_eval("(%save-case-id)")
+    assert not solver.scheme_eval.scheme_eval("(case-modified?)")
+    solver.fields.solution_variable_data.get_data(
+        solution_variable_name="SV_P",
+        zone_names=["elbow-fluid", "wall-elbow"],
+        domain_name="mixture",
+    )
+    assert not solver.scheme_eval.scheme_eval("(case-modified?)")

{ansys_fluent_core-0.20.dev9.dist-info → ansys_fluent_core-0.20.dev11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ansys-fluent-core
-Version: 0.20.dev9
+Version: 0.20.dev11
 Summary: PyFluent provides Pythonic access to Ansys Fluent
 Home-page: https://github.com/ansys/pyfluent
 License: MIT
@@ -21,7 +21,7 @@ Provides-Extra: reader
 Provides-Extra: tests
 Requires-Dist: ansys-api-fluent (>=0.3.22,<0.4.0)
 Requires-Dist: ansys-platform-instancemanagement (>=1.0,<2.0)
-Requires-Dist: ansys-units (>=0.3.1,<0.4.0)
+Requires-Dist: ansys-units (>=0.3.2,<0.4.0)
 Requires-Dist: beartype (>=0.17,<0.18)
 Requires-Dist: docker (>=6.1.3,<7.0.0)
 Requires-Dist: grpcio (>=1.30.0,<2.0.0)