From add28ec6da5ae72a1bde7786bf90d8527c1736e5 Mon Sep 17 00:00:00 2001 From: Anurag Kulshrestha <103188356+akulshre-qa@users.noreply.github.com> Date: Fri, 9 Sep 2022 00:18:04 +0530 Subject: [PATCH] New pro tests added (#849) * New pro tests added * Added marker * added import of missed module --- tests/conftest.py | 1 + tests/test_pro/inlet_exp.tsv | 3 + tests/test_pro/test_pro_cht.py | 277 +++++++++++++ tests/test_pro/test_pro_dpm.py | 61 +++ tests/test_pro/test_pro_exp.py | 72 ++++ tests/test_pro/test_pro_fan.py | 144 +++++++ tests/test_pro/test_pro_ht.py | 184 +++++++++ tests/test_pro/test_pro_parameters.py | 102 +++++ tests/test_pro/test_pro_porous.py | 68 ++++ tests/test_pro/test_pro_post.py | 390 ++++++++++++++++++ tests/test_pro/test_pro_settings_pbcs.py | 211 ++++++++++ tests/test_pro/test_pro_species.py | 147 +++++++ tests/test_pro/test_pro_turbulence.py | 171 ++++++++ tests/test_pro/test_pro_wtm.py | 485 +++++++++++++++++++++++ 14 files changed, 2316 insertions(+) create mode 100644 tests/test_pro/inlet_exp.tsv create mode 100644 tests/test_pro/test_pro_cht.py create mode 100644 tests/test_pro/test_pro_dpm.py create mode 100644 tests/test_pro/test_pro_exp.py create mode 100644 tests/test_pro/test_pro_fan.py create mode 100644 tests/test_pro/test_pro_ht.py create mode 100644 tests/test_pro/test_pro_parameters.py create mode 100644 tests/test_pro/test_pro_porous.py create mode 100644 tests/test_pro/test_pro_post.py create mode 100644 tests/test_pro/test_pro_settings_pbcs.py create mode 100644 tests/test_pro/test_pro_species.py create mode 100644 tests/test_pro/test_pro_turbulence.py create mode 100644 tests/test_pro/test_pro_wtm.py diff --git a/tests/conftest.py b/tests/conftest.py index 00ebe7a052f..333574c28b4 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -2,6 +2,7 @@ pytest_plugins = [ "util.fixture_fluent", + "util.meshing_workflow", ] diff --git a/tests/test_pro/inlet_exp.tsv b/tests/test_pro/inlet_exp.tsv new file mode 100644 index 00000000000..42ee15eb119 --- /dev/null +++ b/tests/test_pro/inlet_exp.tsv @@ -0,0 +1,3 @@ + +name definition description input-parameter output-parameter +"avg_vel_inlet2" "Average(VelocityMagnitude,['inlet2'])" "" #f #f \ No newline at end of file diff --git a/tests/test_pro/test_pro_cht.py b/tests/test_pro/test_pro_cht.py new file mode 100644 index 00000000000..4f0dff6c588 --- /dev/null +++ b/tests/test_pro/test_pro_cht.py @@ -0,0 +1,277 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_cht(launch_fluent_solver_3ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file( + "pyfluent/exhaust_manifold", "manifold.msh" + ) + solver.file.read(file_type=input_type, file_name=input_name) + assert solver._root.get_attr("active?") + assert solver.check_health() == "SERVING" + solver.mesh.check() + solver.execute_tui(r"""/define/units length mm """) + solver.setup.models.energy = {"enabled": True} + assert solver.setup.models.energy.enabled() + solver.execute_tui(r"""/define/models/viscous/kw-sst? yes """) + assert solver.setup.models.viscous.model() == "k-omega" + solver.execute_tui( + r"""/define/materials/change-create aluminum cast-iron yes constant 7150 yes constant 460 yes constant 50 yes """ + ) + assert "cast-iron" in solver.setup.cell_zone_conditions.solid["solid_up"].material() + solver.setup.boundary_conditions.velocity_inlet["inlet"] = { + "vmag": 10.0, + "t": 925.0, + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_intensity": 0.1, + "turb_hydraulic_diam": 0.04, + } + assert solver.setup.boundary_conditions.velocity_inlet["inlet"].vmag() == { + "option": "value", + "value": 10.0, + } + assert solver.setup.boundary_conditions.velocity_inlet["inlet"].t() == { + "option": "value", + "value": 925.0, + } + assert ( + solver.setup.boundary_conditions.velocity_inlet["inlet"].turb_intensity() == 0.1 + ) + solver.execute_tui( + r"""/define/boundary-conditions/copy-bc inlet inlet1 inlet2 () """ + ) + assert ( + solver.setup.boundary_conditions.velocity_inlet["inlet"].vmag() + == solver.setup.boundary_conditions.velocity_inlet["inlet1"].vmag() + ) + assert ( + solver.setup.boundary_conditions.velocity_inlet["inlet"].t() + == solver.setup.boundary_conditions.velocity_inlet["inlet1"].t() + ) + assert ( + solver.setup.boundary_conditions.velocity_inlet["inlet"].turb_hydraulic_diam() + == solver.setup.boundary_conditions.velocity_inlet[ + "inlet1" + ].turb_hydraulic_diam() + ) + assert ( + solver.setup.boundary_conditions.velocity_inlet["inlet"].turb_intensity() + == solver.setup.boundary_conditions.velocity_inlet["inlet1"].turb_intensity() + ) + solver.setup.boundary_conditions.pressure_outlet["outlet"] = { + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_intensity": 0.1, + "turb_hydraulic_diam": 0.04, + } + assert ( + solver.setup.boundary_conditions.pressure_outlet["outlet"].ke_spec() + == "Intensity and Hydraulic Diameter" + ) + assert ( + solver.setup.boundary_conditions.pressure_outlet["outlet"].turb_intensity() + == 0.1 + ) + solver.setup.boundary_conditions.wall["solid_up:1"] = { + "thermal_bc": "Convection", + "h": 10.0, + } + assert ( + solver.setup.boundary_conditions.wall["solid_up:1"].thermal_bc() == "Convection" + ) + assert solver.setup.boundary_conditions.wall["solid_up:1"].h() == { + "option": "value", + "value": 10.0, + } + solver.execute_tui( + r"""/define/boundary-conditions/copy-bc solid_up:1 in1 in2 in3 out1 () """ + ) + solver.solution.methods.p_v_coupling.flow_scheme = "Coupled" + assert solver.solution.methods.p_v_coupling.flow_scheme() == "Coupled" + solver.solution.report_definitions.surface["point-vel"] = {} + solver.solution.report_definitions.surface[ + "point-vel" + ].report_type = "surface-facetmax" + solver.solution.report_definitions.surface["point-vel"] = { + "surface_names": ["outlet"], + "field": "velocity-magnitude", + } + assert solver.solution.report_definitions.surface["point-vel"]() == { + "field": "velocity-magnitude", + "report_type": "surface-facetmax", + "average_over": 1, + "per_surface": False, + "surface_names": ["outlet"], + } + solver.solution.monitor.report_files["point-vel-rfile"] = {} + solver.solution.monitor.report_files["point-vel-rfile"] = { + "print": True, + "report_defs": ["point-vel"], + "file_name": r"out\\point-vel-rfile.out", + } + solver.solution.monitor.report_plots["point-vel-rplot"] = {} + solver.solution.monitor.report_plots["point-vel-rplot"] = { + "print": True, + "report_defs": ["point-vel"], + } + assert solver.solution.monitor.report_plots["point-vel-rplot"].report_defs() == [ + "point-vel" + ] + assert ( + solver.solution.monitor.report_files["point-vel-rfile"].file_name() + == "out\\\\point-vel-rfile.out" + ) + solver.solution.report_definitions.flux["mass-in"] = {} + solver.solution.report_definitions.flux["mass-in"].report_type = "flux-massflow" + solver.solution.report_definitions.flux["mass-in"] = { + "zone_names": ["in1", "in2", "in3", "inlet2", "inlet1", "inlet"] + } + assert solver.solution.report_definitions.flux["mass-in"].zone_names() == [ + "in1", + "in2", + "in3", + "inlet2", + "inlet1", + "inlet", + ] + solver.solution.monitor.report_files["mass-in-rfile"] = {} + solver.solution.monitor.report_files["mass-in-rfile"] = { + "print": True, + "report_defs": ["mass-in"], + "file_name": r"out\\mass-in-rfile.out", + } + solver.solution.monitor.report_plots["mass-in-rplot"] = {} + solver.solution.monitor.report_plots["mass-in-rplot"] = { + "print": True, + "report_defs": ["mass-in"], + } + solver.solution.report_definitions.flux["mass-tot"] = {} + solver.solution.report_definitions.flux["mass-tot"].report_type = "flux-massflow" + solver.solution.report_definitions.flux["mass-tot"] = { + "zone_names": [ + "outlet", + "inlet2", + "inlet1", + "inlet", + "solid_up:1", + "out1", + "in3", + "in2", + "in1", + "solid_up:002", + "solid_up:002-shadow", + "interior--fluid1", + "interior--solid_up", + ] + } + solver.solution.monitor.report_files["mass-tot-rfile"] = {} + solver.solution.monitor.report_files["mass-tot-rfile"] = { + "print": True, + "report_defs": ["mass-tot"], + "file_name": r"out\\mass-tot-rfile.out", + } + solver.solution.monitor.report_plots["mass-tot-rplot"] = {} + solver.solution.monitor.report_plots["mass-tot-rplot"] = { + "print": True, + "report_defs": ["mass-tot"], + } + assert solver.solution.monitor.report_plots["mass-tot-rplot"].report_defs() == [ + "mass-tot" + ] + solver.solution.initialization.standard_initialize() + solver.execute_tui(r"""/solve/set/pseudo-transient yes yes 1 5 0 yes 1. """) + solver.solution.run_calculation.iterate(number_of_iterations=100) + solver.results.report.report_menu.fluxes.mass_flow( + all_bndry_zones=False, + zone_list=["outlet", "inlet2", "inlet1", "inlet"], + write_to_file=True, + file_name="out/mass_flow.flp", + ) + solver.results.graphics.pathline["pathlines-1"] = {} + solver.results.graphics.pathline["pathlines-1"] = { + "field": "time", + "skip": 5, + "surfaces_list": ["inlet", "inlet1", "inlet2"], + } + solver.results.graphics.pathline.display(object_name="pathlines-1") + solver.execute_tui( + r"""/surface/iso-clip x-coordinate clip-x-coordinate solid_up:1 -362.7150356769562 -174.6281 """ + ) + solver.execute_tui( + r"""/surface/iso-clip z-coordinate clip-z-coordinate solid_up:1 -101.8218025565147 -44. """ + ) + assert solver.results.graphics.pathline["pathlines-1"].surfaces_list() == [ + "inlet", + "inlet1", + "inlet2", + ] + solver.results.graphics.mesh["mesh-1"] = {} + solver.results.graphics.mesh["mesh-1"] = {"surfaces_list": ["clip-x-coordinate"]} + assert solver.results.graphics.mesh["mesh-1"].surfaces_list() == [ + "clip-x-coordinate" + ] + solver.results.scene["scene-1"] = {} + solver.results.scene["scene-1"].graphics_objects["mesh-1"] = {} + solver.results.scene["scene-1"].graphics_objects["pathlines-1"] = {} + solver.results.scene["scene-1"] = { + "graphics_objects": {"mesh-1": {"transparency": 50}, "pathlines-1": {}} + } + solver.results.scene.display(object_name="scene-1") + solver.results.graphics.contour["contour-velocity"] = {} + solver.results.graphics.contour["contour-velocity"] = { + "field": "velocity-magnitude", + "surfaces_list": ["outlet"], + "node_values": False, + } + assert ( + solver.results.graphics.contour["contour-velocity"].field() + == "velocity-magnitude" + ) + solver.execute_tui(r"""/display/zone-mesh out1 () """) + solver.results.graphics.contour.add_to_graphics(object_name="contour-velocity") + solver.execute_tui( + r"""/surface/iso-surface axial-coordinate mid-plane-z () fluid1 solid_up* () -44. () """ + ) + solver.results.graphics.contour["contour-temperature"] = {} + solver.results.graphics.contour["contour-temperature"] = { + "field": "temperature", + "surfaces_list": ["inlet", "inlet1", "inlet2", "mid-plane-z", "outlet", "out1"], + } + assert solver.results.graphics.contour["contour-temperature"].surfaces_list() == [ + "inlet", + "inlet1", + "inlet2", + "mid-plane-z", + "outlet", + "out1", + ] + solver.execute_tui(r"""/display/surface-mesh clip-z-coordinate () """) + solver.results.graphics.contour.add_to_graphics(object_name="contour-temperature") + solver.results.graphics.contour["contour-temperature-manifold"] = {} + solver.results.graphics.contour["contour-temperature-manifold"] = { + "field": "temperature", + "surfaces_list": [ + "in1", + "in2", + "in3", + "out1", + "solid_up:002-shadow", + "solid_up:002", + "solid_up:1", + ], + } + assert ( + solver.results.graphics.contour["contour-temperature-manifold"].field() + == "temperature" + ) + solver.results.graphics.contour.display(object_name="contour-temperature-manifold") + solver.file.write(file_type="case-data", file_name="out/manifold_solution.cas.h5") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_dpm.py b/tests/test_pro/test_pro_dpm.py new file mode 100644 index 00000000000..bb357774166 --- /dev/null +++ b/tests/test_pro/test_pro_dpm.py @@ -0,0 +1,61 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_dpm(launch_fluent_solver_3ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file( + "pyfluent/simple_duct", "simple-duct.msh.h5" + ) + solver.file.read(file_type=input_type, file_name=input_name) + assert solver._root.get_attr("active?") + assert solver.check_health() == "SERVING" + solver.setup.boundary_conditions.velocity_inlet["inlet"].vmag = 1.0 + assert solver.setup.boundary_conditions.velocity_inlet["inlet"].vmag() == { + "option": "value", + "value": 1.0, + } + solver.execute_tui( + r"""/define/models/dpm/injections/create-injection single no no no no no no no -4.5 0. 0. 1 0. 0. 0.0001 1e-10 """ + ) + solver.execute_tui( + r"""/define/models/dpm/injections/create-injection group no yes group no 2 no no no no no -4.5 -4.5 0. 0. -0.2 0.2 1 1 0. 0. 0. 0. 0.0001 0.0001 1e-10 1e-10 """ + ) + solver.execute_tui( + r"""/define/models/dpm/injections/create-injection surface no yes surface no inlet () no yes no no no no no 0.0001 1 1e-10 """ + ) + solver.execute_tui( + r"""/define/models/dpm/injections/create-injection cone no yes cone no 4 no no no no no -4.5 0. 0. 0.0001 0. 360 1 0 0 1 45 0. 0 4e-10 """ + ) + solver.execute_tui(r"""/solve/initialize/compute-defaults/velocity-inlet inlet """) + solver.solution.initialization.standard_initialize() + solver.execute_tui( + r"""/display/particle-tracks/plot-write-xy-plot x-coordinate single () time -5 5 yes "out/single.xy" """ + ) + solver.execute_tui( + r"""/display/particle-tracks/plot-write-xy-plot x-coordinate group () time -5 5 yes "out/group_x.xy" """ + ) + solver.execute_tui( + r"""/display/particle-tracks/plot-write-xy-plot z-coordinate group () time -5 5 yes "out/group_z.xy" """ + ) + solver.execute_tui( + r"""/display/particle-tracks/plot-write-xy-plot x-coordinate surface () time -5 5 yes "out/surface.xy" """ + ) + solver.execute_tui( + r"""/display/particle-tracks/plot-write-xy-plot x-coordinate cone () time -5 5 yes "out/cone_x.xy" """ + ) + solver.execute_tui( + r"""/display/particle-tracks/plot-write-xy-plot y-coordinate cone () time -5 5 yes "out/cone_y.xy" """ + ) + solver.execute_tui( + r"""/display/particle-tracks/plot-write-xy-plot z-coordinate cone () time -5 5 yes "out/cone_z.xy" """ + ) + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_exp.py b/tests/test_pro/test_pro_exp.py new file mode 100644 index 00000000000..f5bfe0b0543 --- /dev/null +++ b/tests/test_pro/test_pro_exp.py @@ -0,0 +1,72 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_exp(launch_fluent_solver_3ddp_t2): + solver = launch_fluent_solver_3ddp_t2 + _THIS_DIR = os.path.dirname(__file__) + _EXP_FILE = os.path.join(_THIS_DIR, "inlet_exp.tsv") + input_type, input_name = download_input_file( + "pyfluent/exhaust_manifold", "manifold_expressions.cas.gz" + ) + solver.execute_tui(r"""/file/start-transcript "prolic_exp_s1.trn" """) + solver.file.read(file_type=input_type, file_name=input_name) + assert solver._root.get_attr("active?") + assert solver.check_health() == "SERVING" + solver.execute_tui(r"""/print-license-usage """) + solver.execute_tui( + r'''/define/named-expressions/import-from-tsv "%s"''' % _EXP_FILE + ) + solver.setup.named_expressions["temp_inlet_1"] = {} + solver.setup.named_expressions["temp_inlet_1"] = {"definition": "-1 [C]"} + assert solver.setup.named_expressions["temp_inlet_1"].definition() == "-1 [C]" + solver.setup.boundary_conditions.velocity_inlet["inlet2"] = { + "vmag": "IF(Maximum(TotalTemperature,['interior-part-heatsource'])> 310 [K], 1 [m/s], 0.01[m/s])", + "t": 300.0, + "turb_intensity": 0.04999999888241, + } + solver.setup.boundary_conditions.velocity_inlet["inlet1"] = { + "vmag": "IF(avg_vel_inlet2>=0.5 [m/s], 1 [m/s], 0.2 [m/s])", + "t": "temp_inlet_1", + "turb_intensity": 0.04999999888241, + } + assert solver.setup.boundary_conditions.velocity_inlet["inlet2"].vmag() == { + "option": "value", + "value": "IF(Maximum(TotalTemperature,['interior-part-heatsource'])> 310 [K], 1 [m/s], 0.01[m/s])", + } + assert solver.setup.boundary_conditions.velocity_inlet["inlet1"].vmag() == { + "option": "value", + "value": "IF(avg_vel_inlet2>=0.5 [m/s], 1 [m/s], 0.2 [m/s])", + } + solver.setup.boundary_conditions.velocity_inlet["inlet3"] = { + "vmag": "IF(AND((Maximum(TotalTemperature,['interior-part-heatsource'])> 310 [K]),(Average(VelocityMagnitude,['inlet1'])== 1 [m/s])), 1 [m/s], 0.2 [m/s])", + "turb_intensity": 0.04999999888241, + } + assert solver.setup.boundary_conditions.velocity_inlet["inlet3"].vmag() == { + "option": "value", + "value": "IF(AND((Maximum(TotalTemperature,['interior-part-heatsource'])> 310 [K]),(Average(VelocityMagnitude,['inlet1'])== 1 [m/s])), 1 [m/s], 0.2 [m/s])", + } + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=150) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["inlet1"], + cell_report="temperature", + write_to_file=True, + file_name="temp_inlet_2.srp", + ) + solver.file.write(file_type="case-data", file_name="exp_manifold_reduction") + solver.mesh.check() + solver.mesh.quality() + solver.execute_tui(r"""/define/set-unit-system si """) + solver.execute_tui(r"""/define/units length m """) + solver.mesh.size_info() + solver.execute_tui(r"""/define/models/steady? """) + solver.setup.general.solver.type = "pressure-based" + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_fan.py b/tests/test_pro/test_pro_fan.py new file mode 100644 index 00000000000..474f7084d9b --- /dev/null +++ b/tests/test_pro/test_pro_fan.py @@ -0,0 +1,144 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_fan(launch_fluent_solver_3ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file("pyfluent/fan", "fan_bc_vent.msh") + solver.file.read(file_type=input_type, file_name=input_name) + assert solver._root.get_attr("active?") + assert solver.check_health() == "SERVING" + solver.mesh.check() + solver.execute_tui(r"""/file/show-configuration """) + solver.setup.models.viscous.model = "k-epsilon" + assert solver.setup.models.viscous.model() == "k-epsilon" + solver.setup.boundary_conditions.inlet_vent["inlet-vent-6"] = { + "direction_spec": "Direction Vector" + } + solver.setup.boundary_conditions.inlet_vent["inlet-vent-6"] = { + "ke_spec": "K and Epsilon", + "k": 0.02, + } + solver.setup.boundary_conditions.outlet_vent["outlet-vent-7"] = { + "ke_spec": "K and Epsilon", + "k": 0.02, + } + solver.setup.boundary_conditions.fan["fan-8"] = { + "average_dp": True, + "c": { + "method": "polynomial", + "number_of_coeff": 2, + "coefficients": [200.0, -10.0], + }, + "limit_range": True, + "v_max": 20.0, + "swirl_model": True, + "fr": [0, 0, 20], + "hub": 0.02, + "axis_origin": [0.25, 0, 0], + } + assert ( + solver.setup.boundary_conditions.inlet_vent["inlet-vent-6"].ke_spec() + == "K and Epsilon" + ) + assert solver.setup.boundary_conditions.inlet_vent["inlet-vent-6"].k() == { + "option": "value", + "value": 0.02, + } + assert ( + solver.setup.boundary_conditions.outlet_vent["outlet-vent-7"].ke_spec() + == "K and Epsilon" + ) + assert solver.setup.boundary_conditions.outlet_vent["outlet-vent-7"].k() == { + "option": "value", + "value": 0.02, + } + assert solver.setup.boundary_conditions.fan["fan-8"].c() == { + "method": "polynomial", + "number_of_coeff": 2, + "coefficients": [200.0, -10.0], + } + assert solver.setup.boundary_conditions.fan["fan-8"].axis_origin() == [0.25, 0, 0] + solver.execute_tui(r"""/solve/set/disable-reconstruction? no """) + solver.solution.methods.discretization_scheme = {"pressure": "standard"} + solver.solution.methods.discretization_scheme = {"mom": "first-order-upwind"} + assert solver.solution.methods.discretization_scheme() == { + "k": "first-order-upwind", + "mom": "first-order-upwind", + "epsilon": "first-order-upwind", + "pressure": "standard", + } + solver.execute_tui(r"""/solve/monitors/residual/normalize? yes """) + solver.execute_tui( + r"""/solve/monitors/residual/normalization-factors 0.5231051 3.599108 0.6445935 0.6873757 0.03376108 2.694927 """ + ) + solver.execute_tui(r"""/define/boundary-conditions/list-zones """) + solver.execute_tui(r"""/solve/monitors/residual/plot? no """) + solver.solution.initialization.standard_initialize() + solver.execute_tui(r"""it 1000 """) + solver.file.write(file_type="case-data", file_name="out/fan.cas") + solver.results.graphics.contour["contour-1"] = {} + solver.results.graphics.contour["contour-1"] = { + "field": "pressure", + "surfaces_list": ["fan-8", "symmetry-9", "wall-2", "wall-3"], + } + solver.results.graphics.contour.display(object_name="contour-1") + solver.results.graphics.mesh["mesh-1"] = {} + solver.results.graphics.mesh["mesh-1"] = { + "options": { + "nodes": False, + "edges": True, + "faces": True, + "partitions": False, + "overset": False, + }, + "surfaces_list": [ + "fan-8", + "wall-2", + "wall-3", + "symmetry-9", + "inlet-vent-6", + "outlet-vent-7", + ], + } + solver.results.graphics.mesh.display(object_name="mesh-1") + solver.results.graphics.vector["vector-1"] = {} + solver.results.graphics.vector["vector-1"] = { + "surfaces_list": [ + "symmetry-9", + "fan-8", + "wall-2", + "wall-3", + "inlet-vent-6", + "outlet-vent-7", + ] + } + solver.results.graphics.vector.display(object_name="vector-1") + solver.results.plot.xy_plot["xy-plot-1"] = {} + solver.results.plot.xy_plot["xy-plot-1"] = {"surfaces_list": ["fan-8"]} + solver.results.plot.xy_plot.display(object_name="xy-plot-1") + solver.results.plot.xy_plot["xy-plot-1"] = { + "plot_direction": { + "option": "direction-vector", + "direction_vector": {"z_component": 0, "y_component": 1, "x_component": 0}, + } + } + solver.results.plot.xy_plot.display(object_name="xy-plot-1") + solver.results.report.report_menu.fluxes.mass_flow( + all_bndry_zones=False, zone_list=["fan-8"], write_to_file=False + ) + solver.results.report.report_menu.fluxes.mass_flow( + all_bndry_zones=False, + zone_list=["fan-8"], + write_to_file=True, + file_name="out/mfr-fan.flp", + ) + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_ht.py b/tests/test_pro/test_pro_ht.py new file mode 100644 index 00000000000..77d0902f142 --- /dev/null +++ b/tests/test_pro/test_pro_ht.py @@ -0,0 +1,184 @@ +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_ht(new_watertight_workflow_session): + meshing = new_watertight_workflow_session + input_type, input_name = download_input_file( + "pyfluent/mixing_elbow", "elbow.scdoc.pmdb" + ) + workflow = meshing.workflow + workflow.TaskObject["Import Geometry"].Arguments.setState( + { + r"FileName": r"%s" % input_name, + r"LengthUnit": r"in", + } + ) + workflow.TaskObject["Import Geometry"].Execute() + workflow.TaskObject["Add Local Sizing"].AddChildToTask() + workflow.TaskObject["Add Local Sizing"].Execute() + workflow.TaskObject["Generate the Surface Mesh"].Arguments.setState( + { + r"CFDSurfaceMeshControls": { + r"MaxSize": 0.3, + }, + } + ) + workflow.TaskObject["Generate the Surface Mesh"].Execute() + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=False) + workflow.TaskObject["Describe Geometry"].Arguments.setState( + { + r"SetupType": r"The geometry consists of only fluid regions with no voids", + } + ) + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=True) + workflow.TaskObject["Describe Geometry"].Execute() + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryLabelList": [r"wall-inlet"], + r"BoundaryLabelTypeList": [r"wall"], + r"OldBoundaryLabelList": [r"wall-inlet"], + r"OldBoundaryLabelTypeList": [r"velocity-inlet"], + } + ) + workflow.TaskObject["Update Boundaries"].Execute() + workflow.TaskObject["Update Regions"].Execute() + workflow.TaskObject["Add Boundary Layers"].AddChildToTask() + workflow.TaskObject["Add Boundary Layers"].InsertCompoundChildTask() + workflow.TaskObject["smooth-transition_1"].Arguments.setState( + { + r"BLControlName": r"smooth-transition_1", + } + ) + workflow.TaskObject["Add Boundary Layers"].Arguments.setState({}) + workflow.TaskObject["smooth-transition_1"].Execute() + workflow.TaskObject["Generate the Volume Mesh"].Arguments.setState( + { + r"VolumeFill": r"poly-hexcore", + r"VolumeFillControls": { + r"HexMaxCellLength": 0.3, + }, + } + ) + workflow.TaskObject["Generate the Volume Mesh"].Execute() + meshing.execute_tui(r"""/mesh/check-mesh """) + meshing.execute_tui(r"""/file/write-mesh "elbow.msh.h5" """) + solver = meshing.switch_to_solver() + solver.mesh.check() + solver.execute_tui(r"""/define/units length in """) + solver.mesh.check() + solver.execute_tui(r"""/file/show-configuration """) + assert not solver.setup.models.energy.enabled() + solver.setup.models.energy = {"enabled": True} + assert solver.setup.models.energy.enabled() + solver.execute_tui(r"""/define/materials/copy fluid water-liquid """) + solver.setup.cell_zone_conditions.fluid["fluid"] = {"material": "water-liquid"} + assert "water-liquid" in solver.setup.cell_zone_conditions.fluid["fluid"].material() + solver.setup.boundary_conditions.velocity_inlet["cold-inlet"] = { + "vmag": 0.4, + "t": 293.15, + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_hydraulic_diam": 0.1016, + } + solver.setup.boundary_conditions.velocity_inlet["hot-inlet"] = { + "vmag": 1.2, + "t": 313.15, + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_hydraulic_diam": 0.0254, + } + solver.setup.boundary_conditions.pressure_outlet["outlet"] = { + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_hydraulic_diam": 0.1016, + } + assert solver.setup.boundary_conditions.velocity_inlet["cold-inlet"].vmag() == { + "option": "value", + "value": 0.4, + } + assert solver.setup.boundary_conditions.velocity_inlet["cold-inlet"].t() == { + "option": "value", + "value": 293.15, + } + assert ( + solver.setup.boundary_conditions.velocity_inlet["hot-inlet"].ke_spec() + == "Intensity and Hydraulic Diameter" + ) + solver.execute_tui(r"""/solve/monitors/residual/plot? no """) + solver.solution.report_definitions.surface["outlet-temp-avg"] = {} + solver.solution.report_definitions.surface[ + "outlet-temp-avg" + ].report_type = "surface-massavg" + assert ( + solver.solution.report_definitions.surface["outlet-temp-avg"].report_type() + == "surface-massavg" + ) + solver.solution.report_definitions.surface["outlet-temp-avg"] = { + "field": "temperature", + "surface_names": ["outlet"], + } + solver.solution.monitor.report_files["outlet-temp-avg-rfile"] = {} + solver.solution.monitor.report_files["outlet-temp-avg-rfile"] = { + "report_defs": ["outlet-temp-avg"], + "file_name": r"out\\outlet-temp-avg-rfile.out", + "print": True, + "frequency": 3, + } + solver.solution.monitor.convergence_conditions.convergence_reports[ + "con-outlet-temp-avg" + ] = {} + solver.solution.monitor.convergence_conditions = { + "convergence_reports": { + "con-outlet-temp-avg": { + "initial_values_to_ignore": 20, + "previous_values_to_consider": 15, + "print": True, + "report_defs": "outlet-temp-avg", + "stop_criterion": 1e-05, + } + }, + "frequency": 3, + } + solver.solution.initialization.hybrid_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=150) + solver.results.graphics.contour["contour-vel"] = {} + solver.results.graphics.contour["contour-vel"] = { + "field": "velocity-magnitude", + "surfaces_list": ["symmetry-xyplane"], + "coloring": {"option": "banded", "banded": []}, + } + solver.results.graphics.contour["contour-temp"] = {} + solver.results.graphics.contour["contour-temp"] = { + "field": "velocity-magnitude", + "surfaces_list": ["symmetry-xyplane"], + } + assert ( + solver.results.graphics.contour["contour-temp"].field() == "velocity-magnitude" + ) + assert solver.results.graphics.contour["contour-temp"].surfaces_list() == [ + "symmetry-xyplane" + ] + solver.results.graphics.contour.display(object_name="contour-temp") + solver.results.graphics.vector["vector-vel"] = {} + solver.results.graphics.vector["vector-vel"] = { + "style": "arrow", + "surfaces_list": ["symmetry-xyplane"], + "scale": {"auto_scale": True, "scale_f": 4}, + "skip": 2, + } + solver.results.graphics.vector.display(object_name="vector-vel") + solver.results.report.report_menu.fluxes.mass_flow( + all_bndry_zones=False, + zone_list=["outlet", "hot-inlet", "cold-inlet"], + write_to_file=True, + file_name="mass-flux1.flp", + ) + solver.execute_tui( + r"""/surface/iso-surface z-coordinate z=0_outlet outlet () () 0 () """ + ) + solver.execute_tui(r"""/plot/solution-set/plot-to-file "temp-1.xy" """) + solver.execute_tui(r"""/plot/solution temperature yes () z=0_outlet () """) + solver.file.write(file_type="case-data", file_name="elbow1.cas.h5") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_parameters.py b/tests/test_pro/test_pro_parameters.py new file mode 100644 index 00000000000..0b8b04b7003 --- /dev/null +++ b/tests/test_pro/test_pro_parameters.py @@ -0,0 +1,102 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_parameters(launch_fluent_solver_3ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file( + "pyfluent/static_mixer", "StaticMixer.msh" + ) + solver.file.read(file_type=input_type, file_name=input_name) + solver.setup.models.energy = {"enabled": True} + solver.setup.models.viscous.model = "k-epsilon" + assert solver.setup.models.viscous.model() == "k-epsilon" + solver.setup.models.viscous.k_epsilon_model = "realizable" + assert solver.setup.models.viscous.k_epsilon_model() == "realizable" + solver.setup.named_expressions["inlet1_temp"] = {} + solver.setup.named_expressions["inlet1_temp"] = {"definition": "300 [K]"} + solver.setup.named_expressions["inlet1_temp"] = {"input_parameter": True} + assert solver.setup.named_expressions["inlet1_temp"]() == { + "name": "inlet1_temp", + "definition": "300 [K]", + "description": "", + "input_parameter": True, + "output_parameter": False, + } + solver.setup.named_expressions["inlet2_temp"] = {} + solver.setup.named_expressions["inlet2_temp"] = { + "definition": "350 [K]", + "input_parameter": True, + } + solver.setup.named_expressions["inlet1_vel"] = {} + solver.setup.named_expressions["inlet1_vel"] = { + "definition": "5 [m/s]", + "input_parameter": True, + } + solver.setup.named_expressions["inlet2_vel"] = {} + solver.setup.named_expressions["inlet2_vel"] = { + "definition": "10 [m/s]", + "input_parameter": True, + } + assert solver.setup.named_expressions["inlet2_vel"]() == { + "name": "inlet2_vel", + "definition": "10 [m/s]", + "description": "", + "input_parameter": True, + "output_parameter": False, + } + solver.execute_tui(r"""/define/boundary-conditions/list-zones """) + solver.execute_tui(r"""/define/boundary-conditions/zone-type in1 velocity-inlet """) + solver.execute_tui(r"""/define/boundary-conditions/zone-type in2 velocity-inlet """) + solver.setup.boundary_conditions.velocity_inlet["in1"] = { + "vmag": "inlet1_vel", + "t": "inlet1_temp", + } + solver.setup.boundary_conditions.velocity_inlet["in2"] = { + "vmag": "inlet2_vel", + "t": "inlet2_temp", + } + solver.solution.report_definitions.surface["outlet-temp-avg"] = {} + solver.solution.report_definitions.surface[ + "outlet-temp-avg" + ].report_type = "surface-massavg" + solver.solution.report_definitions.surface["outlet-temp-avg"] = { + "field": "temperature", + "surface_names": ["outlet"], + } + solver.solution.monitor.report_files["outlet-temp-avg-rfile"] = {} + solver.solution.monitor.report_files["outlet-temp-avg-rfile"] = { + "report_defs": ["outlet-temp-avg"], + "print": True, + "file_name": r"out\\outlet-temp-avg-rfile.out", + } + solver.solution.monitor.report_plots["outlet-temp-avg-rplot"] = {} + solver.solution.monitor.report_plots["outlet-temp-avg-rplot"] = { + "report_defs": ["outlet-temp-avg"], + "print": True, + } + solver.execute_tui( + r"""/define/parameters/output-parameters/create report-definition outlet-temp-avg """ + ) + solver.execute_tui(r"""/solve/initialize/compute-defaults/velocity-inlet in1 """) + solver.solution.run_calculation.iter_count = 350 + assert solver.solution.run_calculation.iter_count() == 350 + solver.solution.run_calculation.iterate(number_of_iterations=350) + solver.execute_tui(r"""/display/surface/plane-surface plane-4 xy-plane 1. """) + solver.results.graphics.lic["lic-temp"] = {} + solver.results.graphics.lic["lic-temp"] = { + "field": "temperature", + "surfaces_list": ["plane-4"], + "texture_size": 2, + } + solver.results.graphics.lic.display(object_name="lic-temp") + solver.file.write(file_type="case-data", file_name="out/StaticMixer.cas.h5") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_porous.py b/tests/test_pro/test_pro_porous.py new file mode 100644 index 00000000000..34b54d1f9e8 --- /dev/null +++ b/tests/test_pro/test_pro_porous.py @@ -0,0 +1,68 @@ +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_porous(launch_fluent_solver_3ddp_t2): + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file( + "pyfluent/catalytic_converter", "catalytic_converter.msh.h5" + ) + solver.execute_tui(r"""/file/set-tui-version "23.1" """) + solver.file.read(file_type=input_type, file_name=input_name) + solver.mesh.size_info() + solver.execute_tui(r"""/define/units length mm """) + solver.setup.models.energy = {"enabled": True, "inlet_diffusion": False} + solver.execute_tui(r"""/define/materials/copy fluid nitrogen """) + solver.execute_tui(r"""/define/materials/copy fluid hydrogen """) + solver.execute_tui( + r"""/define/materials/change-create nitrogen nit yes constant 1.2 no yes constant 0.1 no no no no no """ + ) + solver.setup.cell_zone_conditions.fluid["fluid:0"] = {"material": "nitrogen"} + solver.execute_tui( + r"""/define/boundary-conditions/copy-bc fluid:0 fluid:1 fluid:3 () """ + ) + solver.setup.cell_zone_conditions.fluid["fluid:substrate:1"] = { + "material": "nitrogen", + "porous": True, + } + solver.execute_tui( + r"""/define/boundary-conditions/copy-bc fluid:substrate:1 fluid:substrate:2 () """ + ) + solver.setup.boundary_conditions.velocity_inlet["inlet"] = { + "vmag": 125.0, + "t": 800.0, + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_hydraulic_diam": 0.5, + } + solver.setup.boundary_conditions.pressure_outlet["outlet"] = { + "t0": 800.0, + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_hydraulic_diam": 0.5, + } + assert solver.setup.boundary_conditions.velocity_inlet["inlet"].vmag() == { + "option": "value", + "value": 125.0, + } + solver.execute_tui(r"""/solve/initialize/compute-defaults/velocity-inlet inlet """) + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iter_count = 2 + solver.solution.run_calculation.iterate(number_of_iterations=2) + solver.results.report.report_menu.fluxes.mass_flow( + all_bndry_zones=False, + zone_list=["outlet"], + write_to_file=True, + file_name="mass_flow_rate.flp", + ) + # solver.setup.cell_zone_conditions.fluid['fluid:substrate:1'] = {'material': 'hydrogen', 'dir_spec_cond': 'Conical'} + # solver.execute_tui(r'''/define/boundary-conditions/copy-bc fluid:substrate:1 fluid:substrate:2 () ''') + # solver.solution.initialization.standard_initialize() + # solver.solution.run_calculation.iterate(number_of_iterations=2) + # solver.execute_tui(r'''/define/curvilinear-coordinate-system/new "curve-coordinate-0" fluid:1 () "Base_Vector" 1 0 0 "Vector_Projection" 0 1 0 ''') + # solver.execute_tui(r'''/define/curvilinear-coordinate-system/calculation-settings 30 1e-08 ''') + # solver.setup.cell_zone_conditions.fluid['fluid:1'] = {"material": "nit", "porous": True, "dir_spec_cond": "Curvilinear Coordinate System", "cursys_name": "curve-coordinate-0"} + # solver.file.write(file_type="case-data", file_name="catalytic_converter_final.cas.h5") + # solver.execute_tui(r'''(proc-stats) ''') + # solver.execute_tui(r'''(display "testing finished") ''') + solver.exit() diff --git a/tests/test_pro/test_pro_post.py b/tests/test_pro/test_pro_post.py new file mode 100644 index 00000000000..72410db42ee --- /dev/null +++ b/tests/test_pro/test_pro_post.py @@ -0,0 +1,390 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_exp(launch_fluent_solver_3ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file("pyfluent/box", "poly.msh") + solver.file.read(file_type=input_type, file_name=input_name) + solver.mesh.check() + solver.execute_tui(r"""/file/show-configuration """) + solver.setup.models.viscous.model = "laminar" + assert solver.setup.models.viscous.model() == "laminar" + solver.execute_tui(r"""/define/units velocity "m/s" """) + solver.execute_tui(r"""/define/units pressure "Pa" """) + solver.execute_tui(r"""/define/units temperature "K" """) + solver.execute_tui( + r"""/define/materials/change-create air air yes constant 1 no no yes constant 0.001 no no no """ + ) + solver.setup.boundary_conditions.wall["top"] = { + "motion_bc": "Moving Wall", + "vmag": 1.0, + } + solver.solution.methods.p_v_coupling.flow_scheme = "Coupled" + assert solver.solution.methods.p_v_coupling.flow_scheme() == "Coupled" + solver.execute_tui(r"""/solve/monitors/residual/scale-by-coefficient? yes no """) + solver.execute_tui( + r"""/solve/monitors/residual/convergence-criteria 1e-05 1e-05 1e-05 1e-05 """ + ) + solver.execute_tui(r"""/solve/monitors/residual/plot? no """) + solver.solution.initialization.hybrid_initialize() + solver.file.write(file_type="case-data", file_name="out/pro_poly_ini") + solver.mesh.check() + solver.execute_tui( + r"""/file/write-profile "out/test1" symmetry bottom front left right top () pressure velocity-magnitude x-wall-shear pressure-coefficient x-velocity quit """ + ) + solver.mesh.check() + solver.execute_tui(r"""/define/reference-frames/list """) + solver.execute_tui(r"""/define/reference-frames/list-properties "global" """) + solver.execute_tui(r"""/define/reference-frames/display "global" """) + solver.execute_tui(r"""/define/reference-frames/hide "global" """) + solver.execute_tui( + r"""/define/materials/change-create air air yes ideal-gas yes constant 1006.43 no no no yes 0. no """ + ) + solver.execute_tui(r"""/define/materials/list-materials """) + solver.execute_tui( + r"""/define/materials/change-create air air yes boussinesq 0.05 no no no no no no """ + ) + solver.setup.boundary_conditions.wall["bottom"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["front"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["left"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["right"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["bottom"].t = 500.0 + solver.setup.boundary_conditions.wall["front"].t = 500.0 + solver.setup.boundary_conditions.wall["left"].t = 500.0 + solver.setup.boundary_conditions.wall["right"].t = 500.0 + solver.setup.cell_zone_conditions.fluid["fluid"].mrf_motion = True + solver.setup.cell_zone_conditions.fluid["fluid"].reference_frame_axis_direction = [ + {"value": 0.5, "option": "value"}, + {"value": 0, "option": "value"}, + {"value": 1, "option": "value"}, + ] + solver.setup.cell_zone_conditions.fluid["fluid"].mrf_omega = 5.0 + solver.execute_tui(r"""/define/boundary-conditions/set/symmetry symmetry () """) + solver.setup.boundary_conditions.wall["front"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["left"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["right"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["top"].thermal_bc = "Temperature" + solver.setup.boundary_conditions.wall["bottom"].t = 1000.0 + solver.setup.boundary_conditions.wall["front"].t = 1000.0 + solver.setup.boundary_conditions.wall["left"].t = 1000.0 + solver.setup.boundary_conditions.wall["right"].t = 1000.0 + solver.setup.boundary_conditions.wall["top"].t = 1000.0 + solver.setup.cell_zone_conditions.fluid["fluid"] = { + "sources": True, + "source_terms": { + "mass": [10.0], + "x-momentum": [], + "y-momentum": [], + "z-momentum": [], + "energy": [], + }, + "fixed": True, + "fixes": { + "x-velocity": 0.0, + "y-velocity": 0.0, + "z-velocity": 0.0, + "temperature": 0.0, + }, + } + solver.execute_tui(r"""/define/boundary-conditions/list-zones """) + solver.execute_tui(r"""/define/boundary-conditions/zone-name top top """) + solver.execute_tui(r"""/define/boundary-conditions/zone-type top wall """) + solver.execute_tui( + r"""/define/materials/change-create air air yes boussinesq 0.05 no no no no no no """ + ) + solver.execute_tui(r"""/define/materials/list-materials """) + solver.execute_tui(r"""/define/materials/list-properties air """) + solver.execute_tui(r"""/solve/monitors/residual/plot? no """) + solver.execute_tui( + r"""/solve/monitors/residual/check-convergence? yes yes yes yes yes """ + ) + solver.execute_tui(r"""/solve/monitors/residual/criterion-type 0 """) + solver.execute_tui(r"""/solve/monitors/residual/print? yes """) + solver.execute_tui(r"""/solve/monitors/residual/reset? yes """) + solver.solution.report_definitions.force["report-def-0"] = {} + solver.solution.report_definitions.force["report-def-0"] = { + "thread_names": ["top", "bottom", "front", "left", "right"], + "force_vector": [1, 1, 1], + "per_zone": True, + } + solver.solution.report_definitions.compute(report_defs=["report-def-0"]) + solver.solution.monitor.report_plots["report-plot-0"] = {} + solver.solution.monitor.report_plots["report-plot-0"] = { + "report_defs": ["report-def-0"], + "print": True, + } + solver.solution.monitor.report_files["report-file-0"] = {} + solver.solution.monitor.report_files["report-file-0"] = { + "file_name": r"out\\force-rep.out", + "report_defs": ["report-def-0"], + } + solver.execute_tui(r"""/solve/report-files/list """) + solver.execute_tui(r"""/solve/report-files/list-properties "report-file-0" """) + solver.execute_tui(r"""/solve/report-files/clear-data () """) + solver.solution.report_definitions.surface["report-def-1"] = {} + solver.solution.report_definitions.surface[ + "report-def-1" + ].report_type = "surface-integral" + solver.solution.report_definitions.surface["report-def-1"] = { + "surface_names": ["top", "bottom", "front", "left", "right"], + "field": "pressure", + "per_surface": True, + } + solver.solution.monitor.report_files["report-file-1"] = {} + solver.solution.monitor.report_files["report-file-1"] = { + "file_name": r"out\\surface-rep.out", + "report_defs": ["report-def-1"], + } + solver.solution.monitor.report_plots["report-plot-1"] = {} + solver.solution.monitor.report_plots["report-plot-1"] = { + "report_defs": ["report-def-1"] + } + solver.solution.report_definitions.volume["report-def-2"] = {} + solver.solution.report_definitions.volume[ + "report-def-2" + ].report_type = "volume-average" + solver.solution.report_definitions.volume["report-def-2"] = { + "field": "pressure", + "zone_names": ["fluid"], + "per_zone": True, + } + solver.solution.monitor.report_plots["report-plot-2"] = {} + solver.solution.monitor.report_plots["report-plot-2"] = { + "report_defs": ["report-def-2"] + } + solver.execute_tui(r"""/solve/report-plots/list """) + solver.solution.monitor.report_files["report-file-2"] = {} + solver.solution.monitor.report_files["report-file-2"] = { + "file_name": r"out\\vol-rep.out", + "report_defs": ["report-def-2"], + "print": True, + } + solver.execute_tui( + r"""/define/materials/change-create air air yes ideal-gas no no no no no no """ + ) + solver.execute_tui(r"""/solve/set/equations/flow yes """) + solver.solution.run_calculation.data_sampling.data_sampling = True + solver.solution.initialization.standard_initialize() + solver.execute_tui(r"""it 5 """) + solver.mesh.check() + solver.results.graphics.mesh["mesh-1"] = {} + solver.results.graphics.mesh["mesh-1"] = { + "surfaces_list": ["top", "bottom", "left", "right", "front"], + "options": { + "nodes": False, + "edges": True, + "faces": True, + "partitions": False, + "overset": False, + }, + } + assert solver.results.graphics.mesh["mesh-1"].options() == { + "nodes": False, + "edges": True, + "faces": True, + "partitions": False, + "overset": False, + } + assert solver.results.graphics.mesh["mesh-1"].surfaces_list() == [ + "top", + "bottom", + "left", + "right", + "front", + ] + solver.results.graphics.mesh.add_to_graphics(object_name="mesh-1") + solver.results.graphics.mesh.display(object_name="mesh-1") + solver.execute_tui(r"""/display/set/rendering-options/driver quit """) + solver.results.graphics.contour["contour-1"] = {} + solver.results.graphics.contour["contour-1"] = { + "surfaces_list": [ + "left", + "front", + "bottom", + "default-interior", + "top", + "symmetry", + "right", + ], + "field": "pressure", + } + assert solver.results.graphics.contour["contour-1"].surfaces_list() == [ + "left", + "front", + "bottom", + "default-interior", + "top", + "symmetry", + "right", + ] + assert solver.results.graphics.contour["contour-1"].field() == "pressure" + solver.results.graphics.contour.add_to_graphics(object_name="contour-1") + solver.file.read(file_type="case-data", file_name="out/pro_poly_ini") + solver.execute_tui(r"""it 500 """) + solver.execute_tui(r"""/surface/point-array point-array-7 10 0. 0. 0. 1 0. 0. """) + solver.execute_tui(r"""/surface/point-surface point-8 0. 0. 0. """) + solver.execute_tui(r"""/surface/line-surface line-9 0. 0. 0. 1 0.5 1 """) + solver.execute_tui( + r"""/surface/iso-surface pressure pressure-10 top bottom () () () """ + ) + solver.execute_tui(r"""/surface/plane-surface plane-11 yz-plane 0.5 """) + solver.execute_tui( + r"""/surface/multiple-iso-surfaces pressure pressure-12 top bottom () () 0. 11 0.01 """ + ) + solver.execute_tui( + r"""/surface/multiple-plane-surfaces plane-23 yz-plane 0.5 10 0.01 """ + ) + solver.execute_tui(r"""/surface/list-surfaces """) + solver.execute_tui(r"""/surface/rake-surface rake-33 0. 0. 0. 1 0. 0. 10 """) + solver.results.graphics.mesh["mesh-1"] = {} + solver.results.graphics.mesh["mesh-1"] = { + "surfaces_list": ["top", "bottom", "left", "right", "front"], + "options": { + "nodes": False, + "edges": True, + "faces": True, + "partitions": False, + "overset": False, + }, + "shrink_factor": 0.5, + } + assert solver.results.graphics.mesh["mesh-1"].surfaces_list() == [ + "top", + "bottom", + "left", + "right", + "front", + ] + assert solver.results.graphics.mesh["mesh-1"].options() == { + "nodes": False, + "edges": True, + "faces": True, + "partitions": False, + "overset": False, + } + solver.results.graphics.mesh.display(object_name="mesh-1") + solver.results.graphics.contour["contour-1"] = {} + solver.results.graphics.contour["contour-1"] = {"field": "pressure"} + assert solver.results.graphics.contour["contour-1"].field() == "pressure" + solver.results.graphics.contour.add_to_graphics(object_name="contour-1") + solver.results.graphics.contour.display(object_name="contour-1") + solver.results.graphics.vector["vector-1"] = {} + solver.results.graphics.vector["vector-1"] = {"skip": 2} + assert solver.results.graphics.vector["vector-1"].skip() == 2 + solver.results.graphics.vector.display(object_name="vector-1") + solver.results.graphics.pathline["pathlines-1"] = {} + solver.results.graphics.pathline["pathlines-1"] = { + "surfaces_list": ["top", "bottom", "front", "left", "right"] + } + solver.results.graphics.pathline.display(object_name="pathlines-1") + assert solver.results.graphics.pathline["pathlines-1"].surfaces_list() == [ + "top", + "bottom", + "front", + "left", + "right", + ] + solver.results.plot.xy_plot["xy-plot-1"] = {} + solver.results.plot.xy_plot["xy-plot-1"] = { + "surfaces_list": ["top", "bottom", "left", "right", "front"] + } + assert solver.results.plot.xy_plot["xy-plot-1"].surfaces_list() == [ + "top", + "bottom", + "left", + "right", + "front", + ] + solver.results.plot.xy_plot.display(object_name="xy-plot-1") + solver.results.scene["scene-1"] = {} + solver.results.scene["scene-1"].graphics_objects["contour-1"] = {} + solver.results.scene["scene-1"].graphics_objects["mesh-1"] = {} + solver.results.scene["scene-1"].graphics_objects["vector-1"] = {} + solver.results.scene["scene-1"] = { + "graphics_objects": { + "contour-1": {"transparency": 50}, + "mesh-1": {"transparency": 55}, + "vector-1": {}, + } + } + solver.results.scene.display(object_name="scene-1") + assert solver.results.scene["scene-1"].graphics_objects["contour-1"]() == { + "transparency": 50 + } + assert solver.results.scene["scene-1"].graphics_objects["mesh-1"]() == { + "transparency": 55 + } + solver.results.scene.copy(from_name="scene-1", new_name="scene-2") + solver.results.scene["scene-2"] = {"graphics_objects": {}} + solver.results.scene.display(object_name="scene-2") + solver.execute_tui( + r"""/plot/histogram pressure -0.4653678834438324 1.225927948951721 10 no top bottom left right front () """ + ) + solver.execute_tui( + r"""/plot/cumulative-plot/add "cumulative-plot-1" option cumulative-force zones top bottom left right front () split-direction 1. 1 1 force-direction 1. 1 1 number-of-divisions 15 quit """ + ) + solver.execute_tui(r"""/plot/cumulative-plot/plot "cumulative-plot-1" """) + solver.execute_tui(r"""/plot/cumulative-plot/list """) + solver.execute_tui( + r"""/plot/cumulative-plot/list-properties "cumulative-plot-1" """ + ) + solver.execute_tui(r"""/plot/cumulative-plot/print "cumulative-plot-1" """) + solver.execute_tui( + r"""/plot/cumulative-plot/write "cumulative-plot-1" "out/cum-force.xy" """ + ) + solver.results.report.report_menu.fluxes.mass_flow( + all_bndry_zones=False, + zone_list=["front", "right", "left", "bottom", "top"], + write_to_file=True, + file_name="out/mfr", + ) + solver.execute_tui( + r"""/report/forces/pressure-center yes no yes 0.5 yes "out/forces" """ + ) + solver.execute_tui( + r"""/report/forces/wall-forces yes 1 1 1 yes "out/wall-forces" """ + ) + solver.execute_tui( + r"""/report/forces/wall-moments yes 1 1 1 1 0 0 yes "out/wall-mom" """ + ) + solver.results.report.report_menu.projected_surface_area( + surface_id_val=[2, 1, 5, 4, 6], + min_feature_size=0.01, + proj_plane_norm_comp=[1, 0, 0], + ) + solver.results.report.report_menu.surface_integrals( + report_type="vertex-max", + surface_id=["top", "bottom", "left", "right", "front"], + cell_report="pressure", + write_to_file=True, + file_name="out/vertex-max-pressure", + ) + solver.results.report.report_menu.volume_integrals( + report_type="mass", thread_id_list=["fluid"], write_to_file=False + ) + solver.results.report.report_menu.volume_integrals( + report_type="sum", + thread_id_list=["fluid"], + cell_function="pressure", + write_to_file=True, + file_name="out/sum", + ) + solver.results.report.report_menu.summary( + write_to_file=True, file_name="out/summary" + ) + solver.execute_tui(r"""/report/reference-values/pressure 0. """) + solver.execute_tui(r"""/report/reference-values/density 1.225 """) + solver.results.report.report_menu.system.sys_statistics() + solver.results.report.report_menu.system.time_statistics() + solver.execute_tui(r"""it 5 """) + solver.file.write(file_type="case-data", file_name="out/pro_poly-final_s1") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_settings_pbcs.py b/tests/test_pro/test_pro_settings_pbcs.py new file mode 100644 index 00000000000..d94d1c0df14 --- /dev/null +++ b/tests/test_pro/test_pro_settings_pbcs.py @@ -0,0 +1,211 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_exp(launch_fluent_solver_3ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file("pyfluent/nozzle", "nozzle_3d.msh") + solver.file.read(file_type=input_type, file_name=input_name) + solver.mesh.check() + solver.execute_tui(r"""/file/show-configuration """) + solver.setup.models.energy = {"enabled": True} + assert solver.setup.models.energy.enabled() + solver.setup.models.viscous.model = "laminar" + assert solver.setup.models.viscous.model() == "laminar" + solver.execute_tui( + r"""/define/materials/change-create air air yes ideal-gas yes constant 1006.43 yes constant 0.0242 yes constant 1.7894e-05 yes 28.966 no no """ + ) + solver.setup.boundary_conditions.pressure_inlet["inlet"] = { + "p0": 200000.0, + "supersonic_or_initial_gauge_pressure": 190000.0, + "t0": 500.0, + } + assert solver.setup.boundary_conditions.pressure_inlet["inlet"].p0() == { + "option": "value", + "value": 200000.0, + } + assert solver.setup.boundary_conditions.pressure_inlet[ + "inlet" + ].supersonic_or_initial_gauge_pressure() == {"option": "value", "value": 190000.0} + solver.setup.boundary_conditions.pressure_outlet["outlet"] = {"p": 75000.0} + assert solver.setup.boundary_conditions.pressure_outlet["outlet"].p() == { + "option": "value", + "value": 75000.0, + } + solver.setup.boundary_conditions.wall["top"] = { + "thermal_bc": "Temperature", + "t": 328.0, + } + assert solver.setup.boundary_conditions.wall["top"].t() == { + "option": "value", + "value": 328.0, + } + solver.setup.boundary_conditions.wall["bottom"] = { + "thermal_bc": "Temperature", + "t": 328.0, + } + assert ( + solver.setup.boundary_conditions.wall["top"].t() + == solver.setup.boundary_conditions.wall["bottom"].t() + ) + solver.execute_tui(r"""/define/operating-conditions/operating-pressure 101325 """) + solver.execute_tui( + r"""/solve/monitors/residual/convergence-criteria 1e-05 1e-05 1e-05 1e-05 1e-05 """ + ) + solver.execute_tui(r"""/solve/monitors/residual/plot? no """) + solver.file.write(file_type="case", file_name="out/nozzle3d-ini") + solver.solution.initialization.hybrid_initialize() + solver.execute_tui(r"""/solve/set/equations/flow yes """) + solver.execute_tui(r"""/solve/set/equations/temperature yes """) + solver.setup.models.viscous.model = "k-epsilon" + solver.execute_tui(r"""/solve/set/equations/ke yes """) + solver.solution.methods.gradient_scheme = "least-square-cell-based" + assert solver.solution.methods.gradient_scheme() == "least-square-cell-based" + solver.solution.methods.discretization_scheme = {"pressure": "standard"} + assert solver.solution.methods.discretization_scheme["pressure"]() == "standard" + solver.solution.methods.discretization_scheme = {"pressure": "presto!"} + assert solver.solution.methods.discretization_scheme["pressure"]() == "presto!" + solver.solution.methods.discretization_scheme = {"density": "first-order-upwind"} + assert ( + solver.solution.methods.discretization_scheme["density"]() + == "first-order-upwind" + ) + solver.solution.methods.discretization_scheme = {"density": "quick"} + assert solver.solution.methods.discretization_scheme["density"]() == "quick" + solver.solution.methods.discretization_scheme = {"mom": "first-order-upwind"} + assert ( + solver.solution.methods.discretization_scheme["mom"]() == "first-order-upwind" + ) + solver.solution.methods.discretization_scheme = {"mom": "quick"} + assert solver.solution.methods.discretization_scheme["mom"]() == "quick" + solver.solution.methods.discretization_scheme = { + "temperature": "first-order-upwind" + } + assert ( + solver.solution.methods.discretization_scheme["temperature"]() + == "first-order-upwind" + ) + solver.solution.methods.discretization_scheme = {"temperature": "quick"} + assert solver.solution.methods.discretization_scheme["temperature"]() == "quick" + solver.solution.methods.discretization_scheme = { + "temperature": "second-order-upwind" + } + assert ( + solver.solution.methods.discretization_scheme["temperature"]() + == "second-order-upwind" + ) + solver.solution.methods.discretization_scheme = {"k": "second-order-upwind"} + assert solver.solution.methods.discretization_scheme["k"]() == "second-order-upwind" + solver.solution.methods.discretization_scheme = {"epsilon": "second-order-upwind"} + solver.execute_tui( + r"""/solve/set/limits 1. 50000000000. 1. 5000. 1e-14 9.999999999999999e-21 100000. """ + ) + solver.solution.methods.p_v_coupling.flow_scheme = "Coupled" + assert solver.solution.methods.p_v_coupling.flow_scheme() == "Coupled" + solver.solution.controls.p_v_controls.explicit_momentum_under_relaxation = 0.5 + assert ( + solver.solution.controls.p_v_controls.explicit_momentum_under_relaxation() + == 0.5 + ) + solver.solution.controls.p_v_controls.explicit_pressure_under_relaxation = 0.4 + assert ( + solver.solution.controls.p_v_controls.explicit_pressure_under_relaxation() + == 0.4 + ) + solver.solution.controls.limits.min_temperature = 2.0 + assert solver.solution.controls.limits.min_temperature() == 2.0 + solver.solution.methods.expert.numerics_pbns.velocity_formulation = "absolute" + assert ( + solver.solution.methods.expert.numerics_pbns.velocity_formulation() + == "absolute" + ) + solver.execute_tui(r"""/solve/set/expert no no no no """) + solver.solution.methods.set_solution_methods_to_default() + solver.solution.controls.set_controls_to_default.solution_controls() + solver.execute_tui(r"""/solve/monitors/residual/plot? no """) + solver.execute_tui(r"""/solve/monitors/residual/print? yes """) + solver.execute_tui(r"""/solve/monitors/residual/reset? yes """) + solver.execute_tui( + r"""/solve/monitors/residual/monitor? yes yes yes yes yes yes yes """ + ) + solver.execute_tui(r"""/solve/monitors/residual/n-display 1000 """) + solver.execute_tui(r"""/solve/monitors/residual/criterion-type 0 """) + solver.execute_tui( + r"""/solve/monitors/residual/convergence-criteria 1e-05 1e-05 1e-05 1e-05 1e-05 0.001 0.001 """ + ) + solver.execute_tui( + r"""/solve/monitors/residual/check-convergence? yes yes yes yes yes yes yes """ + ) + solver.execute_tui(r"""/solve/monitors/residual/n-maximize-norms 5 """) + solver.execute_tui(r"""/solve/monitors/residual/n-save 1000 """) + solver.execute_tui(r"""/solve/monitors/residual/normalize? yes """) + solver.execute_tui( + r"""/solve/monitors/residual/normalization-factors 0.5 0.5 0.5 0.5 0.5 0.5 0.5 """ + ) + solver.execute_tui(r"""/solve/monitors/residual/re-normalize """) + solver.execute_tui( + r"""/solve/monitors/residual/scale-by-coefficient? yes yes yes """ + ) + solver.execute_tui( + r"""/solve/set/previous-defaults/undo-2022r1-default-changes? no no no """ + ) + solver.solution.methods.expert.numerics_pbns.velocity_formulation = "absolute" + assert ( + solver.solution.methods.expert.numerics_pbns.velocity_formulation() + == "absolute" + ) + solver.solution.initialization.hybrid_initialize() + solver.solution.initialization.list_defaults() + solver.execute_tui(r"""/solve/initialize/init-turb-vel-fluctuations """) + solver.solution.initialization.hybrid_init_options.general_settings.iter_count = 5 + assert ( + solver.solution.initialization.hybrid_init_options.general_settings.iter_count() + == 5 + ) + solver.solution.initialization.hybrid_init_options.general_settings.external_aero = ( + True + ) + assert ( + solver.solution.initialization.hybrid_init_options.general_settings.external_aero() + == True + ) + solver.execute_tui( + r"""/solve/initialize/set-hyb-initializationturbulent-settings/ yes """ + ) + solver.solution.initialization.hybrid_init_options.turbulent_setting.averaged_turbulent_parameters = ( + False + ) + assert ( + solver.solution.initialization.hybrid_init_options.turbulent_setting.averaged_turbulent_parameters() + == False + ) + solver.file.read(file_type="case", file_name="out/nozzle3d-ini") + solver.solution.initialization.standard_initialize() + solver.execute_tui(r"""(benchmark '(iterate 500)) """) + solver.execute_tui(r"""/surface/line-surface center-line 0 0 0 2 0 0 """) + solver.file.write(file_type="case-data", file_name="out/nozzle-3d-supsonic_r1.cas") + solver.execute_tui( + r"""/plot/plot no "out/temp.xy" no no no temperature yes 1 0 0 center-line () """ + ) + solver.execute_tui( + r"""/plot/plot no "out/mach.xy" no no no mach-number no no x-coordinate center-line () """ + ) + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""/solve/monitors/residual/plot? yes """) + solver.execute_tui( + r"""/plot/residuals-set/plot-to-file "out/nozzle-settings_s1.res" """ + ) + solver.execute_tui(r"""it 0 """) + solver.execute_tui( + r"""(define port (open-output-file "out/nozzle-settings_s1_no.conv")) """ + ) + solver.execute_tui(r"""(write (%iterate 0) port) """) + solver.execute_tui(r"""(close-output-port port) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_species.py b/tests/test_pro/test_pro_species.py new file mode 100644 index 00000000000..f76ef776fa1 --- /dev/null +++ b/tests/test_pro/test_pro_species.py @@ -0,0 +1,147 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_exp(launch_fluent_solver_2ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_2ddp_t2 + input_type, input_name = download_input_file("pyfluent/2d_box", "pro_species.cas") + solver.file.read(file_type=input_type, file_name=input_name) + solver.setup.models.energy = {"enabled": True} + solver.setup.models.viscous.model = "k-epsilon" + solver.setup.models.viscous.k_epsilon_model = "realizable" + solver.execute_tui( + r"""/define/models/species/species-transport? yes methane-air """ + ) + solver.execute_tui( + r"""/define/boundary-conditions/zone-type vi-fuel velocity-inlet """ + ) + solver.execute_tui( + r"""/define/boundary-conditions/zone-type vi-oxid velocity-inlet """ + ) + solver.execute_tui(r"""/define/boundary-conditions/zone-type po pressure-outlet """) + solver.setup.boundary_conditions.velocity_inlet["vi-fuel"] = { + "vmag": 5.0, + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_intensity": 0.09999999400000001, + "turb_hydraulic_diam": 0.009999999799999999, + "species_in_mole_fractions": True, + "mf": {"ch4": 0.6144294, "o2": 0, "co2": 0.1119896, "h2o": 0.273581}, + } + solver.setup.boundary_conditions.velocity_inlet["vi-oxid"] = { + "vmag": 10.0, + "ke_spec": "Intensity and Hydraulic Diameter", + "turb_intensity": 0.09999999400000001, + "turb_hydraulic_diam": 0.009999999799999999, + "species_in_mole_fractions": True, + "mf": {"ch4": 0, "o2": 0.207292, "co2": 0, "h2o": 0}, + } + solver.setup.boundary_conditions.pressure_outlet["po"] = { + "ke_spec": "K and Epsilon" + } + solver.solution.methods.gradient_scheme = "green-gauss-node-based" + solver.solution.methods.flux_type.pbns_cases.flux_auto_select = False + solver.solution.methods.flux_type.pbns_cases.flux_type = 0 + solver.solution.methods.gradient_scheme = "green-gauss-node-based" + solver.execute_tui( + r"""/solve/monitors/residual/convergence-criteria 0.001 0.001 0.001 1e-06 1e-06 1e-06 0.001 0.001 0.001 0.001 """ + ) + solver.solution.methods.discretization_scheme = {"pressure": "presto!"} + solver.solution.methods.discretization_scheme = {"k": "second-order-upwind"} + solver.solution.methods.discretization_scheme = {"epsilon": "second-order-upwind"} + solver.solution.report_definitions.surface["mf_co2_outlet"] = {} + solver.solution.report_definitions.surface[ + "mf_co2_outlet" + ].report_type = "surface-areaavg" + solver.solution.report_definitions.surface["mf_co2_outlet"] = { + "field": "molef-co2", + "surface_names": ["po"], + } + solver.solution.report_definitions.surface["mf_h20_outlet"] = {} + solver.solution.report_definitions.surface[ + "mf_h20_outlet" + ].report_type = "surface-areaavg" + solver.solution.report_definitions.surface["mf_h20_outlet"] = { + "field": "molef-h2o", + "surface_names": ["po"], + } + solver.solution.report_definitions.surface["mf_temp_outlet"] = {} + solver.solution.report_definitions.surface[ + "mf_temp_outlet" + ].report_type = "surface-areaavg" + solver.solution.report_definitions.surface["mf_temp_outlet"] = { + "field": "temperature", + "surface_names": ["po"], + } + solver.solution.monitor.report_files["mf_co2_outlet"] = {} + solver.solution.monitor.report_files["mf_co2_outlet"] = { + "file_name": r"out\\mf_co2_outlet.out", + "report_defs": ["mf_co2_outlet"], + "print": True, + } + solver.solution.monitor.report_files["mf_h20_outlet"] = {} + solver.solution.monitor.report_files["mf_h20_outlet"] = { + "file_name": r"out\\mf_h20_outlet.out", + "report_defs": ["mf_h20_outlet"], + "print": True, + } + solver.solution.monitor.report_files["mf_temp_outlet"] = {} + solver.solution.monitor.report_files["mf_temp_outlet"] = { + "file_name": r"out\\mf_temp_outlet.out", + "report_defs": ["mf_temp_outlet"], + "print": True, + } + solver.solution.initialization.hybrid_initialize() + solver.execute_tui(r"""(benchmark '(iterate 150)) """) + solver.execute_tui( + r"""/plot/plot yes "out/mass_ch4_outlet.xy" no no no ch4 yes 0 1 po () """ + ) + solver.execute_tui( + r"""/plot/plot yes "out/mass_o2_outlet.xy" no no no o2 yes 0 1 po () """ + ) + solver.execute_tui( + r"""/plot/plot yes "out/mass_co2_outlet.xy" no no no co2 yes 0 1 po () """ + ) + solver.execute_tui( + r"""/plot/plot yes "out/mass_h2o_outlet.xy" no no no h2o yes 0 1 po () """ + ) + solver.execute_tui( + r"""/plot/plot yes "out/mass_n2_outlet.xy" no no no n2 yes 0 1 po () """ + ) + solver.execute_tui( + r"""/plot/plot yes "out/vmag_outlet.xy" no no no velocity-magnitude yes 0 1 po () """ + ) + solver.execute_tui( + r"""/plot/plot yes "out/k_outlet.xy" no no no turb-kinetic-energy yes 0 1 po () """ + ) + solver.results.graphics.contour["mf_co2"] = {} + solver.results.graphics.contour["mf_co2"] = { + "field": "molef-co2", + "surfaces_list": ["int_fluid"], + } + solver.results.graphics.vector["molef_o2"] = {} + solver.results.graphics.vector["molef_o2"] = { + "field": "molef-o2", + "surfaces_list": ["int_fluid"], + } + solver.results.graphics.pathline["path_fuel"] = {} + solver.results.graphics.pathline["path_fuel"] = {"surfaces_list": ["vi-fuel"]} + solver.results.graphics.pathline["path_oxid"] = {} + solver.results.graphics.pathline["path_oxid"] = {"surfaces_list": ["vi-oxid"]} + solver.execute_tui(r"""/solve/monitors/residual/plot? yes """) + solver.execute_tui( + r"""/plot/residuals-set/plot-to-file "out/pro_species_s1.res" """ + ) + solver.execute_tui(r"""it 0 """) + solver.execute_tui( + r"""(define port (open-output-file "out/pro_species_s1_no.conv")) """ + ) + solver.execute_tui(r"""(write (%iterate 0) port) """) + solver.execute_tui(r"""(close-output-port port) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_turbulence.py b/tests/test_pro/test_pro_turbulence.py new file mode 100644 index 00000000000..8472d410b68 --- /dev/null +++ b/tests/test_pro/test_pro_turbulence.py @@ -0,0 +1,171 @@ +import os + +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.solve +@pytest.mark.fluent_231 +def test_pro_exp(launch_fluent_solver_3ddp_t2): + if not os.path.exists("out"): + os.mkdir("out") + solver = launch_fluent_solver_3ddp_t2 + input_type, input_name = download_input_file("pyfluent/elbow", "elbow.msh.h5") + solver.file.read(file_type=input_type, file_name=input_name) + solver.setup.models.energy = {"enabled": True} + solver.setup.boundary_conditions.velocity_inlet["hot-inlet"] = { + "vmag": 1.0, + "t": 350.0, + "turb_viscosity_ratio": 2, + } + solver.setup.boundary_conditions.velocity_inlet["cold-inlet"] = { + "vmag": 0.5, + "t": 301.0, + "turb_viscosity_ratio": 2, + } + solver.setup.models.viscous.model = "inviscid" + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=200) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["symmetry-xyplane"], + cell_report="pressure", + write_to_file=True, + file_name="out/pressure1.srp", + ) + solver.results.graphics.contour["contour-1"] = {} + solver.results.graphics.contour["contour-1"] = { + "surfaces_list": ["symmetry-xyplane"], + "field": "pressure", + } + solver.results.graphics.contour.display(object_name="contour-1") + solver.setup.models.viscous.model = "laminar" + solver.setup.models.viscous.options.low_pressure_boundary_slip = True + solver.setup.models.viscous.model = "spalart-allmaras" + solver.setup.models.viscous.options.corner_flow_correction = True + solver.setup.models.viscous.options.curvature_correction = True + solver.execute_tui( + r"""/define/models/viscous/corner-flow-correction-ccorner yes 0.9 """ + ) + solver.execute_tui( + r"""/define/models/viscous/curvature-correction-ccurv yes 0.9 """ + ) + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=200) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["symmetry-xyplane"], + cell_report="pressure", + write_to_file=True, + file_name="out/pressure2.srp", + ) + solver.results.graphics.contour["contour-2"] = {} + solver.results.graphics.contour["contour-2"] = { + "surfaces_list": ["symmetry-xyplane"], + "field": "pressure", + } + solver.results.graphics.contour.display(object_name="contour-2") + solver.execute_tui(r"""/define/models/viscous/spalart-allmaras? yes """) + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=200) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["symmetry-xyplane"], + cell_report="pressure", + write_to_file=True, + file_name="out/pressure3.srp", + ) + solver.results.graphics.contour["contour-3"] = {} + solver.results.graphics.contour["contour-3"] = { + "surfaces_list": ["symmetry-xyplane"], + "field": "pressure", + } + solver.results.graphics.contour.display(object_name="contour-3") + solver.setup.models.viscous.model = "k-omega" + solver.setup.models.viscous.k_omega_options.kw_low_re_correction = True + solver.setup.models.viscous.turbulence_expert.kato_launder_model = True + solver.setup.models.viscous.turbulence_expert.production_limiter.clip_factor = 9 + solver.setup.models.viscous.turbulence_expert.kw_vorticity_based_production = True + solver.execute_tui( + r"""/define/models/viscous/turbulence-expert/thermal-p-function? yes """ + ) + solver.setup.models.viscous.turbulence_expert.turb_non_newtonian = True + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=200) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["symmetry-xyplane"], + cell_report="pressure", + write_to_file=True, + file_name="out/pressure4.srp", + ) + solver.results.graphics.contour["contour-4"] = {} + solver.results.graphics.contour["contour-4"] = { + "surfaces_list": ["symmetry-xyplane"], + "field": "turb-kinetic-energy", + } + solver.results.graphics.contour.display(object_name="contour-4") + solver.setup.models.viscous.model = "k-omega" + solver.setup.models.viscous.k_omega_model = "sst" + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=200) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["symmetry-xyplane"], + cell_report="pressure", + write_to_file=True, + file_name="out/pressure5.srp", + ) + solver.results.graphics.contour["contour-5"] = {} + solver.results.graphics.contour["contour-5"] = { + "surfaces_list": ["symmetry-xyplane"], + "field": "turb-kinetic-energy", + } + solver.results.graphics.contour.display(object_name="contour-5") + solver.setup.models.viscous.model = "k-epsilon" + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=200) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["symmetry-xyplane"], + cell_report="pressure", + write_to_file=True, + file_name="out/pressure6.srp", + ) + solver.results.graphics.contour["contour-6"] = {} + solver.results.graphics.contour["contour-6"] = { + "surfaces_list": ["symmetry-xyplane"], + "field": "turb-kinetic-energy", + } + solver.results.graphics.contour.display(object_name="contour-6") + solver.setup.models.viscous.model = "k-epsilon" + solver.setup.models.viscous.k_epsilon_model = "realizable" + solver.setup.models.viscous.turbulence_expert.production_limiter.enable_prod_limiter = ( + True + ) + solver.setup.models.viscous.turbulence_expert.production_limiter.clip_factor = 0.8 + solver.setup.models.viscous.turbulence_expert.low_re_ke = True + solver.setup.models.viscous.turbulence_expert.low_re_ke = False + solver.setup.models.viscous.turbulence_expert.low_re_ke_index = 1 + solver.setup.models.viscous.turbulence_expert.non_newtonian_modification = True + solver.setup.models.viscous.near_wall_treatment.wall_function = ( + "non-equilibrium-wall-fn" + ) + solver.solution.initialization.standard_initialize() + solver.solution.run_calculation.iterate(number_of_iterations=200) + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["symmetry-xyplane"], + cell_report="pressure", + write_to_file=True, + file_name="out/pressure7.srp", + ) + solver.results.graphics.contour["contour-7"] = {} + solver.results.graphics.contour["contour-7"] = { + "surfaces_list": ["symmetry-xyplane"], + "field": "turb-kinetic-energy", + } + solver.results.graphics.contour.display(object_name="contour-7") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() diff --git a/tests/test_pro/test_pro_wtm.py b/tests/test_pro/test_pro_wtm.py new file mode 100644 index 00000000000..1af760cb4ef --- /dev/null +++ b/tests/test_pro/test_pro_wtm.py @@ -0,0 +1,485 @@ +import pytest +from util.fixture_fluent import download_input_file + + +@pytest.mark.mesh +@pytest.mark.fluent_231 +def test_pro_wtm_tet(new_watertight_workflow_session): + meshing = new_watertight_workflow_session + input_type, input_name = download_input_file("pyfluent/cylinder", "cylinder.agdb") + workflow = meshing.workflow + workflow.TaskObject["Import Geometry"].Arguments.setState( + { + r"FileName": r"%s" % input_name, + } + ) + workflow.TaskObject["Import Geometry"].Execute() + workflow.TaskObject["Add Local Sizing"].AddChildAndUpdate() + + workflow.TaskObject["Generate the Surface Mesh"].Arguments.setState( + { + r"SeparationRequired": r"Yes", + r"SurfaceMeshPreferences": { + r"ShowSurfaceMeshPreferences": False, + }, + } + ) + workflow.TaskObject["Generate the Surface Mesh"].Execute() + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=False) + workflow.TaskObject["Describe Geometry"].Arguments.setState( + { + r"SetupType": r"The geometry consists of only fluid regions with no voids", + } + ) + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=True) + workflow.TaskObject["Describe Geometry"].Execute() + assert workflow.TaskObject["Generate the Surface Mesh"].Arguments.getState() == { + "SeparationRequired": "Yes", + "SurfaceMeshPreferences": {"ShowSurfaceMeshPreferences": False}, + "OriginalZones": ["solid"], + "ExecuteShareTopology": "No", + } + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + } + ) + assert workflow.TaskObject["Update Boundaries"].Arguments.getState() == { + "OldBoundaryZoneTypeList": ["wall", "wall", "wall"], + "BoundaryZoneTypeList": ["pressure-outlet", "velocity-inlet", "wall"], + "BoundaryZoneList": ["outlet", "inlet", "wall"], + "OldBoundaryZoneList": ["solid:1:12", "solid:1:11", "solid:1"], + } + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + r"ZoneLocation": [ + r"3", + r"-1", + r"-0.998245", + r"10", + r"0.99225116", + r"0.99803305", + r"10", + r"solid:1:12", + r"-1", + r"-0.998245", + r"0", + r"0.99225116", + r"0.99803305", + r"0", + r"solid:1:11", + r"-1", + r"-0.99996799", + r"0", + r"0.99999988", + r"0.99995881", + r"10", + r"solid:1", + ], + } + ) + + workflow.TaskObject["Update Boundaries"].Execute() + workflow.TaskObject["Update Regions"].Arguments.setState( + { + r"OldRegionNameList": [r"solid"], + r"OldRegionTypeList": [r"fluid"], + r"RegionNameList": [r"fluid"], + r"RegionTypeList": [r"fluid"], + } + ) + workflow.TaskObject["Update Regions"].Execute() + assert workflow.TaskObject["Update Regions"].Arguments.getState() == { + "OldRegionNameList": ["solid"], + "RegionNameList": ["fluid"], + "RegionTypeList": ["fluid"], + "OldRegionTypeList": ["fluid"], + } + workflow.TaskObject["Add Boundary Layers"].Arguments.setState( + { + r"LocalPrismPreferences": { + r"Continuous": r"Stair Step", + }, + } + ) + workflow.TaskObject["Add Boundary Layers"].AddChildAndUpdate() + workflow.TaskObject["Generate the Volume Mesh"].Arguments.setState( + { + r"VolumeFill": r"tetrahedral", + } + ) + workflow.TaskObject["Generate the Volume Mesh"].Execute() + meshing.execute_tui(r"""/mesh/check-mesh """) + solver = meshing.switch_to_solver() + solver.setup.models.energy = {"enabled": True} + solver.setup.models.viscous.model = "k-epsilon" + solver.setup.boundary_conditions.velocity_inlet["inlet"] = {"vmag": 1.0} + solver.mesh.check() + solver.solution.initialization.hybrid_initialize() + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["inlet"], + cell_report="velocity-magnitude", + write_to_file=True, + file_name="wtm_tet_s2.srp", + ) + solver.solution.run_calculation.iter_count = 10 + solver.solution.run_calculation.iterate(number_of_iterations=10) + solver.file.write(file_type="case-data", file_name="wtm_tet_s2.cas.h5") + solver.file.read(file_type="case-data", file_name="wtm_tet_s2.cas.h5") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() + + +@pytest.mark.mesh +@pytest.mark.fluent_231 +def test_pro_wtm_hex(new_watertight_workflow_session): + meshing = new_watertight_workflow_session + input_type, input_name = download_input_file("pyfluent/cylinder", "cylinder.agdb") + workflow = meshing.workflow + workflow.TaskObject["Import Geometry"].Arguments.setState( + { + r"FileName": r"%s" % input_name, + } + ) + workflow.TaskObject["Import Geometry"].Execute() + workflow.TaskObject["Add Local Sizing"].AddChildAndUpdate() + workflow.TaskObject["Generate the Surface Mesh"].Arguments.setState( + { + r"SeparationRequired": r"Yes", + } + ) + workflow.TaskObject["Generate the Surface Mesh"].Execute() + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=False) + workflow.TaskObject["Describe Geometry"].Arguments.setState( + { + r"SetupType": r"The geometry consists of only fluid regions with no voids", + } + ) + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=True) + workflow.TaskObject["Describe Geometry"].Execute() + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + } + ) + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + r"ZoneLocation": [ + r"3", + r"-1", + r"-0.998245", + r"10", + r"0.99225116", + r"0.99803305", + r"10", + r"solid:1:12", + r"-1", + r"-0.998245", + r"0", + r"0.99225116", + r"0.99803305", + r"0", + r"solid:1:11", + r"-1", + r"-0.99996799", + r"0", + r"0.99999988", + r"0.99995881", + r"10", + r"solid:1", + ], + } + ) + workflow.TaskObject["Update Boundaries"].Execute() + workflow.TaskObject["Update Regions"].Arguments.setState( + { + r"OldRegionNameList": [r"solid"], + r"OldRegionTypeList": [r"fluid"], + r"RegionNameList": [r"fluid"], + r"RegionTypeList": [r"fluid"], + } + ) + workflow.TaskObject["Update Regions"].Execute() + workflow.TaskObject["Add Boundary Layers"].Arguments.setState( + { + r"LocalPrismPreferences": { + r"Continuous": r"Stair Step", + }, + } + ) + workflow.TaskObject["Add Boundary Layers"].AddChildAndUpdate() + workflow.TaskObject["Generate the Volume Mesh"].Arguments.setState( + { + r"PrismPreferences": { + r"PrismAdjacentAngle": 80, + }, + r"VolumeFill": r"hexcore", + } + ) + workflow.TaskObject["Generate the Volume Mesh"].Execute() + meshing.execute_tui(r"""/mesh/check-mesh """) + solver = meshing.switch_to_solver() + solver.setup.models.energy = {"enabled": True} + solver.setup.models.viscous.model = "k-epsilon" + solver.setup.boundary_conditions.velocity_inlet["inlet"] = {"vmag": 1.0} + solver.mesh.check() + solver.solution.initialization.hybrid_initialize() + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["inlet"], + cell_report="velocity-magnitude", + write_to_file=True, + file_name="wtm_hex_s4.srp", + ) + solver.solution.run_calculation.iter_count = 10 + solver.solution.run_calculation.iterate(number_of_iterations=10) + solver.file.write(file_type="case-data", file_name="wtm_hex_s4.cas.h5") + solver.file.read(file_type="case-data", file_name="wtm_hex_s4.cas.h5") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() + + +@pytest.mark.mesh +@pytest.mark.fluent_231 +def test_pro_wtm_poly(new_watertight_workflow_session): + meshing = new_watertight_workflow_session + input_type, input_name = download_input_file("pyfluent/cylinder", "cylinder.agdb") + workflow = meshing.workflow + workflow.TaskObject["Import Geometry"].Arguments.setState( + { + r"FileName": r"%s" % input_name, + } + ) + workflow.TaskObject["Import Geometry"].Execute() + workflow.TaskObject["Add Local Sizing"].AddChildAndUpdate() + workflow.TaskObject["Generate the Surface Mesh"].Arguments.setState( + { + r"SeparationRequired": r"Yes", + } + ) + workflow.TaskObject["Generate the Surface Mesh"].Execute() + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=False) + workflow.TaskObject["Describe Geometry"].Arguments.setState( + { + r"SetupType": r"The geometry consists of only fluid regions with no voids", + } + ) + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=True) + workflow.TaskObject["Describe Geometry"].Execute() + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + } + ) + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + r"ZoneLocation": [ + r"3", + r"-1", + r"-0.998245", + r"10", + r"0.99225116", + r"0.99803305", + r"10", + r"solid:1:12", + r"-1", + r"-0.998245", + r"0", + r"0.99225116", + r"0.99803305", + r"0", + r"solid:1:11", + r"-1", + r"-0.99996799", + r"0", + r"0.99999988", + r"0.99995881", + r"10", + r"solid:1", + ], + } + ) + workflow.TaskObject["Update Boundaries"].Execute() + workflow.TaskObject["Update Regions"].Arguments.setState( + { + r"OldRegionNameList": [r"solid"], + r"OldRegionTypeList": [r"fluid"], + r"RegionNameList": [r"fluid"], + r"RegionTypeList": [r"fluid"], + } + ) + workflow.TaskObject["Update Regions"].Execute() + workflow.TaskObject["Add Boundary Layers"].Arguments.setState( + { + r"LocalPrismPreferences": { + r"Continuous": r"Stair Step", + }, + } + ) + workflow.TaskObject["Add Boundary Layers"].AddChildAndUpdate() + workflow.TaskObject["Generate the Volume Mesh"].Execute() + meshing.execute_tui(r"""/mesh/check-mesh """) + solver = meshing.switch_to_solver() + solver.setup.models.energy = {"enabled": True} + solver.setup.models.viscous.model = "k-epsilon" + solver.setup.boundary_conditions.velocity_inlet["inlet"] = {"vmag": 1.0} + solver.mesh.check() + solver.solution.initialization.hybrid_initialize() + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["inlet"], + cell_report="velocity-magnitude", + write_to_file=True, + file_name="wtm_poly_s3.srp", + ) + solver.solution.run_calculation.iter_count = 10 + solver.solution.run_calculation.iterate(number_of_iterations=10) + solver.file.write(file_type="case-data", file_name="wtm_poly_s3.cas.h5") + solver.file.read(file_type="case-data", file_name="wtm_poly_s3.cas.h5") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit() + + +@pytest.mark.mesh +@pytest.mark.fluent_231 +def test_pro_wtm_polyhexcore(new_watertight_workflow_session): + meshing = new_watertight_workflow_session + input_type, input_name = download_input_file("pyfluent/cylinder", "cylinder.agdb") + workflow = meshing.workflow + workflow.TaskObject["Import Geometry"].Arguments.setState( + { + r"FileName": r"%s" % input_name, + } + ) + workflow.TaskObject["Import Geometry"].Execute() + workflow.TaskObject["Add Local Sizing"].AddChildAndUpdate() + workflow.TaskObject["Generate the Surface Mesh"].Arguments.setState( + { + r"SeparationRequired": r"Yes", + } + ) + workflow.TaskObject["Generate the Surface Mesh"].Execute() + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=False) + workflow.TaskObject["Describe Geometry"].Arguments.setState( + { + r"SetupType": r"The geometry consists of only fluid regions with no voids", + } + ) + workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=True) + workflow.TaskObject["Describe Geometry"].Execute() + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + } + ) + workflow.TaskObject["Update Boundaries"].Arguments.setState( + { + r"BoundaryZoneList": [r"outlet", r"inlet", r"wall"], + r"BoundaryZoneTypeList": [r"pressure-outlet", r"velocity-inlet", r"wall"], + r"OldBoundaryZoneList": [r"solid:1:12", r"solid:1:11", r"solid:1"], + r"OldBoundaryZoneTypeList": [r"wall", r"wall", r"wall"], + r"ZoneLocation": [ + r"3", + r"-1", + r"-0.998245", + r"10", + r"0.99225116", + r"0.99803305", + r"10", + r"solid:1:12", + r"-1", + r"-0.998245", + r"0", + r"0.99225116", + r"0.99803305", + r"0", + r"solid:1:11", + r"-1", + r"-0.99996799", + r"0", + r"0.99999988", + r"0.99995881", + r"10", + r"solid:1", + ], + } + ) + workflow.TaskObject["Update Boundaries"].Execute() + workflow.TaskObject["Update Regions"].Arguments.setState( + { + r"OldRegionNameList": [r"solid"], + r"OldRegionTypeList": [r"fluid"], + r"RegionNameList": [r"fluid"], + r"RegionTypeList": [r"fluid"], + } + ) + workflow.TaskObject["Update Regions"].Execute() + workflow.TaskObject["Add Boundary Layers"].Arguments.setState( + { + r"LocalPrismPreferences": { + r"Continuous": r"Stair Step", + }, + } + ) + workflow.TaskObject["Add Boundary Layers"].AddChildAndUpdate() + workflow.TaskObject["Generate the Volume Mesh"].Arguments.setState( + { + r"PrismPreferences": { + r"ShowPrismPreferences": False, + }, + r"VolumeFill": r"poly-hexcore", + r"VolumeMeshPreferences": { + r"ShowVolumeMeshPreferences": False, + }, + } + ) + workflow.TaskObject["Generate the Volume Mesh"].Execute() + meshing.execute_tui(r"""/mesh/check-mesh """) + solver = meshing.switch_to_solver() + solver.setup.models.energy = {"enabled": True} + solver.setup.models.viscous.model = "k-epsilon" + solver.setup.boundary_conditions.velocity_inlet["inlet"] = {"vmag": 1.0} + solver.mesh.check() + solver.solution.initialization.hybrid_initialize() + solver.results.report.report_menu.surface_integrals( + report_type="area-weighted-avg", + surface_id=["inlet"], + cell_report="velocity-magnitude", + write_to_file=True, + file_name="wtm_poly_hexcore_s1.srp", + ) + solver.solution.run_calculation.iter_count = 10 + solver.solution.run_calculation.iterate(number_of_iterations=10) + solver.file.write(file_type="case-data", file_name="wtm_poly_hexcore_s1.cas.h5") + solver.file.read(file_type="case-data", file_name="wtm_poly_hexcore_s1.cas.h5") + solver.execute_tui(r"""(proc-stats) """) + solver.execute_tui(r"""(display "testing finished") """) + solver.exit()