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

ansys/fluent/tests/test_launcher.py

@@ -28,9 +28,9 @@ from ansys.fluent.core.launcher.process_launch_string import (
 from ansys.fluent.core.launcher.pyfluent_enums import (
     FluentLinuxGraphicsDriver,
     FluentMode,
-    FluentUI,
     FluentWindowsGraphicsDriver,
     LaunchMode,
+    UIMode,
 )
 from ansys.fluent.core.utils.fluent_version import AnsysVersionNotFound, FluentVersion
 import ansys.platform.instancemanagement as pypim
@@ -77,22 +77,22 @@ def test_non_gui_in_windows_throws_exception():
     launcher_utils.is_windows = lambda: True
     try:
         with pytest.raises(InvalidArgument):
-            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v232)
+            _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v232)
         with pytest.raises(InvalidArgument):
-            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v231)
+            _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v231)
         with pytest.raises(InvalidArgument):
-            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v222)
+            _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v222)
         with pytest.raises(InvalidArgument):
             _raise_non_gui_exception_in_windows(
-                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v232
+                UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v232
             )
         with pytest.raises(InvalidArgument):
             _raise_non_gui_exception_in_windows(
-                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v231
+                UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v231
             )
         with pytest.raises(InvalidArgument):
             _raise_non_gui_exception_in_windows(
-                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v222
+                UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v222
             )
     finally:
         launcher_utils.is_windows = lambda: default_windows_flag
@@ -103,13 +103,13 @@ 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(UIMode.NO_GUI, FluentVersion.v241)
         _raise_non_gui_exception_in_windows(
-            FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v241
+            UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v241
         )
-        _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v242)
+        _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v242)
         _raise_non_gui_exception_in_windows(
-            FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v242
+            UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v242
         )
     finally:
         launcher_utils.is_windows = lambda: default_windows_flag
