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

ansys/fluent/tests/test_solvermode/test_named_expressions.py

@@ -1,35 +0,0 @@
-import pytest
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version(">=24.1")
-def test_expression(mixing_elbow_settings_session):
-    solver_session = mixing_elbow_settings_session
-    # Case file already has energy model turned on
-    # solver_session.setup.models.energy.enabled = True
-    expressions = solver_session.setup.named_expressions
-    expressions["r"] = {}
-    expressions["r"] = {"definition": "(Position.z**2.0 +Position.x**2.0)**0.5"}
-    expressions["r1"] = {}
-    expressions["r1"] = {"definition": "1-(r/0.014[m])"}
-    expressions["v1"] = {}
-    expressions["v1"] = {"definition": "r1**(1.0/6.0)"}
-    expressions["vel_cold"] = {}
-    expressions["vel_cold"] = {"definition": "1.264 * 1.43 [m s^-1] * max(0,v1)"}
-
-    assert expressions["r"].definition() == "(Position.z**2.0 +Position.x**2.0)**0.5"
-    assert expressions["r1"].definition() == "1-(r/0.014[m])"
-    assert expressions["v1"].definition() == "r1**(1.0/6.0)"
-    assert expressions["vel_cold"].definition() == "1.264 * 1.43 [m s^-1] * max(0,v1)"
-
-    velocity_inlet = solver_session.setup.boundary_conditions.velocity_inlet
-    velocity_inlet["cold-inlet"].momentum = {"velocity": "vel_cold"}
-    velocity_inlet["hot-inlet"].momentum = {"velocity": "max(vel_cold, 1.5 [m/s])"}
-    assert velocity_inlet["cold-inlet"].momentum.velocity() == {
-        "option": "value",
-        "value": "vel_cold",
-    }
-    assert velocity_inlet["hot-inlet"].momentum.velocity() == {
-        "option": "value",
-        "value": "max(vel_cold, 1.5 [m/s])",
-    }

ansys/fluent/tests/test_solvermode/test_post_vector.py

@@ -1,22 +0,0 @@
-import pytest
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version("latest")
-def test_post_elbow(mixing_elbow_settings_session):
-    mixing_elbow_settings_session.results.graphics.vector[
-        "velocity_vector_symmetry"
-    ] = {}
-    vector_graphics = mixing_elbow_settings_session.results.graphics.vector[
-        "velocity_vector_symmetry"
-    ]
-    vector_graphics.field = "temperature"
-    vector_graphics.surfaces_list = ["symmetry-xyplane"]
-    vector_graphics.scale.scale_f = 4
-    vector_graphics.style = "arrow"
-    vel_vector = vector_graphics()
-    assert vel_vector.get("name") == "velocity_vector_symmetry"
-    assert vel_vector.get("field") == "temperature"
-    assert vel_vector.get("surfaces_list") == ["symmetry-xyplane"]
-    assert vel_vector.get("scale") == {"auto_scale": True, "scale_f": 4.0}
-    assert vel_vector.get("style") == "arrow"

ansys/fluent/tests/test_solvermode/test_species_model.py

