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

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

@@ -1,263 +0,0 @@
-from collections import OrderedDict
-import os
-from pathlib import Path
-import shutil
-import tempfile
-
-import pytest
-from test_utils import pytest_approx
-
-import ansys.fluent.core as pyfluent
-from ansys.fluent.core import examples
-from ansys.fluent.core.filereader.case_file import CaseFile
-from ansys.fluent.core.utils.fluent_version import FluentVersion
-
-
-@pytest.mark.nightly
-@pytest.mark.codegen_required
-@pytest.mark.fluent_version("latest")
-def test_simple_solve(mixing_elbow_param_case_data_session):
-    """Use case 1: This optiSLang integration test performs these steps.
-
-    - Reads a case file with and without data file
-    - Gets input and output parameters and creates dictionary
-    - Sets a variation on input parameters
-    - Solve
-    - Reread data
-
-    This test queries the following using PyTest:
-    - Session health
-    - Input parameters
-    - Output parameters
-    """
-    # Step 1: Launch fluent session and read case file with and without data file
-    solver_session = mixing_elbow_param_case_data_session
-    assert solver_session.health_check.is_serving
-    case_path = examples.path("elbow_param.cas.h5")
-    solver_session.settings.file.read_case_data(file_name=case_path)
-
-    # Step 2: Get input and output parameters and create a dictionary
-    reader = CaseFile(case_file_name=case_path)
-
-    input_parameters = {}
-    for p in reader.input_parameters():
-        input_parameters[p.name] = (p.value, p.numeric_value, p.units)
-    output_parameters = {}
-    for o in reader.output_parameters():
-        output_parameters[o.name] = (0, o.units)
-    solver_session.settings.file.read_case(file_name=case_path)
-
-    input_parameters = input_parameters["inlet2_temp"]
-    output_parameters = output_parameters["outlet_temp-op"]
-
-    # Step 3: Set a variation on these input parameters
-    # variations/designs are generated by optiSLang based on
-    # algorithm selected
-    inputs_table = solver_session.settings.parameters.input_parameters.expression[
-        "inlet2_temp"
-    ] = {"value": 600}
-
-    Path(pyfluent.EXAMPLES_PATH).mkdir(parents=True, exist_ok=True)
-    tmp_save_path = tempfile.mkdtemp(dir=pyfluent.EXAMPLES_PATH)
-    design_elbow_param_path = Path(tmp_save_path) / "design_elbow_param.cas.h5"
-    solver_session.settings.file.write_case(file_name=str(design_elbow_param_path))
-
-    assert design_elbow_param_path.exists()
-
-    # Step 4: Solve
-    solver_session.settings.solution.initialization.standard_initialize()
-
-    # check if solution is steady or transient
-    workflow = solver_session.rp_vars("rp-unsteady?")
-
-    # iterate workflow
-    if workflow:
-        solver_session.settings.solution.run_calculation.dual_time_iterate()
-    else:
-        solver_session.settings.solution.run_calculation.iterate()
-
-    convergence = solver_session.rp_vars("solution/converged?")
-
-    # solution output (test conditional statement)
-    if not convergence:  # -> let user know
-        print("Failed to converge")
-    else:
-        print("Solution is converged")
-
-    assert convergence, "Solution failed to converge"
-
-    # Step 5: Read the data again from the case and data file
-    solver_session.settings.file.read_case_data(file_name=case_path)
-
-    inputs_table = solver_session.settings.parameters.input_parameters.expression[
-        "inlet2_temp"
-    ]()
-    assert input_parameters[0] == "500 [K]"
-    assert inputs_table["value"] == 500.0
-
-    fluent_output_table = solver_session.settings.parameters.output_parameters.list()
-    for key, entry in fluent_output_table.items():
-        output_value = entry[0]
-        output_unit = entry[1]
-
-    assert output_value == pytest_approx(322.3360076327905)
-
-    # output_unit should assert the unit string but it doesn't currently
-    # A bug has been submitted to address this
-    assert output_unit == "K"
-    assert output_parameters[1] == "K"
-
-    solver_session.exit()
-
-
-@pytest.mark.nightly
-@pytest.mark.codegen_required
-@pytest.mark.fluent_version("latest")
-def test_generate_read_mesh(mixing_elbow_geometry_filename):
-    """Use case 2: This optiSLang integration test performs these steps.
-
-    - Launch Fluent in Meshing Mode
-    - Generate mesh with default workflow settings
-    - Read created mesh file
-    - Switch to solution and write case file
-
-    This test queries the following using PyTest:
-    - Session health
-    """
-    # Step 1: Launch fluent session in meshing mode
-    meshing = pyfluent.launch_fluent(
-        mode="meshing", precision="double", processor_count=2
-    )
-    assert meshing.health_check.is_serving
-    temporary_resource_path = os.path.join(
-        pyfluent.EXAMPLES_PATH, "test_generate_read_mesh_resources"
-    )
-    if os.path.exists(temporary_resource_path):
-        shutil.rmtree(temporary_resource_path, ignore_errors=True)
-    if not os.path.exists(temporary_resource_path):
-        os.mkdir(temporary_resource_path)
-
-    # Step 2: Generate mesh from geometry with default workflow settings
-    meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
-    geo_import = meshing.workflow.TaskObject["Import Geometry"]
-    geo_import.Arguments = dict(FileName=mixing_elbow_geometry_filename)
-    geo_import.Execute()
-    meshing.workflow.TaskObject["Generate the Volume Mesh"].Execute()
-    meshing.tui.mesh.check_mesh()
-    gz_path = str(Path(temporary_resource_path) / "default_mesh.msh.gz")
-    h5_path = str(Path(temporary_resource_path) / "default_mesh.msh.h5")
-    meshing.tui.file.write_mesh(gz_path)
-    meshing.tui.file.write_mesh(h5_path)
-    assert (Path(temporary_resource_path) / "default_mesh.msh.gz").exists()
-    assert (Path(temporary_resource_path) / "default_mesh.msh.h5").exists()
-
-    # Step 3: use created mesh file - .msh.gz/.msh.h5
-    meshing.tui.file.read_mesh(gz_path, "ok")
-    meshing.tui.file.read_mesh(h5_path, "ok")
-
-    # Step 4: Switch to solution and Write case file
-    solver = meshing.switch_to_solver()
-    solver.settings.solution.initialization.hybrid_initialize()
-    gz_path = str(Path(temporary_resource_path) / "default_case.cas.gz")
-    h5_path = str(Path(temporary_resource_path) / "default_case.cas.h5")
-    write_case = solver.settings.file.write_case
-    write_case(file_name=gz_path)
-    write_case(file_name=h5_path)
-    assert (Path(temporary_resource_path) / "default_case.cas.gz").exists()
-    assert (Path(temporary_resource_path) / "default_case.cas.h5").exists()
-    solver.exit()
-    shutil.rmtree(temporary_resource_path, ignore_errors=True)
-
-
-@pytest.mark.nightly
-@pytest.mark.codegen_required
-@pytest.mark.fluent_version("latest")
-def test_case_file():
-    case_path = examples.download_file(
-        "elbow_param.cas.h5", "pyfluent/mixing_elbow", return_without_path=False
-    )
-    reader = CaseFile(case_file_name=case_path)
-
-    assert reader.num_dimensions() == 3
-    assert reader.precision() == 2
-
-    plist = []
-    olist = []
-    for p in reader.input_parameters():
-        ipar = OrderedDict()
-        ipar["name"] = p.name
-        ipar["numeric_value"] = p.numeric_value
-        ipar["units"] = p.units
-        plist.append(ipar)
-
-    input_params = plist[0]
-    assert input_params["name"] == "inlet2_temp"
-    assert input_params["numeric_value"] == 500.0
-    assert input_params["units"] == "K"
-
-    for o in reader.output_parameters():
-        opar = OrderedDict()
-        opar["name"] = o.name
-        opar["numeric_value"] = 0.0
-        opar["units"] = o.units
-        olist.append(opar)
-
-    output_params = olist[0]
-    assert output_params["name"] == "outlet_temp-op"
-    assert output_params["numeric_value"] == 0.0
-    assert output_params["units"] == "K"
-
-
-@pytest.mark.nightly
-@pytest.mark.codegen_required
-@pytest.mark.fluent_version("latest")
-def test_parameters(mixing_elbow_param_case_data_session):
-    solver_session = mixing_elbow_param_case_data_session
-    input_params = solver_session.settings.parameters.input_parameters.expression[
-        "inlet2_temp"
-    ]
-    assert input_params() == {"name": "inlet2_temp", "value": 500.0}
-
-    output_params = solver_session.settings.parameters.output_parameters.list()
-    output_jdict = {}
-    for key, entry in output_params.items():
-        output_jdict[key] = entry[0]
-        output_jdict[key] = entry[1]
-
-    assert output_jdict == {"outlet_temp-op": "K"}
-
-
-@pytest.mark.nightly
-@pytest.mark.codegen_required
-@pytest.mark.fluent_version("latest")
-def test_parametric_project(mixing_elbow_param_case_data_session, new_solver_session):
-    session1 = mixing_elbow_param_case_data_session
-    Path(pyfluent.EXAMPLES_PATH).mkdir(parents=True, exist_ok=True)
-    tmp_save_path = tempfile.mkdtemp(dir=pyfluent.EXAMPLES_PATH)
-    init_project = Path(tmp_save_path) / "mixing_elbow_param_init.flprj"
-    project_file = Path(tmp_save_path) / "mixing_elbow_param.flprj"
-    session1.settings.parametric_studies.initialize(project_filename=str(init_project))
-    session1.settings.file.parametric_project.save_as(
-        project_filename=str(project_file)
-    )
-    assert project_file.exists()
-
-    session2 = new_solver_session
-    session2.settings.file.parametric_project.open(project_filename=str(project_file))
-    current_pstudy_name = session2.settings.current_parametric_study()
-    assert current_pstudy_name == "elbow_param-Solve"
-    pstudy = session2.settings.parametric_studies[current_pstudy_name]
-    base_dp = pstudy.design_points["Base DP"]()
-    base_inputs = base_dp["input_parameters"]
-    assert base_inputs == {"inlet2_temp": 500.0}
-    base_outputs = base_dp["output_parameters"]
-    assert base_outputs == {"outlet_temp-op": pytest_approx(322.336008)}
-    if session2.get_fluent_version() < FluentVersion.v251:
-        pstudy.design_points.create_1()
-        dp = pstudy.design_points["DP1"]
-    else:
-        dp = pstudy.design_points.create()
-    dp.input_parameters["inlet2_temp"] = 600.0
-    pstudy.design_points.update_selected(design_points=["DP1"])
-    fluent_output_table = dp.output_parameters()
-    assert fluent_output_table["outlet_temp-op"] != 0.0

