ansys-fluent-core 0.28.1__py3-none-any.whl → 0.29.0__py3-none-any.whl

ansys/fluent/tests/test_cad_to_post_wtm.py

@@ -1,250 +0,0 @@
-"""
-End-to-end Fluent Solver Workflow using Watertight Meshing
------------------------------------------------------------------------------
-This test covers the setup and solution of a 3D
-turbulent fluid flow and heat transfer problem in a mixing elbow. The mixing
-elbow configuration is encountered in piping systems in power plants and
-process industries. It is often important to predict the flow field and
-temperature field in the area of the mixing region to properly design
-the junction.
-
-This test queries the following using PyTest:
-
-- Meshing workflow tasks state before and after the task execution
-- Report definitions check after solution
-"""
-
-from functools import partial
-
-import pytest
-from util.meshing_workflow import (
-    assign_task_arguments,
-    execute_task_with_pre_and_postcondition_checks,
-)
-from util.solver import check_report_definition_result
-
-from ansys.fluent.core.utils.fluent_version import FluentVersion
-
-
-@pytest.mark.nightly
-@pytest.mark.codegen_required
-def test_mixing_elbow(watertight_workflow_session, mixing_elbow_geometry_filename):
-    meshing_session = watertight_workflow_session
-    workflow = meshing_session.workflow
-
-    assign_task_args = partial(
-        assign_task_arguments, workflow=workflow, check_state=True
-    )
-
-    execute_task_with_pre_and_postconditions = partial(
-        execute_task_with_pre_and_postcondition_checks, workflow=workflow
-    )
-
-    ###############################################################################
-    # Import the CAD geometry
-    # Query the task state before and after task execution
-    assign_task_args(
-        task_name="Import Geometry",
-        FileName=mixing_elbow_geometry_filename,
-        LengthUnit="in",
-    )
-
-    execute_task_with_pre_and_postconditions(task_name="Import Geometry")
-
-    ###############################################################################
-    # Add local sizing
-    # Query the task state before and after task execution
-    workflow.TaskObject["Add Local Sizing"].AddChildToTask()
-
-    execute_task_with_pre_and_postconditions(task_name="Add Local Sizing")
-
-    ###############################################################################
-    # Generate the surface mesh
-    # Query the task state before and after task execution
-    assign_task_args(
-        task_name="Generate the Surface Mesh",
-        CFDSurfaceMeshControls={"MaxSize": 0.3},
-    )
-
-    execute_task_with_pre_and_postconditions(task_name="Generate the Surface Mesh")
-
-    ###############################################################################
-    # Describe the geometry
-    # Query the task state before and after task execution
-    describe_geo = workflow.TaskObject["Describe Geometry"]
-    describe_geo.UpdateChildTasks(SetupTypeChanged=False)
-    assign_task_args(
-        task_name="Describe Geometry",
-        SetupType="The geometry consists of only fluid regions with no voids",
-    )
-    describe_geo.UpdateChildTasks(SetupTypeChanged=True)
-
-    execute_task_with_pre_and_postconditions(task_name="Describe Geometry")
-
-    ###############################################################################
-    # Update Boundaries Task
-    # Query the task state before and after task execution
-    assign_task_args(
-        task_name="Update Boundaries",
-        BoundaryLabelList=["wall-inlet"],
-        BoundaryLabelTypeList=["wall"],
-        OldBoundaryLabelList=["wall-inlet"],
-        OldBoundaryLabelTypeList=["velocity-inlet"],
-    )
-
-    execute_task_with_pre_and_postconditions(task_name="Update Boundaries")
-
-    ###############################################################################
-    # Update your regions
-    # Query the task state before and after task execution
-
-    execute_task_with_pre_and_postconditions(task_name="Update Regions")
-
-    ###############################################################################
-    # Add Boundary Layers
-    # Query the task state before and after task execution
-    add_boundary_layers = workflow.TaskObject["Add Boundary Layers"]
-    add_boundary_layers.AddChildToTask()
-    add_boundary_layers.InsertCompoundChildTask()
-    assign_task_args(
-        task_name="smooth-transition_1", BLControlName="smooth-transition_1"
-    )
-    add_boundary_layers.Arguments = {}
-
-    execute_task_with_pre_and_postconditions(task_name="Add Boundary Layers")
-
-    ###############################################################################
-    # Generate the volume mesh
-    # Query the task state before and after task execution
-    assign_task_args(
-        task_name="Generate the Volume Mesh",
-        VolumeFill="poly-hexcore",
-        VolumeFillControls={"HexMaxCellLength": 0.3},
-    )
-
-    execute_task_with_pre_and_postconditions(task_name="Generate the Volume Mesh")
-
-    ###############################################################################
-    # Check the mesh in Meshing mode
-    # TODO: Remove the if condition after a stable version of 23.1 is available and update the commands as required.
-    if meshing_session.get_fluent_version() < FluentVersion.v231:
-        meshing_session.tui.mesh.check_mesh()
-
-    ###############################################################################
-    # Switch to Solution mode
-    solver_session = meshing_session.switch_to_solver()
-
-    ###############################################################################
-    # Check the mesh in Solver mode
-    solver_session.tui.mesh.check()
-
-    ###############################################################################
-    # Set the working units for the mesh
-    define = solver_session.tui.define
-    define.units("length", "in")
-
-    ###############################################################################
-    # Enable heat transfer by activating the energy equation.
-    define.models.energy("yes", ", ", ", ", ", ", ", ")
-
-    ###############################################################################
-    # Create a new material called water-liquid.
-    define.materials.copy("fluid", "water-liquid")
-
-    ###############################################################################
-    # Set up the cell zone conditions for the fluid zone (elbow-fluid). Select
-    # water-liquid from the Material list.
-    # 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:
-        define.boundary_conditions.fluid(
-            "elbow-fluid",
-            "yes",
-            "water-liquid",
-            "no",
-            "no",
-            "no",
-            "no",
-            "0",
-            "no",
-            "0",
-            "no",
-            "0",
-            "no",
-            "0",
-            "no",
-            "0",
-            "no",
-            "1",
-            "no",
-            "no",
-            "no",
-            "no",
-            "no",
-        )
-
-        ###############################################################################
-        # Set up the boundary conditions
-        velocity_inlet = define.boundary_conditions.set.velocity_inlet
-        velocity_inlet("cold-inlet", [], "vmag", "no", 0.4, "quit")
-        velocity_inlet("cold-inlet", [], "ke-spec", "no", "no", "no", "yes", "quit")
-        velocity_inlet("cold-inlet", [], "turb-intensity", 5, "quit")
-        velocity_inlet("cold-inlet", [], "turb-hydraulic-diam", 4, "quit")
-        velocity_inlet("cold-inlet", [], "temperature", "no", 293.15, "quit")
-        velocity_inlet("hot-inlet", [], "vmag", "no", 1.2, "quit")
-        velocity_inlet("hot-inlet", [], "ke-spec", "no", "no", "no", "yes", "quit")
-        velocity_inlet("hot-inlet", [], "turb-intensity", 5, "quit")
-        velocity_inlet("hot-inlet", [], "turb-hydraulic-diam", 1, "quit")
-        velocity_inlet("hot-inlet", [], "temperature", "no", 313.15, "quit")
-
-        pressure_outlet = define.boundary_conditions.set.pressure_outlet
-        pressure_outlet("outlet", [], "turb-intensity", 5, "quit")
-        pressure_outlet("outlet", [], "turb-viscosity-ratio", 4, "quit")
-
-        ###############################################################################
-        # Enable the plotting of residuals during the calculation.
-        solver_session.tui.solve.monitors.residual.plot("yes")
-
-        ###############################################################################
-        # Initialize the flow field using the Hybrid Initialization
-        solver_session.tui.solve.initialize.hyb_initialization()
-
-        ###############################################################################
-        # Solve for 250 Iterations.
-        solver_session.tui.solve.iterate(250)
-
-        ###############################################################################
-        # Assert the returned mass flow rate report definition value
-        flux = solver_session.solution.report_definitions.flux
-        flux["mass_flow_rate"] = {}
-        flux["mass_flow_rate"].zone_names = [
-            "cold-inlet",
-            "hot-inlet",
-            "outlet",
-        ]
-
-        check_report_definition = partial(
-            check_report_definition_result,
-            report_definitions=solver_session.solution.report_definitions,
-        )
-
-        check_report_definition(
-            report_definition_name="mass_flow_rate",
-            expected_result=pytest.approx(-2.985690364942784e-06, abs=1e-3),
-        )
-
-        ###############################################################################
-        # Assert the returned temperature report definition value on the outlet surface
-        solver_session.solution.report_definitions.surface["temperature_outlet"] = {}
-        temp_outlet = solver_session.solution.report_definitions.surface[
-            "temperature_outlet"
-        ]
-        temp_outlet.report_type = "surface-massavg"
-        temp_outlet.field = "temperature"
-        temp_outlet.surface_names = ["outlet"]
-
-        check_report_definition(
-            report_definition_name="temperature_outlet",
-            expected_result=pytest.approx(296.229, rel=1e-3),
-        )
-
-        ###############################################################################