@@ -1,67 +0,0 @@
-import pytest
-
-
-@pytest.mark.settings_only
-@pytest.mark.fluent_version(">=24.1")
-def test_change_create_mixture(mixing_elbow_settings_session):
-    solver_session = mixing_elbow_settings_session
-
-    # Test turning on species transport model
-    species_mdl = solver_session.setup.models.species.model
-
-    assert species_mdl.option() == "off"
-    species_mdl.option = "species-transport"
-    assert species_mdl.option() == "species-transport"
-
-    # Test command names list
-    materials = solver_session.setup.materials
-    assert sorted(materials.mixture.command_names) == sorted(
-        ["delete", "list", "list_properties", "make_a_copy", "rename"]
-    )
-
-    # Test change/creating a mixture with custom species from template
-    custom_species_1 = materials.fluid.create("custom-species-1")
-    custom_species_2 = materials.fluid.create("custom-species-2")
-    solver_session.tui.define.materials.change_create(
-        "mixture-template",  # Change/create mixture-template
-        "custom-mixture",  # Rename to `custom-mixture`
-        "yes",  # Change mixture species
-        "2",  # Set number of species to 2
-        custom_species_1.name(),  # Set species 1
-        custom_species_2.name(),  # Set species 2
-        "0",  # No surface species
-        "0",  # No site species
-        "no",  # Do not change density
-        "no",  # Do not change specific heat
-        "no",  # Do not change thermal conductivity
-        "no",  # Do not change viscosity
-        "no",  # Do not change mass diffusivity
-        "no",  # Do not change speed of sound
-        "yes",  # Overwrite mixture-template
-    )
-    assert "custom-mixture" in materials.mixture.keys()
-    assert "mixture-template" not in materials.mixture.keys()
-
-    # Test that mixture contains correct species
-    mix_species = solver_session.setup.materials.mixture[
-        "custom-mixture"
-    ].species.volumetric_species.keys()
-    assert "custom-species-1" in mix_species
-    assert "custom-species-2" in mix_species
-
-    # Test copying a mixture
-    materials.mixture.make_a_copy(
-        from_="custom-mixture",
-        to="custom-mixture-copy",
-    )
-    assert "custom-mixture-copy" in materials.mixture.keys()
-
-    # Test changing cellzone mixture
-    elbow_zone = solver_session.setup.cell_zone_conditions.fluid["elbow-fluid"]
-    assert elbow_zone.material() == "custom-mixture"
-    elbow_zone.material = "custom-mixture-copy"
-    assert elbow_zone.material() == "custom-mixture-copy"
-
-    # Test deleting a mixture
-    materials.mixture.delete(name_list=["custom-mixture"])
-    assert "custom-mixture" not in materials.mixture.keys()

ansys/fluent/tests/test_streaming_services.py

@@ -1,52 +0,0 @@
-import time
-
-from ansys.fluent.core import connect_to_fluent
-from ansys.fluent.core.utils.fluent_version import FluentVersion
-
-
-def transcript(data):
-    transcript.data = data
-
-
-def run_transcript(i, ip, port, password):
-    transcript("")
-    session = connect_to_fluent(
-        ip=ip, port=port, password=password, cleanup_on_exit=False
-    )
-    session.transcript.register_callback(transcript)
-
-    transcript_checked = False
-    transcript_passed = False
-
-    if i % 5 == 0:
-        time.sleep(0.5)
-        session.scheme_eval.scheme_eval("(pp 'test)")
-        time.sleep(0.5)
-        if not transcript.data:
-            assert transcript.data == ""
-        else:
-            assert transcript.data == "test"
-            transcript_passed = True
-        transcript_checked = True
-
-    return transcript_checked, transcript_passed
-
-
-def test_transcript(new_solver_session):
-    solver = new_solver_session
-    ip = solver.connection_properties.ip
-    port = solver.connection_properties.port
-    password = solver.connection_properties.password
-
-    total_checked_transcripts = 0
-    total_passed_transcripts = 0
-
-    for i in range(100):
-        transcript_checked, transcript_passed = run_transcript(i, ip, port, password)
-        total_checked_transcripts += int(transcript_checked)
-        total_passed_transcripts += int(transcript_passed)
-
-    if solver.get_fluent_version() >= FluentVersion.v232:
-        assert total_checked_transcripts == total_passed_transcripts
-    else:
-        assert total_checked_transcripts >= total_passed_transcripts

ansys/fluent/tests/test_systemcoupling.py

