ansys-fluent-core 0.29.dev0__py3-none-any.whl → 0.29.dev1__py3-none-any.whl

ansys/fluent/tests/test_solvermode/test_boundaries.py

@@ -1,127 +0,0 @@
-import json
-import os
-from unittest import TestCase
-
-import pytest
-from util.solver import SettingsValDict as D
-from util.solver import assign_settings_value_from_value_dict as assign_dict_val
-from util.solver import get_name_info
-
-
-@pytest.mark.fluent_version(">=24.1")
-@pytest.mark.settings_only
-@pytest.mark.codegen_required
-def test_boundaries_elbow(mixing_elbow_settings_session):
-    solver_session = mixing_elbow_settings_session
-    solver_session.setup.models.energy.enabled = True
-
-    cold_inlet = solver_session.setup.boundary_conditions.velocity_inlet["cold-inlet"]
-    assert D(1) == cold_inlet.momentum.velocity()
-    assign_dict_val(cold_inlet.momentum.velocity, 0.4)
-    assert D(0.4) == cold_inlet.momentum.velocity()
-
-    cold_inlet.turbulence.turbulent_specification = "Intensity and Hydraulic Diameter"
-    cold_inlet.turbulence.turbulent_intensity = 0.05
-    cold_inlet.turbulence.hydraulic_diameter = "4 [in]"
-    assign_dict_val(cold_inlet.thermal.t, 293.15)
-
-    assert {
-        "name": "cold-inlet",
-        "momentum": {
-            "initial_gauge_pressure": {"option": "value", "value": 0},
-            "reference_frame": "Absolute",
-            "velocity": {"option": "value", "value": 0.4},
-            "velocity_specification_method": "Magnitude, Normal to Boundary",
-        },
-        "turbulence": {
-            "turbulent_specification": "Intensity and Hydraulic Diameter",
-            "turbulent_intensity": 0.05,
-            "hydraulic_diameter": "4 [in]",
-        },
-        "thermal": {"t": {"option": "value", "value": 293.15}},
-    } == cold_inlet()
-
-    hot_inlet = solver_session.setup.boundary_conditions.velocity_inlet["hot-inlet"]
-    assign_dict_val(hot_inlet.momentum.velocity, 1.2)
-    hot_inlet.turbulence.turbulent_specification = "Intensity and Hydraulic Diameter"
-    hot_inlet.turbulence.hydraulic_diameter = "1 [in]"
-    assign_dict_val(hot_inlet.thermal.t, 313.15)
-
-    assert {
-        "name": "hot-inlet",
-        "momentum": {
-            "initial_gauge_pressure": {"option": "value", "value": 0},
-            "reference_frame": "Absolute",
-            "velocity": {"option": "value", "value": 1.2},
-            "velocity_specification_method": "Magnitude, Normal to Boundary",
-        },
-        "turbulence": {
-            "turbulent_specification": "Intensity and Hydraulic Diameter",
-            "turbulent_intensity": 0.05,
-            "hydraulic_diameter": "1 [in]",
-        },
-        "thermal": {"t": {"option": "value", "value": 313.15}},
-    } == hot_inlet()
-
-    solver_session.setup.boundary_conditions.pressure_outlet[
-        "outlet"
-    ].turbulence.turbulent_viscosity_ratio = 4
-    assert (
-        solver_session.setup.boundary_conditions.pressure_outlet[
-            "outlet"
-        ].turbulence.turbulent_viscosity_ratio()
-        == 4
-    )
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_boundaries_periodic(periodic_rot_settings_session):
-    solver_session = periodic_rot_settings_session
-    print(__file__)
-    _THIS_DIR = os.path.dirname(__file__)
-    _DATA_FILE = os.path.join(_THIS_DIR, "boundaries_periodic_expDict")
-    boundary_exp = json.load(open(_DATA_FILE))
-    boundary_test = dict()
-    boundary_tested = dict()
-    for name, boundary in solver_session.setup.boundary_conditions.items():
-        boundary_test[name] = boundary()
-    boundary_tested["val_1"] = boundary_test
-
-    TestCase().assertDictEqual(boundary_tested["val_1"], boundary_exp["val_1"])
-
-    boundary_test = dict()
-    for (
-        boundary_type
-    ) in solver_session.setup.boundary_conditions.get_active_child_names():
-        if boundary_type in ["non_reflecting_bc", "perforated_wall", "settings"]:
-            continue
-        for name, boundary in getattr(
-            solver_session.setup.boundary_conditions, boundary_type
-        ).items():
-            boundary_test[name] = boundary()
-    boundary_tested["val_2"] = boundary_test
-    TestCase().assertDictEqual(boundary_tested["val_2"], boundary_exp["val_2"])
-
-    boundaries_check = ["inlet", "outlet", "pipe_2_wall"]
-    selected_bou_test = get_name_info(boundary_tested["val_1"], boundaries_check)
-    selected_bou_exp = get_name_info(boundary_exp["val_1"], boundaries_check)
-    TestCase().assertDictEqual(selected_bou_test, selected_bou_exp)
-    solver_session.setup.boundary_conditions.wall["pipe_2_wall"].rename("pipe2_wall")
-    solver_session.setup.boundary_conditions.pressure_outlet["outlet"].rename("out")
-    solver_session.setup.boundary_conditions.velocity_inlet[
-        "inlet"
-    ].momentum.velocity = 5.0
-    solver_session.setup.boundary_conditions["inlet"].momentum.velocity = 10.0
-    boundaries_check = ["inlet", "out", "pipe2_wall"]
-    boundary_test = dict()
-    for name, boundary in solver_session.setup.boundary_conditions.items():
-        boundary_test[name] = boundary()
-    boundary_tested["val_3"] = boundary_test
-    TestCase().assertDictEqual(boundary_tested["val_3"], boundary_exp["val_3"])
-
-    selected_bou_test = get_name_info(boundary_tested["val_3"], boundaries_check)
-    selected_bou_exp = get_name_info(boundary_exp["val_3"], boundaries_check)
-    TestCase().assertDictEqual(selected_bou_test, selected_bou_exp)
-    with open("boundaries_periodic_outDict.py", "a") as f:
-        json.dump(boundary_tested, f, sort_keys=True, indent=4)