ansys/fluent/tests/test_casereader.py

@@ -1,324 +0,0 @@
-from os.path import dirname, join
-import pathlib
-import shutil
-
-import pytest
-
-from ansys.fluent.core import examples
-from ansys.fluent.core.filereader import lispy
-from ansys.fluent.core.filereader.case_file import (
-    InputParameter,
-    InputParameterOld,
-    MeshType,
-    _get_processed_string,
-)
-from ansys.fluent.core.filereader.case_file import CaseFile as CaseReader
-
-
-def call_casereader(
-    case_file_name: str | None = None,
-    project_file_name: str | None = None,
-    expected: dict | None = None,
-):
-    reader = CaseReader(
-        case_file_name=case_file_name, project_file_name=project_file_name
-    )
-    if expected is not None:
-        assert reader.precision() == expected["precision"]
-        assert reader.num_dimensions() == expected["num_dimensions"]
-        assert reader.iter_count() == expected["iter_count"]
-        assert {
-            p.name: (p.numeric_value, p.units) for p in reader.input_parameters()
-        } == expected["input_parameters"]
-        assert {p.name: p.units for p in reader.output_parameters()} == expected[
-            "output_parameters"
-        ]
-
-
-def call_casereader_static_mixer(
-    case_file_name: str | None = None, project_file_name: str | None = None
-):
-    call_casereader(
-        case_file_name=case_file_name,
-        project_file_name=project_file_name,
-        expected=dict(
-            precision=2,
-            num_dimensions=3,
-            iter_count=100,
-            input_parameters=dict(
-                inlet1_temp=(300, "K"),
-                inlet1_vel=(1, "m/s"),
-                inlet2_temp=(350, "K"),
-                inlet2_vel=(1, "m/s"),
-            ),
-            output_parameters={
-                "outlet-temp-avg-op": "K",
-                "outlet-vel-avg-op": "m s^-1",
-            },
-        ),
-    )
-
-
-def static_mixer_file():
-    return examples.download_file(
-        "Static_Mixer_Parameters.cas.h5",
-        "pyfluent/static_mixer",
-        return_without_path=False,
-    )
-
-
-def test_casereader_static_mixer_h5():
-    call_casereader_static_mixer(case_file_name=static_mixer_file())
-
-
-def test_casereader_static_mixer_binary_cas():
-    call_casereader_static_mixer(
-        case_file_name=examples.download_file(
-            "Static_Mixer_Parameters_legacy_binary.cas",
-            "pyfluent/static_mixer",
-            return_without_path=False,
-        )
-    )
-
-
-def test_casereader_static_mixer_binary_gz():
-    call_casereader_static_mixer(
-        case_file_name=examples.download_file(
-            "Static_Mixer_Parameters_legacy_binary.cas.gz",
-            "pyfluent/static_mixer",
-            return_without_path=False,
-        )
-    )
-
-
-def test_casereader_static_mixer_text_cas():
-    call_casereader_static_mixer(
-        case_file_name=examples.download_file(
-            "Static_Mixer_Parameters_legacy_text.cas",
-            "pyfluent/static_mixer",
-            return_without_path=False,
-        )
-    )
-
-
-def test_casereader_static_mixer_text_gz():
-    call_casereader_static_mixer(
-        case_file_name=examples.download_file(
-            "Static_Mixer_Parameters_legacy_text.cas.gz",
-            "pyfluent/static_mixer",
-            return_without_path=False,
-        )
-    )
-
-
-def create_dir_structure_locally(copy_1: bool = False, copy_2: bool = False):
-    # Copying from and then creating the entire directory structure locally
-    case_file_dir = (
-        "Static_Mixer_Parameter_project_file/"
-        "Static_Mixer_Parameters.cffdb/Static_Mixer_Parameters-Solve"
-    )
-    case_file_name = examples.download_file(
-        "Static_Mixer_Parameters.cas.h5",
-        "pyfluent/static_mixer/" + case_file_dir,
-        return_without_path=False,
-    )
-    prj_dir = join(dirname(case_file_name), case_file_dir)
-    pathlib.Path(prj_dir).mkdir(parents=True, exist_ok=True)
-    if copy_1:
-        shutil.copy2(case_file_name, prj_dir)
-    if copy_2:
-        case_file_name_2 = examples.download_file(
-            "Static_Mixer_Parameters_legacy_binary.cas.gz",
-            "pyfluent/static_mixer",
-            return_without_path=False,
-        )
-        shutil.copy2(case_file_name_2, prj_dir)
-    prj_file_dir = "Static_Mixer_Parameter_project_file"
-    prj_file = r"Static_Mixer_Parameters.flprj"
-    prj_file_name = examples.download_file(
-        prj_file, "pyfluent/static_mixer/" + prj_file_dir, return_without_path=False
-    )
-    prj_file_dir = join(dirname(prj_file_name), prj_file_dir)
-    shutil.copy2(prj_file_name, prj_file_dir)
-
-    return join(prj_file_dir, prj_file)
-
-
-def test_processed_string():
-    assert (
-        _get_processed_string(b"Hello! World (37 ( Get this part of the string ))")
-        == "(37 ( Get this part of the string ))"
-    )
-
-
-def test_casereader_no_file():
-    with pytest.raises(FileNotFoundError):
-        call_casereader("no_file.cas.h5")
-
-
-def test_casereader_with_both_project_and_case_file():
-    with pytest.raises(RuntimeError):
-        call_casereader(
-            case_file_name="case_file.cas.h5", project_file_name="project.flprj"
-        )
-
-
-def test_casereader_for_project_directory_invalid_project_file():
-    with pytest.raises(FileNotFoundError):
-        call_casereader(project_file_name="project.flprx")
-
-
-def test_case_reader_with_bad_data_to_be_skipped_and_input_parameters_labeled_differently():
-    call_casereader(
-        case_file_name=examples.download_file(
-            "mixer-ran_2019r3.cas.gz", "pyfluent/optislang", return_without_path=False
-        ),
-        expected=dict(
-            precision=1,
-            num_dimensions=3,
-            iter_count=25,
-            input_parameters=dict(
-                swirl_max_hot=(0.1, "m s^-1"),
-                vel_hot=(0.1, "m s^-1"),
-                vel_cold=(0.1, "m s^-1"),
-                swirl_max_cold=(0.1, "m s^-1"),
-            ),
-            output_parameters={
-                "p2-op": "kg m^-1 s^-2",
-                "t-dev-op": "K",
-                "p1-op": "kg m^-1 s^-2",
-                "ave_temp_out": "K",
-            },
-        ),
-    )
-
-
-def test_case_reader_get_rp_and_config_vars():
-    reader = CaseReader(case_file_name=static_mixer_file())
-    rp_vars = reader.rp_vars()
-    assert rp_vars
-    assert hasattr(rp_vars, "__getitem__")
-    config_vars = reader.config_vars()
-    assert config_vars
-    assert hasattr(config_vars, "__getitem__")
-    assert config_vars["rp-3d?"] is True
-    assert reader.config_var("rp-3d?") is True
-    assert reader.config_var.rp_3d__q() is True
-    assert reader.rp_var.smooth_mesh.niter() == 4
-    assert reader.rp_var.pressure.output_dpdt__q() is True
-    assert len(reader.rp_var.context.map_r17__plus()) == 53
-    assert reader.rp_var.defaults.pre_r19__dot0_early__q() is False
-
-    with pytest.raises(RuntimeError) as msg:
-        reader.rp_var.defaults.pre_r19__dot0_early()
-
-    with pytest.raises(ValueError) as msg:
-        reader.config_var("rp-3d")
-    assert (
-        msg.value.args[0] == "'config-vars' has no attribute 'rp-3d'.\n"
-        "The most similar names are: rp-3d?, rp-des?."
-    )
-
-
-def test_case_reader_input_parameter():
-    number = InputParameter(raw_data=(("name", "n"), ("definition", "12.4")))
-
-    assert number.name == "n"
-    assert number.units == ""
-    assert number.numeric_value == 12.4
-    assert number.value == "12.4"
-
-    length = InputParameter(raw_data=(("name", "x"), ("definition", "12.4 [m]")))
-
-    assert length.name == "x"
-    assert length.units == "m"
-    assert length.numeric_value == 12.4
-    assert length.value == "12.4 [m]"
-
-    momentum = InputParameter(
-        raw_data=(("name", "p"), ("definition", "12.4 [kg m s^-1]"))
-    )
-
-    assert momentum.name == "p"
-    assert momentum.units == "kg m s^-1"
-    assert momentum.numeric_value == 12.4
-    assert momentum.value == "12.4 [kg m s^-1]"
-
-    velocity = InputParameter(raw_data=(("name", "v"), ("definition", "2[m/s]")))
-
-    assert velocity.name == "v"
-    assert velocity.units == "m/s"
-    assert velocity.numeric_value == 2
-    assert velocity.value == "2 [m/s]"
-
-    vel_data = [
-        "real-1",
-        [
-            ("type", "real"),
-            ["name", ("value", '"inlet_velocity"'), ("type", "string-class")],
-            [
-                "parameter-value",
-                ("type", "real-class"),
-                ("value", 20.0),
-                ("min", False),
-                ("max", False),
-                ("units-quantity", "velocity"),
-            ],
-        ],
-    ]
-    velocity = InputParameterOld(raw_data=vel_data)
-
-    assert velocity.name == "inlet_velocity"
-    assert velocity.value == [
-        "parameter-value",
-        ("type", "real-class"),
-        ("value", 20.0),
-        ("min", False),
-        ("max", False),
-        ("units-quantity", "velocity"),
-    ]
-    assert velocity.units == "velocity"
-    assert velocity.numeric_value == 20.0
-
-
-def test_lispy_for_multiline_string():
-    assert lispy.parse('(define x "abc\ndef")') == ["define", "x", '"abc\ndef"']
-
-
-def test_lispy_for_quotes():
-    assert lispy.parse(
-        '(define x "\n(format \\"\n-------------------------\nRunning Original Settings\n------------------------\n\\")")'
-    ) == [
-        "define",
-        "x",
-        '"\n(format \\"\n-------------------------\nRunning Original Settings\n------------------------\n\\")"',
-    ]
-
-
-def test_mesh_reader():
-    mesh_file_2d = examples.download_file(
-        "sample_2d_mesh.msh.h5",
-        "pyfluent/surface_mesh",
-        return_without_path=False,
-    )
-    mesh_file_3d = examples.download_file(
-        "mixing_elbow.msh.h5",
-        "pyfluent/mixing_elbow",
-        return_without_path=False,
-    )
-    case_file = examples.download_file(
-        "mixing_elbow.cas.h5",
-        "pyfluent/mixing_elbow",
-        return_without_path=False,
-    )
-    mesh_reader_2d = CaseReader(case_file_name=mesh_file_2d)
-    mesh_reader_3d = CaseReader(case_file_name=mesh_file_3d)
-    case_reader = CaseReader(case_file_name=case_file)
-
-    assert mesh_reader_2d.get_mesh().get_mesh_type() == MeshType.SURFACE
-    assert mesh_reader_3d.get_mesh().get_mesh_type() == MeshType.VOLUME
-    assert case_reader.get_mesh().get_mesh_type() == MeshType.VOLUME
-
-    assert mesh_reader_2d.precision() is None
-    assert mesh_reader_3d.precision() is None
-    assert case_reader.precision() == 2