@@ -1,44 +0,0 @@
-import pytest
-
-
-@pytest.mark.fluent_version(">=25.1")
-def test_systemcoupling_mixing_elbow_settings_apis(mixing_elbow_case_data_session):
-    """Test System Coupling related settings APIs"""
-    solver = mixing_elbow_case_data_session
-    # enable the feature flag to be able to make the queries
-    solver.scheme_eval.scheme_eval("(enable-feature 'sc/participant-info)")
-    elbow_fluid = "elbow-fluid"
-    region_names = solver.settings.setup.models.system_coupling.get_all_regions()
-    assert elbow_fluid in region_names
-    # elbow fluid must be a volume
-    assert (
-        solver.settings.setup.models.system_coupling.get_topology(
-            region_name=elbow_fluid
-        )
-        == "Volume"
-    )
-
-
-def _test_systemcoupling_mixing_elbow_settings_common(mixing_elbow_case_data_session):
-    solver = mixing_elbow_case_data_session
-    # check participant type, analysis type, regions, and variables
-    assert solver.system_coupling.participant_type == "FLUENT"
-    assert solver.system_coupling.get_analysis_type() == "Steady"
-    regions = solver.system_coupling.get_regions()
-    variables = solver.system_coupling.get_variables()
-    # [wall-inlet, wall-elbow, elbow-fluid, hot-inlet, cold-inlet, outlet]
-    assert len(regions) >= 6
-    # [force, temp, htc, hflow, nwt, hrate, e-cond, lorentz-force]
-    assert len(variables) >= 8
-
-
-@pytest.mark.fluent_version(">=25.1")
-def test_systemcoupling_mixing_elbow_settings(mixing_elbow_case_data_session):
-    """Very superficial test of System Coupling related settings."""
-    _test_systemcoupling_mixing_elbow_settings_common(mixing_elbow_case_data_session)
-
-
-@pytest.mark.fluent_version(">=24.1,<25.1")
-def test_systemcoupling_mixing_elbow_settings_legacy(mixing_elbow_case_data_session):
-    """Test legacy implementation of getting System Coupling related settings."""
-    _test_systemcoupling_mixing_elbow_settings_common(mixing_elbow_case_data_session)

ansys/fluent/tests/test_topy.py

@@ -1,179 +0,0 @@
-import os
-from pathlib import Path
-import time
-
-import pytest
-
-import ansys.fluent.core as pyfluent
-
-
-@pytest.mark.skip(reason="Unable to read generated python journal from fluent.")
-def test_single_jou():
-    file_name = os.path.join(pyfluent.EXAMPLES_PATH, "jou1.jou")
-
-    with open(file_name, "w") as journal:
-        journal.write('(display "from jou1.jou")')
-
-    solver = pyfluent.launch_fluent(mode="solver", topy=file_name)
-    solver.exit()
-
-    with open(file_name) as file:
-        returned = file.readlines()
-
-    if os.path.exists(file_name):
-        os.remove(file_name)
-
-    assert returned
-
-    gen_file_name = os.path.join(os.getcwd(), f"{Path(file_name).stem}.py")
-
-    with open(gen_file_name) as file:
-        gen_returned = file.readlines()
-
-    assert gen_returned
-
-    while os.path.exists(gen_file_name):
-        try:
-            os.remove(gen_file_name)
-        except PermissionError:
-            time.sleep(1)
-        if not os.path.exists(gen_file_name):
-            break
-
-
-@pytest.mark.skip(reason="Unable to read generated python journal from fluent.")
-def test_single_scm():
-    file_name = os.path.join(pyfluent.EXAMPLES_PATH, "jou1.scm")
-
-    with open(file_name, "w") as journal:
-        journal.write('(display "from jou1.scm")')
-
-    solver = pyfluent.launch_fluent(mode="solver", topy=file_name)
-    solver.exit()
-
-    with open(file_name) as file:
-        returned = file.readlines()
-
-    if os.path.exists(file_name):
-        os.remove(file_name)
-
-    assert returned
-
-    gen_file_name = os.path.join(os.getcwd(), f"{Path(file_name).stem}.py")
-
-    with open(gen_file_name) as file:
-        gen_returned = file.readlines()
-
-    assert gen_returned
-
-    while os.path.exists(gen_file_name):
-        try:
-            os.remove(gen_file_name)
-        except PermissionError:
-            time.sleep(1)
-        if not os.path.exists(gen_file_name):
-            break
-
-
-@pytest.mark.skip(reason="Unable to read generated python journal from fluent.")
-def test_2_jou():
-    file_name_1 = os.path.join(pyfluent.EXAMPLES_PATH, "jou1.jou")
-    file_name_2 = os.path.join(pyfluent.EXAMPLES_PATH, "jou2.jou")
-
-    with open(file_name_1, "w") as journal:
-        journal.write('(display "from jou1.jou")')
-
-    with open(file_name_2, "w") as journal:
-        journal.write('(display "from jou2.jou")')
-
-    solver = pyfluent.launch_fluent(mode="solver", topy=[file_name_1, file_name_2])
-    solver.exit()
-
-    with open(file_name_1) as file:
-        returned1 = file.readlines()
-
-    if os.path.exists(file_name_1):
-        os.remove(file_name_1)
-
-    assert returned1
-
-    with open(file_name_2) as file:
-        returned2 = file.readlines()
-
-    if os.path.exists(file_name_2):
-        os.remove(file_name_2)
-
-    assert returned2
-
-    gen_file_name = (
-        Path(file_name_1).stem.split(".")[0]
-        + "_"
-        + Path(file_name_2).stem.split(".")[0]
-        + ".py"
-    )
-    gen_file_name = os.path.join(os.getcwd(), gen_file_name)
-
-    with open(gen_file_name) as file:
-        gen_returned = file.readlines()
-
-    assert gen_returned
-
-    while os.path.exists(gen_file_name):
-        try:
-            os.remove(gen_file_name)
-        except PermissionError:
-            time.sleep(1)
-        if not os.path.exists(gen_file_name):
-            break
-
-
-@pytest.mark.skip(reason="Unable to read generated python journal from fluent.")
-def test_2_scm():
-    file_name_1 = os.path.join(pyfluent.EXAMPLES_PATH, "jou1.scm")
-    file_name_2 = os.path.join(pyfluent.EXAMPLES_PATH, "jou2.scm")
-
-    with open(file_name_1, "w") as journal:
-        journal.write('(display "from jou1.scm")')
-
-    with open(file_name_2, "w") as journal:
-        journal.write('(display "from jou2.scm")')
-
-    solver = pyfluent.launch_fluent(mode="solver", topy=[file_name_1, file_name_2])
-    solver.exit()
-
-    with open(file_name_1) as file:
-        returned1 = file.readlines()
-
-    if os.path.exists(file_name_1):
-        os.remove(file_name_1)
-
-    assert returned1
-
-    with open(file_name_2) as file:
-        returned2 = file.readlines()
-
-    if os.path.exists(file_name_2):
-        os.remove(file_name_2)
-
-    assert returned2
-
-    gen_file_name = (
-        Path(file_name_1).stem.split(".")[0]
-        + "_"
-        + Path(file_name_2).stem.split(".")[0]
-        + ".py"
-    )
-    gen_file_name = os.path.join(os.getcwd(), gen_file_name)
-
-    with open(gen_file_name) as file:
-        gen_returned = file.readlines()
-
-    assert gen_returned
-
-    while os.path.exists(gen_file_name):
-        try:
-            os.remove(gen_file_name)
-        except PermissionError:
-            time.sleep(1)
-        if not os.path.exists(gen_file_name):
-            break