ansys/fluent/tests/test_solvermode/test_calculationactivities.py

@@ -1,20 +0,0 @@
-import pytest
-
-from ansys.fluent.core.utils.fluent_version import FluentVersion
-
-
-@pytest.mark.fluent_version("latest")
-def test_solver_calculation(static_mixer_case_session):
-    solver_session = static_mixer_case_session
-    scheme_eval = solver_session.scheme_eval.scheme_eval
-    assert scheme_eval("(client-get-var 'residuals/plot?)") is True
-    # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if solver_session.get_fluent_version() < FluentVersion.v231:
-        solver_session.tui.solve.monitors.residual.plot("no")
-        assert scheme_eval("(client-get-var 'residuals/plot?)") is False
-    assert scheme_eval("(data-valid?)") is False
-    solver_session.solution.initialization.hybrid_initialize()
-    assert scheme_eval("(data-valid?)") is True
-    # solver_session.solution.run_calculation.iterate.get_attr("arguments")
-    # solver_session.solution.run_calculation.number_of_iterations = 5
-    # assert solver_session.solution.run_calculation.number_of_iterations == 5

ansys/fluent/tests/test_solvermode/test_controls.py

@@ -1,131 +0,0 @@
-import pytest
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_controls(mixing_elbow_settings_session):
-    solver = mixing_elbow_settings_session
-    solver.setup.models.multiphase.models = "vof"
-    assert solver.setup.models.multiphase.models() == "vof"
-    solver.setup.general.operating_conditions.gravity = {
-        "enable": True,
-        "components": [0.0, 0.0, -9.81],
-    }
-    assert solver.setup.general.operating_conditions.gravity.components() == [
-        0,
-        0,
-        -9.81,
-    ]
-    solver.setup.general.solver.time = "steady"
-    assert solver.setup.general.solver.time() == "steady"
-    param_coarsening = (
-        solver.solution.controls.advanced.multi_grid.amg_controls.coupled_parameters.coarsening_parameters
-    )
-    param_coarsening.laplace_coarsening = True
-    assert param_coarsening() == {
-        "max_coarse_levels": 40,
-        "coarsen_by_interval": 8,
-        "conservative_coarsening": False,
-        "aggressive_coarsening": False,
-        "laplace_coarsening": True,
-    }
-    param_coarsening.max_coarse_levels = 45
-    assert param_coarsening.max_coarse_levels() == 45
-
-    param_coarsening.set_state(
-        {
-            "max_coarse_levels": 48,
-            "coarsen_by_interval": 9,
-            "conservative_coarsening": True,
-            "aggressive_coarsening": True,
-            "laplace_coarsening": True,
-        }
-    )
-    assert param_coarsening.max_coarse_levels() == 48
-    assert param_coarsening.coarsen_by_interval() == 9
-    assert param_coarsening.conservative_coarsening() is True
-    assert param_coarsening.aggressive_coarsening() is True
-
-    param_fixed_cycle = (
-        solver.solution.controls.advanced.multi_grid.amg_controls.scalar_parameters.fixed_cycle_parameters
-    )
-    param_fixed_cycle.max_cycle = 300
-    assert param_fixed_cycle.max_cycle() == 300
-    param_fixed_cycle.set_state(
-        {
-            "pre_sweeps": 1,
-            "post_sweeps": 2,
-            "max_cycle": 350,
-        }
-    )
-    assert param_fixed_cycle() == {
-        "pre_sweeps": 1,
-        "post_sweeps": 2,
-        "max_cycle": 350,
-    }
-    solver.solution.methods.p_v_coupling.flow_scheme = "Coupled"
-    assert solver.solution.methods.p_v_coupling.flow_scheme() == "Coupled"
-    solver.solution.methods.p_v_coupling.coupled_form = True
-    assert solver.solution.methods.p_v_coupling.coupled_form() is True
-    solver.solution.controls.advanced.multi_grid.amg_controls.scalar_parameters.smoother_type = (
-        "Gauss-Seidel"
-    )
-    assert (
-        solver.solution.controls.advanced.multi_grid.amg_controls.scalar_parameters.smoother_type()
-        == "Gauss-Seidel"
-    )
-    assert solver.solution.controls.pseudo_time_explicit_relaxation_factor() == {
-        "global_dt_pseudo_relax": {
-            "turb-viscosity": 1.0,
-            "body-force": 1.0,
-            "k": 0.75,
-            "omega": 0.75,
-            "mp": 0.5,
-            "density": 1.0,
-            "temperature": 0.75,
-        }
-    }
-    solver.solution.controls.pseudo_time_explicit_relaxation_factor = {
-        "global_dt_pseudo_relax": {"turb-viscosity": 0.9, "body-force": 0.8}
-    }
-    assert solver.solution.controls.pseudo_time_explicit_relaxation_factor() == {
-        "global_dt_pseudo_relax": {
-            "turb-viscosity": 0.9,
-            "body-force": 0.8,
-            "k": 0.75,
-            "omega": 0.75,
-            "mp": 0.5,
-            "density": 1.0,
-            "temperature": 0.75,
-        }
-    }
-    solver.solution.methods.p_v_coupling.flow_scheme = "SIMPLE"
-    solver.solution.controls.under_relaxation = {"pressure": 0.9}
-    solver.solution.controls.under_relaxation = {"density": 0.9}
-    assert solver.solution.controls.under_relaxation() == {
-        "mom": 0.7,
-        "turb-viscosity": 1,
-        "density": 0.9,
-        "omega": 0.8,
-        "mp": 0.5,
-        "body-force": 1.0,
-        "pressure": 0.9,
-        "k": 0.8,
-        "temperature": 1.0,
-    }
-    solver.solution.controls.under_relaxation = {
-        "body-force": 0.7,
-        "density": 0.75,
-        "mom": 0.8,
-    }
-    assert solver.solution.controls.under_relaxation() == {
-        "mom": 0.8,
-        "turb-viscosity": 1,
-        "density": 0.75,
-        "omega": 0.8,
-        "mp": 0.5,
-        "body-force": 0.7,
-        "pressure": 0.9,
-        "k": 0.8,
-        "temperature": 1.0,
-    }