@@ -305,7 +305,7 @@ def test_watchdog_launch(monkeypatch):
 
 def test_fluent_launchers():
     kwargs = dict(
-        ui=FluentUI.NO_GUI,
+        ui_mode=UIMode.NO_GUI,
         graphics_driver=(
             FluentWindowsGraphicsDriver.AUTO
             if is_windows()
@@ -382,23 +382,23 @@ def test_show_gui_raises_warning():
 
 
 def test_fluent_enums():
-    assert str(FluentUI.GUI) == "gui"
-    assert FluentUI("gui") == FluentUI.GUI
+    assert str(UIMode.GUI) == "gui"
+    assert UIMode("gui") == UIMode.GUI
     with pytest.raises(ValueError):
-        FluentUI("")
-    assert FluentUI.NO_GUI < FluentUI.GUI
+        UIMode("")
+    assert UIMode.NO_GUI < UIMode.GUI
     with pytest.raises(TypeError):
-        FluentUI.NO_GUI < FluentWindowsGraphicsDriver.AUTO
+        UIMode.NO_GUI < FluentWindowsGraphicsDriver.AUTO
 
 
 def test_exposure_and_graphics_driver_arguments():
     with pytest.raises(ValueError):
-        pyfluent.launch_fluent(ui="gu")
+        pyfluent.launch_fluent(ui_mode="gu")
     with pytest.raises(ValueError):
         pyfluent.launch_fluent(graphics_driver="x11" if is_windows() else "dx11")
-    for m in FluentUI:
+    for m in UIMode:
         assert (
-            _build_fluent_launch_args_string(ui=m).strip() == f"3ddp -{m.value[0]}"
+            _build_fluent_launch_args_string(ui_mode=m).strip() == f"3ddp -{m.value[0]}"
             if m.value[0]
             else " 3ddp"
         )

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_meshing_queries_fdl.py

@@ -5,6 +5,7 @@ from ansys.fluent.core import examples
 import_filename = examples.download_file("mixing_elbow.msh.h5", "pyfluent/mixing_elbow")
 
 
+@pytest.mark.nightly
 @pytest.mark.fluent_version(">=24.2")
 def test_meshing_utilities(new_mesh_session):
     meshing_session = new_mesh_session

ansys/fluent/tests/test_new_meshing_workflow.py

@@ -5,6 +5,8 @@ import pytest
 
 from ansys.fluent.core import examples
 from ansys.fluent.core.meshing.watertight import watertight_workflow
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+from tests.test_datamodel_service import disable_datamodel_cache  # noqa: F401
 
 
 @pytest.mark.nightly
@@ -544,12 +546,19 @@ def test_workflow_and_data_model_methods_new_meshing_workflow(new_mesh_session):
     watertight.task("import_geom_wtm").file_name = import_file_name
     watertight.task("import_geom_wtm").length_unit = "in"
     watertight.task("import_geom_wtm")()
-    assert watertight.task("import_geom_wtm").get_next_possible_tasks() == [
+    _next_possible_tasks = [
         "import_body_of_influence_geometry",
         "set_up_periodic_boundaries",
         "create_local_refinement_regions",
+        "load_cad_geometry",
         "run_custom_journal",
     ]
+    if meshing.get_fluent_version() < FluentVersion.v242:
+        _next_possible_tasks.remove("load_cad_geometry")
+    assert (
+        watertight.task("import_geom_wtm").get_next_possible_tasks()
+        == _next_possible_tasks
+    )
     watertight.task("import_geom_wtm").insert_next_task(
         "import_body_of_influence_geometry"
     )
@@ -937,6 +946,25 @@ def test_attrs_in_watertight_meshing_workflow(new_mesh_session):
     assert not watertight.import_geometry.file_name()
 
 
+@pytest.mark.codegen_required
+@pytest.mark.fluent_version(">=23.2")
+def test_ordered_children_in_enhanced_meshing_workflow(new_mesh_session):
+    watertight = new_mesh_session.watertight()
+    assert set([repr(x) for x in watertight.ordered_children()]) == {
+        "<Task 'Add Boundary Layers'>",
+        "<Task 'Add Local Sizing'>",
+        "<Task 'Apply Share Topology'>",
+        "<Task 'Create Regions'>",
+        "<Task 'Describe Geometry'>",
+        "<Task 'Enclose Fluid Regions (Capping)'>",
+        "<Task 'Generate the Surface Mesh'>",
+        "<Task 'Generate the Volume Mesh'>",
+        "<Task 'Import Geometry'>",
+        "<Task 'Update Boundaries'>",
+        "<Task 'Update Regions'>",
+    }
+
+
 @pytest.mark.skip("Randomly failing in CI")
 @pytest.mark.codegen_required
 @pytest.mark.fluent_version(">=23.2")
@@ -1016,3 +1044,43 @@ def test_switch_between_workflows(new_mesh_session):
     # Re-initialize fault-tolerant
     fault_tolerant.reinitialize()
     assert fault_tolerant.import_cad_and_part_management.arguments()
+
+
+@pytest.mark.codegen_required
+@pytest.mark.fluent_version(">=24.1")
+def test_new_meshing_workflow_without_dm_caching(
+    disable_datamodel_cache, new_mesh_session
+):
+    import_file_name = examples.download_file(
+        "mixing_elbow.pmdb", "pyfluent/mixing_elbow"
+    )
+
+    watertight = new_mesh_session.watertight()
+    watertight.import_geometry.file_name = import_file_name
+    watertight.import_geometry.length_unit.set_state("in")
+    watertight.import_geometry()
+
+    watertight.add_local_sizing.add_child_to_task()
+    watertight.add_local_sizing()
+
+    watertight.create_volume_mesh()
+
+    watertight.import_geometry.rename(new_name="import_geom_wtm")
+    assert watertight.task("import_geom_wtm").arguments()
+
+    watertight.delete_tasks(list_of_tasks=["add_local_sizing"])
+    with pytest.raises(AttributeError):
+        watertight.add_local_sizing
+    watertight.insert_new_task(command_name="add_local_sizing")
+    time.sleep(2.5)
+    assert watertight.add_local_sizing
+
+    fault_tolerant = new_mesh_session.fault_tolerant()
+    with pytest.raises(RuntimeError):
+        watertight.import_geometry.arguments()
+    assert fault_tolerant.import_cad_and_part_management.arguments()
+
+    watertight.reinitialize()
+    with pytest.raises(RuntimeError):
+        fault_tolerant.import_cad_and_part_management.arguments()
+    assert watertight.import_geometry.arguments()

ansys/fluent/tests/test_preferences.py

@@ -2,6 +2,8 @@ import pytest
 from util.meshing_workflow import new_mesh_session  # noqa: F401
 from util.solver_workflow import new_solver_session  # noqa: F401
 
+from ansys.fluent.core.services.datamodel_se import ReadOnlyObjectError
+
 
 @pytest.mark.codegen_required
 def test_solver_preferences(new_solver_session):
@@ -10,8 +12,9 @@ def test_solver_preferences(new_solver_session):
     preferred_meshing.Verbosity = "off"
     assert preferred_meshing.Verbosity() == "off"
 
-    preferred_meshing.CheckpointingOption = "Write into memory"
-    assert preferred_meshing.CheckpointingOption() == "Write into memory"
+    with pytest.raises(ReadOnlyObjectError):
+        preferred_meshing.CheckpointingOption = "Write into memory"
+    assert preferred_meshing.CheckpointingOption() == "Write mesh files"
 
     preferred_drawing = preferred_meshing.DrawSettings
     preferred_drawing.FacetLimit = 6000000
@@ -43,8 +46,9 @@ def test_meshing_preferences(new_mesh_session):
     preferred_meshing.Verbosity = "off"
     assert preferred_meshing.Verbosity() == "off"
 
-    preferred_meshing.CheckpointingOption = "Write into memory"
-    assert preferred_meshing.CheckpointingOption() == "Write into memory"
+    with pytest.raises(ReadOnlyObjectError):
+        preferred_meshing.CheckpointingOption = "Write into memory"
+    assert preferred_meshing.CheckpointingOption() == "Write mesh files"
 
     preferred_drawing = preferred_meshing.DrawSettings
     preferred_drawing.FacetLimit = 6000000

ansys/fluent/tests/test_pure_mesh_vs_mesh_workflow.py

@@ -11,7 +11,7 @@ def test_pure_meshing_mode(load_mixing_elbow_pure_meshing):
     # n.b. 'field_data', 'field_info' need to
     # be eliminated from meshing sessions
     session_dir = dir(pure_meshing_session)
-    for attr in ("field_data", "field_info", "meshing", "workflow"):
+    for attr in ("meshing", "workflow"):
         assert attr in session_dir
     workflow = pure_meshing_session.workflow
     workflow_dir = dir(workflow)
@@ -33,7 +33,7 @@ def test_meshing_mode(load_mixing_elbow_meshing):
     # n.b. 'field_data', 'field_info' need to
     # be eliminated from meshing sessions
     session_dir = dir(meshing_session)
-    for attr in ("field_data", "field_info", "meshing", "workflow"):
+    for attr in ("meshing", "workflow"):
         assert attr in session_dir
     assert meshing_session.workflow.InitializeWorkflow(
         WorkflowType="Watertight Geometry"

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

@@ -171,7 +171,7 @@ def test_create_mock_session_from_server_info_file(tmp_path: Path) -> None:
     server.start()
     server_info_file = tmp_path / "server_info.txt"
     server_info_file.write_text(f"{ip}:{port}\n12345")
-    session = BaseSession.create_from_server_info_file(
+    session = BaseSession._create_from_server_info_file(
         server_info_file_name=str(server_info_file), cleanup_on_exit=False
     )
     assert session.health_check_service.is_serving
@@ -195,7 +195,7 @@ def test_create_mock_session_from_server_info_file_with_wrong_password(
     server_info_file = tmp_path / "server_info.txt"
     server_info_file.write_text(f"{ip}:{port}\n1234")
     with pytest.raises(RuntimeError) as ex:
-        session = BaseSession.create_from_server_info_file(
+        session = BaseSession._create_from_server_info_file(
             server_info_file_name=str(server_info_file),
             cleanup_on_exit=False,
         )
@@ -223,9 +223,9 @@ def test_create_mock_session_from_launch_fluent_by_passing_ip_port_password() ->
         password="12345",
     )
     # check a few dir elements
-    session_dir = dir(session)
+    fields_dir = dir(session.fields)
     for attr in ("field_data", "field_info"):
-        assert attr in session_dir
+        assert attr in fields_dir
     assert session.health_check_service.is_serving
     server.stop(None)
     session.exit()
@@ -251,9 +251,9 @@ def test_create_mock_session_from_launch_fluent_by_setting_ip_port_env_var(
         cleanup_on_exit=False, ip=ip, port=port, password="12345"
     )
     # check a few dir elements
-    session_dir = dir(session)
+    fields_dir = dir(session.fields)
     for attr in ("field_data", "field_info"):
-        assert attr in session_dir
+        assert attr in fields_dir
     assert session.health_check_service.is_serving
     server.stop(None)
     session.exit()
@@ -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
@@ -439,3 +439,20 @@ def test_get_set_state_on_solver(new_solver_session):
     state = solver.get_state()
     assert state
     solver.set_state(state)
+
+
+def test_solver_structure(new_solver_session):
+    solver = new_solver_session
+    with pytest.warns(DeprecationWarning):
+        solver.field_data
+    with pytest.warns(DeprecationWarning):
+        solver.svar_data
+
+    assert {
+        "field_data",
+        "field_info",
+        "field_data_streaming",
+        "solution_variable_data",
+        "solution_variable_info",
+        "reduction",
+    }.issubset(set(dir(solver.fields)))