ansys/fluent/tests/parametric/test_local_parametric_run.py

@@ -1,36 +0,0 @@
-import pytest
-
-from ansys.fluent.core import examples
-from ansys.fluent.core.parametric import (
-    LocalParametricStudy,
-    convert_design_point_parameter_units,
-)
-
-
-@pytest.mark.standalone
-def test_local_parametric_run():
-    case_filepath = examples.download_file(
-        "Static_Mixer_Parameters.cas.h5",
-        "pyfluent/static_mixer",
-        return_without_path=False,
-    )
-
-    local_study = LocalParametricStudy(case_filepath=case_filepath)
-
-    for idx in range(4):
-        design_point = local_study.add_design_point("dp_" + str(idx))
-        design_point.input_parameters["inlet1_vel"] = float(2 + idx)
-
-    local_study.run_in_fluent(num_servers=2)
-
-    table = local_study.design_point_table
-
-    assert len(table) == 5
-
-    for point in table:
-        ins = convert_design_point_parameter_units(point.input_parameters)
-        outs = point.output_parameters
-        new_inlet_velocity = ins["inlet1_vel"]
-        new_outlet_velocity = outs["outlet-vel-avg-op"]
-        assert new_inlet_velocity
-        assert new_outlet_velocity

ansys/fluent/tests/parametric/test_local_parametric_setup.py