ansys/fluent/tests/test_solvermode/test_general.py

@@ -1,109 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-
-import ansys.fluent.core as pyfluent
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_solver_import_mixingelbow(mixing_elbow_settings_session):
-    solver_session = mixing_elbow_settings_session
-    assert solver_session.settings.is_active()
-    assert solver_session.health_check.is_serving
-    file_name = Path(pyfluent.EXAMPLES_PATH) / "jou_test_general.py"
-    solver_session.journal.start(file_name.as_posix())
-    ###
-    assert solver_session.setup.models.energy.enabled()
-    scheme_eval = solver_session.scheme_eval.scheme_eval
-    assert scheme_eval("(case-valid?)")
-    ###
-    solver_session.tui.mesh.check()
-    solver_session.tui.define.units("length", "in")
-    assert scheme_eval('(units/quantity-info "length")')[-1] == "in"
-    general_solver = solver_session.setup.general.solver
-    general_solver.time.allowed_values()
-    assert general_solver.time.allowed_values() == [
-        "steady",
-        "unsteady-1st-order",
-        "unsteady-2nd-order",
-        "unsteady-2nd-order-bounded",
-    ]
-
-    general_solver.time = "unsteady-2nd-order"
-    general_solver.time = "unsteady-1st-order"
-    general_solver.time = "unsteady-2nd-order-bounded"
-    general_solver.time = "steady"
-
-    # solver.setup.general.gravity = {"gravity": True, "y_component": -9.81}
-    # solver.mesh.scale(x_scale=0.001, y_scale=0.001, z_scale=0.001)
-
-    assert general_solver.type.get_attr("allowed-values") == [
-        "pressure-based",
-        "density-based-implicit",
-        "density-based-explicit",
-    ]
-    assert general_solver.type.allowed_values() == [
-        "pressure-based",
-        "density-based-implicit",
-        "density-based-explicit",
-    ]
-    # Below line is commented due to TFS Bug 714494
-    # assert solver_session.setup.general.solver.type.default_value() == "pressure-based"
-    assert general_solver.type.is_active()
-    assert not general_solver.type.is_read_only()
-    general_solver.type = "density-based-implicit"
-    assert general_solver.type() == "density-based-implicit"
-    general_solver.type = "density-based-explicit"
-    assert general_solver.type() == "density-based-explicit"
-    general_solver.type = "pressure-based"
-    assert general_solver.type() == "pressure-based"
-
-    auto_save = solver_session.file.auto_save
-    auto_save.data_frequency = 10
-    assert auto_save.data_frequency.default_value() == 0
-    assert auto_save.data_frequency() == 10
-    auto_save.case_frequency = "each-time"
-    assert auto_save.case_frequency() == "each-time"
-    auto_save.root_name = "file_auto_save"
-    assert auto_save.root_name() == "file_auto_save"
-    solver_session.setup.reference_values.compute(
-        from_zone_name="outlet", from_zone_type="pressure-outlet"
-    )
-    solver_session.journal.stop()
-    solver_session.tui.file.read_journal(file_name.as_posix())
-    assert auto_save.root_name() == "file_auto_save"
-    assert general_solver.type() == "pressure-based"
-    assert auto_save.data_frequency() == 10
-    assert general_solver.time() == "steady"
-    if os.path.exists(file_name):
-        os.remove(file_name)
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_disk_2d_setup(disk_settings_session):
-    session = disk_settings_session
-    assert session.settings.is_active()
-    assert session.health_check.is_serving
-    ###
-    assert not session.setup.models.energy.enabled()
-    assert session.scheme_eval.scheme_eval("(case-valid?)")
-    session.tui.mesh.check()
-
-    session_solver = session.setup.general.solver
-    assert session_solver.two_dim_space.get_attr("allowed-values") == [
-        "swirl",
-        "axisymmetric",
-        "planar",
-    ]
-    assert session_solver.two_dim_space() == "planar"
-    session_solver.two_dim_space = "axisymmetric"
-    assert session_solver.two_dim_space() == "axisymmetric"
-    session_solver.two_dim_space = "swirl"
-    assert session_solver.two_dim_space() == "swirl"
-    session_solver.two_dim_space = "planar"
-    assert session_solver.two_dim_space() == "planar"
-    # Bug 682773
-    # session.setup.general.gravity = {"gravity": True, "x_component": -9.81}