ansys/fluent/tests/test_tui_api.py

@@ -1,70 +0,0 @@
-import os
-
-import pytest
-
-from ansys.fluent.core import FluentVersion
-from ansys.fluent.core.examples.downloads import download_file
-from ansys.fluent.core.services.datamodel_tui import TUIMenu
-
-
-@pytest.mark.skip("Failing in github")
-def test_report_system_proc_stats_tui(new_solver_session, capsys) -> None:
-    new_solver_session.tui.report.system.sys_stats()
-    captured = capsys.readouterr()
-    assert "CPU" in captured.out
-
-
-def test_runtime_tui_menus(static_mixer_case_session) -> None:
-    solver = static_mixer_case_session
-    solver.tui.define.models.addon_module(3)
-    rmf = solver.tui.define.models.resolved_MEA_fuelcells
-    assert rmf is not None
-    assert rmf.__class__ == TUIMenu
-
-
-@pytest.mark.codegen_required
-def test_python_keyword_menu_name(new_meshing_session):
-    meshing = new_meshing_session
-    assert "cad_options" in dir(meshing.tui.file.import_)
-    assert "create_cad_assemblies" in dir(meshing.tui.file.import_.cad_options)
-    meshing.tui.file.import_.cad_options.create_cad_assemblies("yes")
-
-
-@pytest.mark.skip("Failing in github")
-def test_api_upgrade_message(new_solver_session):
-    solver = new_solver_session
-    case_name = download_file(
-        "Static_Mixer_main.cas.h5", "pyfluent/static_mixer", save_path=os.getcwd()
-    )
-    from contextlib import redirect_stdout
-    import io
-
-    f = io.StringIO()
-    with redirect_stdout(f):
-        solver.tui.file.read_case(case_name)
-    s = f.getvalue()
-    if solver.get_fluent_version() >= FluentVersion.v251:
-        assert (
-            s.split("\n")[-2].split("(")[0]
-            == r"<solver_session>.settings.file.read_case"
-        )
-    else:
-        assert s.split("\n")[-2].split("(")[0] == r"<solver_session>.file.read_case"
-
-
-def test_exit_not_in_meshing_tui(new_meshing_session):
-    meshing = new_meshing_session
-
-    assert "exit" not in dir(meshing.tui)
-
-    with pytest.raises(AttributeError):
-        meshing.tui.exit()
-
-
-def test_commands_not_in_solver_tui(new_solver_session):
-    solver = new_solver_session
-
-    for command in ["exit", "switch_to_meshing_mode"]:
-        assert command not in dir(solver.tui)
-        with pytest.raises(AttributeError):
-            getattr(solver.tui, command)