@@ -1,34 +0,0 @@
-from ansys.fluent.core import examples
-from ansys.fluent.core.parametric import LocalParametricStudy
-
-
-def test_local_parametric_setup():
-    case_filepath = examples.download_file(
-        "Static_Mixer_Parameters.cas.h5",
-        "pyfluent/static_mixer",
-        return_without_path=False,
-    )
-
-    local_study = LocalParametricStudy(case_filepath=case_filepath)
-
-    base_design_point = local_study.design_point("Base DP")
-
-    input_parameters = base_design_point.input_parameters
-
-    assert len(input_parameters) == 4
-
-    assert input_parameters["inlet1_temp"] == "300 [K]"
-
-    assert input_parameters["inlet1_vel"] == "1 [m/s]"
-
-    assert input_parameters["inlet2_temp"] == "350 [K]"
-
-    assert input_parameters["inlet2_vel"] == "1 [m/s]"
-
-    output_parameters = base_design_point.output_parameters
-
-    assert len(output_parameters) == 2
-
-    assert not output_parameters["outlet-temp-avg-op"]
-
-    assert not output_parameters["outlet-vel-avg-op"]

ansys/fluent/tests/parametric/test_parametric_workflow.py

@@ -1,279 +0,0 @@
-import os
-from pathlib import Path, PurePosixPath
-import tempfile
-
-import pytest
-from test_utils import pytest_approx
-
-import ansys.fluent.core as pyfluent
-from ansys.fluent.core import examples
-from ansys.fluent.core.utils.file_transfer_service import RemoteFileTransferStrategy
-from ansys.fluent.core.utils.fluent_version import FluentVersion
-
-
-@pytest.mark.nightly
-@pytest.mark.fluent_version("latest")
-def test_parametric_workflow():
-    # parent path needs to exist for mkdtemp
-    Path(pyfluent.EXAMPLES_PATH).mkdir(parents=True, exist_ok=True)
-    tmp_save_path = tempfile.mkdtemp(dir=pyfluent.EXAMPLES_PATH)
-    if pyfluent.USE_FILE_TRANSFER_SERVICE:
-        file_transfer_service = RemoteFileTransferStrategy(mount_source=tmp_save_path)
-    import_file_name = examples.download_file(
-        "Static_Mixer_main.cas.h5", "pyfluent/static_mixer", save_path=tmp_save_path
-    )
-    if os.getenv("PYFLUENT_LAUNCH_CONTAINER") == "1":
-        inside_container = True
-        config_dict = {}
-        config_dict.update(mount_source=tmp_save_path)
-        if pyfluent.USE_FILE_TRANSFER_SERVICE:
-            solver_session = pyfluent.launch_fluent(
-                processor_count=2,
-                container_dict=config_dict,
-                file_transfer_service=file_transfer_service,
-            )
-        else:
-            solver_session = pyfluent.launch_fluent(
-                processor_count=2,
-                container_dict=config_dict,
-            )
-        container_workdir = PurePosixPath(pyfluent.CONTAINER_MOUNT_TARGET)
-    else:
-        inside_container = False
-        solver_session = pyfluent.launch_fluent(processor_count=2, cwd=tmp_save_path)
-    solver_session.file.read_case(file_name=import_file_name)
-    solver_session.solution.run_calculation.iter_count = 100
-    solver_session.tui.define.parameters.enable_in_TUI("yes")
-
-    velocity_inlet = solver_session.tui.define.boundary_conditions.set.velocity_inlet
-    velocity_inlet("inlet1", (), "vmag", "yes", "inlet1_vel", 1, "quit")
-    velocity_inlet("inlet1", (), "temperature", "yes", "inlet1_temp", 300, "quit")
-    velocity_inlet("inlet2", (), "vmag", "yes", "no", "inlet2_vel", 1, "quit")
-    velocity_inlet("inlet2", (), "temperature", "yes", "no", "inlet2_temp", 350, "quit")
-
-    solver_session.solution.report_definitions.surface["outlet-temp-avg"] = {}
-    outlet_temp_avg = solver_session.solution.report_definitions.surface[
-        "outlet-temp-avg"
-    ]
-    outlet_temp_avg.report_type = "surface-areaavg"
-    outlet_temp_avg.field = "temperature"
-    outlet_temp_avg.surface_names = ["outlet"]
-
-    solver_session.solution.report_definitions.surface["outlet-vel-avg"] = {}
-    outlet_vel_avg = solver_session.solution.report_definitions.surface[
-        "outlet-vel-avg"
-    ]
-    outlet_vel_avg.report_type = "surface-areaavg"
-    outlet_vel_avg.field = "velocity-magnitude"
-    outlet_vel_avg.surface_names = ["outlet"]
-
-    create_output_param = solver_session.tui.define.parameters.output_parameters.create
-    create_output_param("report-definition", "outlet-temp-avg")
-    create_output_param("report-definition", "outlet-vel-avg")
-
-    solver_session.tui.solve.monitors.residual.criterion_type("0")
-
-    case_path = Path(tmp_save_path) / "Static_Mixer_Parameters.cas.h5"
-    if inside_container:
-        write_case_path = str(container_workdir / "Static_Mixer_Parameters.cas.h5")
-    else:
-        write_case_path = str(case_path)
-    solver_session.file.write(file_type="case", file_name=write_case_path)
-
-    assert case_path.exists()
-    assert len(solver_session.parametric_studies) == 0
-    solver_session.parametric_studies.initialize()
-    assert len(solver_session.parametric_studies) == 1
-    study1_name = "Static_Mixer_main-Solve"
-    assert study1_name in solver_session.parametric_studies
-    study1 = solver_session.parametric_studies[study1_name]
-    assert len(study1.design_points) == 1
-    base_dp_name = "Base DP"
-    assert "Base DP" in study1.design_points
-    base_dp = study1.design_points[base_dp_name]
-    base_dp.input_parameters["inlet1_vel"] = 0.5
-    assert base_dp.input_parameters["inlet1_vel"]() == 0.5
-    assert base_dp.input_parameters["inlet2_temp"]() == 350.0
-    assert base_dp.input_parameters["inlet2_vel"]() == 1.0
-    assert base_dp.input_parameters["inlet1_temp"]() == 300.0
-    study1.design_points.update_current()
-    assert len(study1.design_points) == 1
-    assert base_dp.output_parameters["outlet-temp-avg-op"]() == pytest_approx(
-        333.348727
-    )
-    assert base_dp.output_parameters["outlet-vel-avg-op"]() == pytest_approx(1.506855)
-    dp_names = set([*study1.design_points.keys()])
-    if solver_session.get_fluent_version() < FluentVersion.v251:
-        study1.design_points.create_1()
-        dp1_name = set([*study1.design_points.keys()]).difference(dp_names).pop()
-        dp1 = study1.design_points[dp1_name]
-    else:
-        dp1 = study1.design_points.create()
-    dp1.input_parameters["inlet1_temp"] = 500
-    dp1.input_parameters["inlet1_vel"] = 1
-    dp1.input_parameters["inlet2_vel"] = 1
-    assert len(study1.design_points) == 2
-    assert dp1.input_parameters["inlet1_temp"]() == 500
-    assert dp1.input_parameters["inlet1_vel"]() == 1
-    assert dp1.input_parameters["inlet2_vel"]() == 1
-    assert dp1.input_parameters["inlet2_temp"]() == 350.0
-    dp_names = set([*study1.design_points.keys()])
-    study1.design_points.duplicate(design_point=dp1.obj_name)
-    dp2_name = set([*study1.design_points.keys()]).difference(dp_names).pop()
-    dp2 = study1.design_points[dp2_name]
-    assert dp1.input_parameters() == dp2.input_parameters()
-    assert len(study1.design_points) == 3
-    assert study1.current_design_point() == base_dp_name
-    study1.design_points.set_as_current(design_point=dp2_name)
-    assert study1.current_design_point() == dp2_name
-    study1.design_points.update_all()
-    assert len(study1.design_points) == 3
-    assert base_dp.output_parameters["outlet-temp-avg-op"]() == pytest_approx(
-        333.348727
-    )
-    assert base_dp.output_parameters["outlet-vel-avg-op"]() == pytest_approx(1.506855)
-    assert dp1.output_parameters["outlet-temp-avg-op"]() == pytest_approx(425.004045)
-    assert dp1.output_parameters["outlet-vel-avg-op"]() == pytest_approx(2.029792)
-    assert dp2.output_parameters["outlet-temp-avg-op"]() == pytest_approx(425.004045)
-    assert dp2.output_parameters["outlet-vel-avg-op"]() == pytest_approx(2.029792)
-
-    design_point_table = Path(tmp_save_path) / "design_point_table_study_1.csv"
-    if inside_container:
-        write_design_table = str(container_workdir / "design_point_table_study_1.csv")
-    else:
-        write_design_table = str(design_point_table)
-    solver_session.parametric_studies.export_design_table(filepath=write_design_table)
-    assert design_point_table.exists()
-
-    study1.design_points.delete_design_points(design_points=[dp1.obj_name])
-    assert len(study1.design_points) == 2
-    study_names = set([*solver_session.parametric_studies.keys()])
-    solver_session.parametric_studies.duplicate()
-    assert len(solver_session.parametric_studies) == 2
-    study2_name = (
-        set([*solver_session.parametric_studies.keys()]).difference(study_names).pop()
-    )
-    study2 = solver_session.parametric_studies[study2_name]
-    assert len(study2.design_points) == 2
-    solver_session.parametric_studies[study2_name].rename("New Study")
-    assert "New Study" in solver_session.parametric_studies
-    del solver_session.parametric_studies[study1_name]
-    assert len(solver_session.parametric_studies) == 1
-
-    project_file_name = Path(tmp_save_path) / "static_mixer_study.flprj"
-    if inside_container:
-        write_project_file_name = str(container_workdir / "static_mixer_study.flprj")
-    else:
-        write_project_file_name = str(project_file_name)
-
-    solver_session.file.parametric_project.save_as(
-        project_filename=write_project_file_name
-    )
-    assert project_file_name.exists()
-    solver_session.exit()
-
-    if inside_container:
-        if pyfluent.USE_FILE_TRANSFER_SERVICE:
-            solver_session = pyfluent.launch_fluent(
-                processor_count=2,
-                container_dict=config_dict,
-                file_transfer_service=file_transfer_service,
-            )
-        else:
-            solver_session = pyfluent.launch_fluent(
-                processor_count=2,
-                container_dict=config_dict,
-            )
-    else:
-        solver_session = pyfluent.launch_fluent(processor_count=2, cwd=tmp_save_path)
-
-    solver_session.file.parametric_project.open(
-        project_filename=write_project_file_name
-    )
-    solver_session.file.parametric_project.save()
-    project_save_as_name = Path(tmp_save_path) / "static_mixer_study_save_as.flprj"
-    if inside_container:
-        write_project_save_as_name = str(
-            container_workdir / "static_mixer_study_save_as.flprj"
-        )
-    else:
-        write_project_save_as_name = str(project_save_as_name)
-
-    solver_session.file.parametric_project.save_as(
-        project_filename=write_project_save_as_name
-    )
-    assert project_save_as_name.exists()
-
-    project_save_as_copy_name = (
-        Path(tmp_save_path) / "static_mixer_study_save_copy_as.flprj"
-    )
-    if inside_container:
-        write_project_save_as_copy_name = str(
-            container_workdir / "static_mixer_study_save_copy_as.flprj"
-        )
-    else:
-        write_project_save_as_copy_name = str(project_save_as_copy_name)
-    solver_session.file.parametric_project.save_as_copy(
-        project_filename=write_project_save_as_copy_name
-    )
-    assert project_save_as_copy_name.exists()
-
-    archive_name = Path(tmp_save_path) / "static_mixer_study.flprz"
-    if inside_container:
-        write_archive_name = str(container_workdir / "static_mixer_study.flprz")
-    else:
-        write_archive_name = str(archive_name)
-    solver_session.file.parametric_project.archive(archive_name=write_archive_name)
-    assert archive_name.exists()
-    solver_session.exit()
-
-
-@pytest.mark.fluent_version(">=24.2")
-def test_parameters_list_function(static_mixer_settings_session):
-    solver = static_mixer_settings_session
-    solver.tui.define.parameters.enable_in_TUI("yes")
-
-    velocity_inlet = solver.tui.define.boundary_conditions.set.velocity_inlet
-    velocity_inlet("inlet1", (), "vmag", "yes", "inlet1_vel", 1, "quit")
-    velocity_inlet("inlet1", (), "temperature", "yes", "inlet1_temp", 300, "quit")
-    velocity_inlet("inlet2", (), "vmag", "yes", "no", "inlet2_vel", 1, "quit")
-    velocity_inlet("inlet2", (), "temperature", "yes", "no", "inlet2_temp", 350, "quit")
-
-    solver.solution.report_definitions.surface["outlet-temp-avg"] = {}
-    outlet_temp_avg = solver.solution.report_definitions.surface["outlet-temp-avg"]
-    outlet_temp_avg.report_type = "surface-areaavg"
-    outlet_temp_avg.field = "temperature"
-    outlet_temp_avg.surface_names = ["outlet"]
-
-    solver.solution.report_definitions.surface["outlet-vel-avg"] = {}
-    outlet_vel_avg = solver.solution.report_definitions.surface["outlet-vel-avg"]
-    outlet_vel_avg.report_type = "surface-areaavg"
-    outlet_vel_avg.field = "velocity-magnitude"
-    outlet_vel_avg.surface_names = ["outlet"]
-
-    create_output_param = solver.tui.define.parameters.output_parameters.create
-    create_output_param("report-definition", "outlet-temp-avg")
-    create_output_param("report-definition", "outlet-vel-avg")
-
-    # Create a unitless output parameter
-    unitless_quantity = solver.settings.solution.report_definitions.surface.create(
-        "temp-outlet-uniformity"
-    )
-    unitless_quantity.report_type = "surface-masswtui"
-    unitless_quantity.field = "temperature"
-    unitless_quantity.surface_names = ["outlet"]
-    unitless_quantity.output_parameter = True
-
-    input_parameters_list = solver.parameters.input_parameters.list()
-    output_parameters_list = solver.parameters.output_parameters.list()
-    assert input_parameters_list == {
-        "inlet1_temp": [300.0, "K"],
-        "inlet1_vel": [1.0, "m/s"],
-        "inlet2_temp": [350.0, "K"],
-        "inlet2_vel": [1.0, "m/s"],
-    }
-    assert output_parameters_list == {
-        "outlet-temp-avg-op": [0.0, "K"],
-        "outlet-vel-avg-op": [0.0, "m/s"],
-        "temp-outlet-uniformity-op": [0.0, ""],
-    }