ansys/fluent/tests/test_solvermode/test_initialization.py

@@ -1,83 +0,0 @@
-import pytest
-
-from ansys.fluent.core.examples.downloads import download_file
-
-
-@pytest.mark.settings_only
-def test_initialization_settings(new_solver_session):
-    solver = new_solver_session
-    case_name = download_file(
-        "wigley.cas.h5",
-        "pyfluent/wigley_hull",
-    )
-    solver.file.read(
-        file_type="case",
-        file_name=case_name,
-        lightweight_setup=True,
-    )
-    solver.parallel.partition.set.laplace_smoothing.enabled = True
-    solver.parallel.partition.method(partition_method="metis", count=2)
-    copy_by_name = solver.setup.materials.database.copy_by_name
-    copy_by_name(type="fluid", name="air")
-    copy_by_name(type="fluid", name="water-liquid")
-    solver.setup.models.multiphase.models = "vof"
-    solver.setup.general.operating_conditions.gravity = {
-        "enable": True,
-        "components": [0.0, 0.0, -9.81],
-    }
-    solver.setup.general.solver.time = "steady"
-
-    solver.tui.define.models.multiphase.vof_sub_models("yes", "no")
-    solver.tui.define.phases.set_domain_properties.change_phases_names("water", "air")
-    solver.setup.boundary_conditions.pressure_inlet["inflow"].phase["mixture"] = {
-        "multiphase": {
-            "open_channel": True,
-            "vmag": 1.452,
-            "ht_bottom": -0.941875,
-        },
-        "momentum": {"direction_specification_method": "Direction Vector"},
-        "turbulence": {
-            "turbulent_intensity": 0.01,
-            "turbulent_viscosity_ratio": 1,
-        },
-    }
-    solver.setup.boundary_conditions.pressure_outlet["outflow"].phase["mixture"] = {
-        "multiphase": {
-            "open_channel": True,
-            "ht_bottom": -0.941875,
-            "den_spec": "From Free Surface Level",
-        },
-        "momentum": {
-            "direction_spec": "Normal to Boundary",
-            "p_backflow_spec_gen": "Static Pressure",
-        },
-        "turbulence": {
-            "turbulent_intensity": 0.01,
-            "turbulent_viscosity_ratio": 1,
-        },
-    }
-
-    solver.solution.methods.p_v_coupling.flow_scheme = "Coupled"
-    solver.solution.methods.p_v_coupling.coupled_form = True
-    solver.solution.controls.advanced.multi_grid.amg_controls.coupled_parameters.coarsening_parameters.laplace_coarsening = (
-        True
-    )
-    solver.solution.initialization.open_channel_auto_init = {
-        "boundary_zone": 3,
-        "flat_init": True,
-    }
-    assert solver.solution.initialization.open_channel_auto_init() == {
-        "boundary_zone": 3,
-        "flat_init": True,
-    }
-
-
-@pytest.mark.fluent_version(">=24.1")
-def test_fmg_initialize(new_solver_session):
-    solver = new_solver_session
-    case_name = download_file("vki_turbine.cas.gz", "pyfluent/vki_turbine")
-    solver.file.read(file_type="case", file_name=case_name)
-    solver.mesh.check()
-    solver.solution.initialization.standard_initialize()
-    solver.solution.initialization.fmg.fmg_initialize()
-    solver.tui.solve.iterate(2)