ansys/fluent/tests/test_type_stub.py

@@ -1,37 +0,0 @@
-import ast
-
-import pytest
-
-from ansys.fluent.core import CODEGEN_OUTDIR
-
-
-@pytest.mark.codegen_required
-@pytest.mark.fluent_version("==25.1")
-def test_settings_stub():
-    # The type-stub files, which are generated for settings API, are parsed by the
-    # intellisense engine while typing in editors like vscode. This test validates the
-    # information contained in a type-stub file.
-    version = "251"
-    stub_file = CODEGEN_OUTDIR / "solver" / f"settings_{version}.pyi"
-    assert stub_file.exists()
-    with open(stub_file) as f:
-        module_def = ast.parse(f.read())
-    assert isinstance(module_def, ast.Module)
-    assert any(isinstance(x, ast.ImportFrom) for x in module_def.body)
-    class_def = next(
-        x for x in module_def.body if isinstance(x, ast.ClassDef) and x.name == "export"
-    )
-    assert len(class_def.bases) > 0
-    assigns = [x for x in class_def.body if isinstance(x, ast.AnnAssign)]
-    for class_attr in [
-        "version",
-        "fluent_name",
-        "_python_name",
-        "child_names",
-        "command_names",
-    ]:
-        print(class_attr)
-        assert any(x.target.id == class_attr for x in assigns)
-    fn_def = next(x for x in class_def.body if isinstance(x, ast.FunctionDef))
-    assert ast.get_docstring(fn_def)
-    assert all(x.annotation for x in fn_def.args.args[1:])

ansys/fluent/tests/test_utils.py

@@ -1,82 +0,0 @@
-import time
-
-import pytest
-
-from ansys.fluent.core.utils.dictionary_operations import get_first_dict_key_for_value
-from ansys.fluent.core.utils.execution import (
-    InvalidArgument,
-    timeout_exec,
-    timeout_loop,
-)
-
-
-def test_timeout_exec():
-    ret = timeout_exec(time.sleep, timeout=0.25, args=(0.5,))
-    assert ret is False
-    ret = timeout_exec(time.sleep, timeout=0.5, args=(0.25,))
-    assert ret is True
-
-
-def test_timeout_loop():
-    class ExpectedAfterFive:
-        def __init__(self, expected):
-            self._counter = 0
-            self._expected = expected
-
-        def __call__(self):
-            self._counter += 1
-            if self._counter >= 5:
-                return self._expected
-            else:
-                return not self._expected
-
-    class Waiter:
-        def __init__(self, func, expected):
-            self._func = func(expected)
-            self._expected = expected
-
-        def __call__(self):
-            returned = self._func()
-            if returned == self._expected:
-                return returned
-            else:
-                return returned
-
-    waiter = Waiter(ExpectedAfterFive, expected=True)
-    ret = timeout_loop(waiter, timeout=1, expected="truthy", idle_period=0.1)
-    assert ret is True
-
-    waiter = Waiter(ExpectedAfterFive, expected=False)
-    ret = timeout_loop(waiter, timeout=1, expected="falsy", idle_period=0.1)
-    assert ret is False
-
-    waiter = Waiter(ExpectedAfterFive, expected=True)
-    ret = timeout_loop(waiter, timeout=0.2, expected="truthy", idle_period=0.1)
-    assert ret is False
-
-    with pytest.raises(InvalidArgument):
-        timeout_loop(waiter, timeout=0.2, expected=True, idle_period=0.1)
-
-
-def count_key_recursive(dictionary, key):
-    count = 0
-    for k, v in dictionary.items():
-        if k == key:
-            count += 1
-        elif isinstance(v, dict):
-            count += count_key_recursive(v, key)
-    return count
-
-
-def test_get_first_dict_key_for_value():
-    assert get_first_dict_key_for_value({1: 2}, 2) == 1
-    assert get_first_dict_key_for_value({1: 2, 3: 4}, 2) == 1
-    with pytest.raises(ValueError):
-        get_first_dict_key_for_value({1: 2}, 1)
-
-
-PYTEST_RELATIVE_TOLERANCE = 1e-3
-
-
-def pytest_approx(expected):
-    return pytest.approx(expected=expected, rel=PYTEST_RELATIVE_TOLERANCE)