ansys/fluent/tests/test_solvermode/test_materials.py

@@ -1,40 +0,0 @@
-import pytest
-from util.solver import copy_database_material
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_solver_material(mixing_elbow_settings_session):
-    solver_session = mixing_elbow_settings_session
-    setup_materials = solver_session.setup.materials
-    copy_database_material(materials=setup_materials, type="fluid", name="water-liquid")
-    elbow_fluid = solver_session.setup.cell_zone_conditions.fluid["elbow-fluid"]
-
-    assert "water-liquid" not in elbow_fluid.material()
-    elbow_fluid.material = "water-liquid"
-    assert "water-liquid" in elbow_fluid.material()
-
-    setup_materials.database.copy_by_name(type="fluid", name="air")
-    elbow_fluid.material = "air"
-    assert "air" in elbow_fluid.material()
-    assert "air" in elbow_fluid.material()
-
-    assert setup_materials.child_names == [
-        "database",
-        "fluid",
-        "solid",
-        "mixture",
-        "inert_particle",
-        "droplet_particle",
-        "combusting_particle",
-        "particle_mixture",
-    ]
-    assert setup_materials.database.get_active_command_names() == [
-        "copy_by_formula",
-        "copy_by_name",
-        "list_materials",
-        "list_properties",
-    ]
-    setup_materials.database.copy_by_formula(type="fluid", formula="c2h6")
-    elbow_fluid.material = "ethane"
-    assert "ethane" in elbow_fluid.material()

ansys/fluent/tests/test_solvermode/test_methods.py

@@ -1,65 +0,0 @@
-import pytest
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_methods(mixing_elbow_settings_session):
-    solver = mixing_elbow_settings_session
-    solver.setup.models.multiphase.models = "vof"
-    solver.setup.general.operating_conditions.gravity = {
-        "enable": True,
-        "components": [0.0, 0.0, -9.81],
-    }
-    solver.setup.general.solver.time = "steady"
-
-    p_v_coupling = solver.solution.methods.p_v_coupling
-    p_v_coupling.flow_scheme = "Coupled"
-    p_v_coupling.coupled_form = False
-    assert p_v_coupling() == {
-        "flow_scheme": "Coupled",
-        "coupled_form": False,
-    }
-    solver.solution.methods.discretization_scheme = {"pressure": "presto!"}
-    assert solver.solution.methods.discretization_scheme() == {
-        "mom": "second-order-upwind",
-        "omega": "second-order-upwind",
-        "mp": "compressive",
-        "pressure": "presto!",
-        "k": "second-order-upwind",
-        "temperature": "second-order-upwind",
-    }
-    solver.solution.methods.gradient_scheme = "least-square-cell-based"
-    assert solver.solution.methods.gradient_scheme() == "least-square-cell-based"
-
-    enable_warped_face = solver.solution.methods.warped_face_gradient_correction
-    enable_warped_face(enable=True, mode="fast")
-    enable_warped_face(enable=False, mode="fast")
-
-    solver.solution.methods.expert.numerics_pbns.velocity_formulation = "relative"
-    assert (
-        solver.solution.methods.expert.numerics_pbns.velocity_formulation()
-        == "relative"
-    )
-    solver.solution.methods.expert.numerics_pbns = {
-        "implicit_bodyforce_treatment": True,
-        "velocity_formulation": "absolute",
-        "physical_velocity_formulation": True,
-        "disable_rhie_chow_flux": True,
-        "presto_pressure_scheme": False,
-        "first_to_second_order_blending": 1.0,
-    }
-    assert solver.solution.methods.expert.numerics_pbns() == {
-        "implicit_bodyforce_treatment": True,
-        "velocity_formulation": "absolute",
-        "physical_velocity_formulation": True,
-        "disable_rhie_chow_flux": True,
-        "presto_pressure_scheme": False,
-        "first_to_second_order_blending": 1.0,
-    }
-    solver.solution.methods.expert.numerics_pbns.presto_pressure_scheme = True
-    assert solver.solution.methods.expert.numerics_pbns.presto_pressure_scheme() is True
-    solver.solution.methods.gradient_scheme = "green-gauss-node-based"
-    assert solver.solution.methods.gradient_scheme() == "green-gauss-node-based"
-    solver.solution.methods.warped_face_gradient_correction(
-        enable=True, mode="memory-saving"
-    )