ansys/fluent/tests/util/__init__.py

@@ -1,36 +0,0 @@
-from pathlib import Path
-from tempfile import TemporaryDirectory
-import uuid
-
-from pytest import MonkeyPatch
-
-import ansys.fluent.core as pyfluent
-from ansys.fluent.core.codegen import StaticInfoType, datamodelgen
-from ansys.fluent.core.utils import load_module
-
-
-def create_datamodel_root_in_server(session, rules_str, app_name) -> None:
-    rules_file_name = f"{uuid.uuid4()}.fdl"
-    session.scheme_eval.scheme_eval(
-        f'(with-output-to-file "{rules_file_name}" (lambda () (format "~a" "{rules_str}")))',
-    )
-    session.scheme_eval.scheme_eval(
-        f'(state/register-new-state-engine "{app_name}" "{rules_file_name}")'
-    )
-    session.scheme_eval.scheme_eval(f'(remove-file "{rules_file_name}")')
-    assert session.scheme_eval.scheme_eval(f'(state/find-root "{app_name}")') > 0
-
-
-def create_root_using_datamodelgen(service, app_name):
-    version = "252"
-    static_info = service.get_static_info(app_name)
-    with TemporaryDirectory() as temp_dir:
-        with MonkeyPatch.context() as m:
-            m.setattr(pyfluent, "CODEGEN_OUTDIR", Path(temp_dir))
-            # TODO: Refactor datamdodelgen so we don't need to hardcode StaticInfoType
-            datamodelgen.generate(
-                version, static_infos={StaticInfoType.DATAMODEL_WORKFLOW: static_info}
-            )
-            gen_file = Path(temp_dir) / f"datamodel_{version}" / "workflow.py"
-            module = load_module("datamodel", gen_file)
-            return module.Root(service, app_name, [])

ansys/fluent/tests/util/meshing_workflow.py

@@ -1,33 +0,0 @@
-def assign_task_arguments(
-    workflow, check_state: bool, task_name: str, **kwargs
-) -> None:
-    task = workflow.TaskObject[task_name]
-    task.Arguments = kwargs
-    if check_state:
-        # the state that we have set must be a subset of the total state
-        assert kwargs.items() <= task.Arguments().items()
-
-
-def check_task_execute_preconditions(task) -> None:
-    assert task.State() == "Out-of-date"
-    assert not task.Errors() or not len(task.Errors())
-
-
-def check_task_execute_postconditions(task) -> None:
-    assert task.State() == "Up-to-date"
-    assert not task.Errors() or not len(task.Errors())
-
-
-def execute_task_with_pre_and_postcondition_checks(workflow, task_name: str) -> None:
-    task = workflow.TaskObject[task_name]
-    check_task_execute_preconditions(task)
-    # Some tasks are wrongly returning False in meshing workflow itself
-    # so we add a temporary caveat below
-    result = task.Execute()
-    if task_name not in (
-        "Add Local Sizing",
-        "Add Boundary Layers",
-        "Import CAD and Part Management",
-    ):
-        assert result is True
-    check_task_execute_postconditions(task)