ansys/fluent/tests/test_solvermode/test_models.py

@@ -1,99 +0,0 @@
-import pytest
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_solver_models(mixing_elbow_settings_session):
-    solver_session = mixing_elbow_settings_session
-    models = solver_session.setup.models
-    assert models.energy.enabled()
-    models.energy.enabled = False
-    assert not models.energy.enabled()
-    models.multiphase.models = "vof"
-    assert models.multiphase.models() == "vof"
-    models.viscous.model = "laminar"
-    assert models.viscous.model() == "laminar"
-    models.viscous.model = "k-epsilon"
-    assert models.viscous.model() == "k-epsilon"
-
-    models.viscous.near_wall_treatment.wall_treatment = "enhanced-wall-treatment"
-    models.multiphase.models = "eulerian"
-    assert models.multiphase.models() == "eulerian"
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_disk_2d_models(disk_settings_session):
-    solver_session = disk_settings_session
-    models = solver_session.setup.models
-    solver_session.setup.general.solver.two_dim_space = "axisymmetric"
-    solver_session.setup.general.solver.two_dim_space = "swirl"
-
-    models.viscous.model = "k-epsilon"
-    near_wall = models.viscous.near_wall_treatment
-    assert models.viscous.model() == "k-epsilon"
-    near_wall.wall_treatment = "enhanced-wall-treatment"
-    assert near_wall.wall_treatment() == "enhanced-wall-treatment"
-    assert near_wall.wall_treatment.get_attr("allowed-values") == [
-        "standard-wall-fn",
-        "non-equilibrium-wall-fn",
-        "enhanced-wall-treatment",
-        "menter-lechner",
-        "scalable-wall-functions",
-    ]
-
-    near_wall.wall_treatment = "standard-wall-fn"
-    assert near_wall.wall_treatment() == "standard-wall-fn"
-    near_wall.wall_treatment = "non-equilibrium-wall-fn"
-    assert near_wall.wall_treatment() == "non-equilibrium-wall-fn"
-    near_wall.wall_treatment = "menter-lechner"
-    assert near_wall.wall_treatment() == "menter-lechner"
-    near_wall.wall_treatment = "scalable-wall-functions"
-    assert near_wall.wall_treatment() == "scalable-wall-functions"
-
-    models.viscous.model = "k-omega"
-    assert models.viscous.model() == "k-omega"
-    assert models.viscous.k_omega_model.get_attr("allowed-values") == [
-        "standard",
-        "geko",
-        "bsl",
-        "sst",
-    ]
-
-    assert models.viscous.k_omega_model() == "standard"
-    models.viscous.k_omega_model = "geko"
-    assert models.viscous.k_omega_model() == "geko"
-    models.viscous.k_omega_model = "bsl"
-    assert models.viscous.k_omega_model() == "bsl"
-    models.viscous.k_omega_model = "sst"
-    assert models.viscous.k_omega_model() == "sst"
-    assert models.viscous.model.get_attr("allowed-values") == [
-        "inviscid",
-        "laminar",
-        "k-epsilon",
-        "k-omega",
-        "mixing-length",
-        "spalart-allmaras",
-        "k-kl-w",
-        "transition-sst",
-        "reynolds-stress",
-        "scale-adaptive-simulation",
-        "detached-eddy-simulation",
-    ]
-    k_omega_options = models.viscous.k_omega_options
-    k_omega_options.kw_low_re_correction = True
-    assert k_omega_options.kw_low_re_correction() is True
-
-    turb_options = models.viscous.options
-    turb_options.production_kato_launder_enabled = True
-    assert turb_options.production_kato_launder_enabled() is True
-    turb_options.production_limiter.clip_factor = 9
-    assert turb_options.production_limiter.clip_factor() == 9
-    turb_expert = models.viscous.turbulence_expert
-    turb_expert.turb_non_newtonian = True
-    assert turb_expert.turb_non_newtonian() is True
-
-    models.viscous.model = "laminar"
-    assert models.viscous.model() == "laminar"
-    models.viscous.model = "spalart-allmaras"
-    assert models.viscous.model() == "spalart-allmaras"