From 8899c80d63a227857fbc0d87b033dc60742a7239 Mon Sep 17 00:00:00 2001 From: hpohekar Date: Wed, 4 Jun 2025 17:53:02 +0530 Subject: [PATCH 1/2] docs: Update solver and meshing in examples [skip tests] --- examples/00-fluent/DOE_ML.py | 20 +- examples/00-fluent/conjugate_heat_transfer.py | 254 ++++++++++-------- .../00-fluent/exhaust_system_settings_api.py | 94 +++---- .../00-fluent/external_compressible_flow.py | 50 ++-- examples/00-fluent/frozen_rotor_workflow.py | 110 ++++---- examples/00-fluent/lunar_lander_thermal.py | 56 ++-- .../00-fluent/mixing_elbow_settings_api.py | 40 +-- examples/00-fluent/mixing_tank_workflow.py | 108 +++++--- examples/00-fluent/modeling_ablation.py | 174 ++++++------ examples/00-fluent/modeling_cavitation.py | 64 ++--- examples/00-fluent/radiation_headlamp.py | 92 ++++--- examples/00-fluent/species_transport.py | 96 +++---- 12 files changed, 622 insertions(+), 536 deletions(-) diff --git a/examples/00-fluent/DOE_ML.py b/examples/00-fluent/DOE_ML.py index 075158c2db82..52f2f72f660c 100644 --- a/examples/00-fluent/DOE_ML.py +++ b/examples/00-fluent/DOE_ML.py @@ -86,19 +86,19 @@ # Launch Fluent session with solver mode and print Fluent version # =============================================================== -solver = pyfluent.launch_fluent( +solver_session = pyfluent.launch_fluent( precision="double", processor_count=2, version="3d", ) -print(solver.get_fluent_version()) +print(solver_session.get_fluent_version()) ############################################################################# # Read case # ========= -solver.settings.file.read_case(file_name=import_filename) +solver_session.settings.file.read_case(file_name=import_filename) ############################################################################################## # Design of Experiments @@ -113,21 +113,21 @@ for idx1, coldVel in np.ndenumerate(coldVelArr): for idx2, hotVel in np.ndenumerate(hotVelArr): - cold_inlet = solver.settings.setup.boundary_conditions.velocity_inlet[ + cold_inlet = solver_session.settings.setup.boundary_conditions.velocity_inlet[ "cold-inlet" ] cold_inlet.momentum.velocity.value = coldVel - hot_inlet = solver.settings.setup.boundary_conditions.velocity_inlet[ + hot_inlet = solver_session.settings.setup.boundary_conditions.velocity_inlet[ "hot-inlet" ] hot_inlet.momentum.velocity.value = hotVel - solver.settings.solution.initialization.initialization_type = "standard" - solver.settings.solution.initialization.standard_initialize() - solver.settings.solution.run_calculation.iterate(iter_count=200) + solver_session.settings.solution.initialization.initialization_type = "standard" + solver_session.settings.solution.initialization.standard_initialize() + solver_session.settings.solution.run_calculation.iterate(iter_count=200) - res_tui = solver.scheme.exec( + res_tui = solver_session.scheme.exec( ( "(ti-menu-load-string " '"/report/surface-integrals/mass-weighted-avg outlet () ' @@ -141,7 +141,7 @@ # Close the session # ================= -solver.exit() +solver_session.exit() #################################### # Plot Response Surface using Plotly diff --git a/examples/00-fluent/conjugate_heat_transfer.py b/examples/00-fluent/conjugate_heat_transfer.py index 43cc622387bf..228c48f5bace 100644 --- a/examples/00-fluent/conjugate_heat_transfer.py +++ b/examples/00-fluent/conjugate_heat_transfer.py @@ -71,27 +71,29 @@ # Launch Fluent session with meshing mode and print Fluent version # ================================================================ -meshing = pyfluent.launch_fluent( +meshing_session = pyfluent.launch_fluent( mode="meshing", dimension=3, precision="double", processor_count=4, ) -print(meshing.get_fluent_version()) +print(meshing_session.get_fluent_version()) ############################################################################# # Start Watertight Geometry Meshing Workflow # ========================================== -meshing.workflow.InitializeWorkflow(WorkflowType=r"Watertight Geometry") +meshing_session.workflow.InitializeWorkflow(WorkflowType=r"Watertight Geometry") -meshing.workflow.TaskObject["Import Geometry"].Arguments = dict(FileName=geom_filename) +meshing_session.workflow.TaskObject["Import Geometry"].Arguments = dict( + FileName=geom_filename +) -meshing.workflow.TaskObject["Import Geometry"].Execute() +meshing_session.workflow.TaskObject["Import Geometry"].Execute() -meshing.workflow.TaskObject["Add Local Sizing"].Execute() +meshing_session.workflow.TaskObject["Add Local Sizing"].Execute() -meshing.workflow.TaskObject["Generate the Surface Mesh"].Arguments = dict( +meshing_session.workflow.TaskObject["Generate the Surface Mesh"].Arguments = dict( { "CFDSurfaceMeshControls": { "MinSize": 0.3, @@ -100,10 +102,12 @@ }, } ) -meshing.workflow.TaskObject["Generate the Surface Mesh"].Execute() +meshing_session.workflow.TaskObject["Generate the Surface Mesh"].Execute() -meshing.workflow.TaskObject["Describe Geometry"].UpdateChildTasks(SetupTypeChanged=True) -meshing.workflow.TaskObject["Describe Geometry"].Arguments.setState( +meshing_session.workflow.TaskObject["Describe Geometry"].UpdateChildTasks( + SetupTypeChanged=True +) +meshing_session.workflow.TaskObject["Describe Geometry"].Arguments.setState( { r"CappingRequired": r"No", r"InvokeShareTopology": r"No", @@ -112,13 +116,13 @@ } ) -meshing.workflow.TaskObject["Describe Geometry"].Execute() +meshing_session.workflow.TaskObject["Describe Geometry"].Execute() ############################################################################# # Update Interface Boundaries; Create Region # ========================================== -meshing.workflow.TaskObject["Update Boundaries"].Arguments.setState( +meshing_session.workflow.TaskObject["Update Boundaries"].Arguments.setState( { r"BoundaryLabelList": [ r"interface-out-solid-a", @@ -325,19 +329,21 @@ } ) -meshing.workflow.TaskObject["Update Boundaries"].Execute() +meshing_session.workflow.TaskObject["Update Boundaries"].Execute() -meshing.workflow.TaskObject["Create Regions"].Execute() +meshing_session.workflow.TaskObject["Create Regions"].Execute() ############################################################################# # Custom Journal for Creating Periodicity due to Non-Conformal Objects # ==================================================================== -meshing.workflow.TaskObject["Describe Geometry"].InsertNextTask( +meshing_session.workflow.TaskObject["Describe Geometry"].InsertNextTask( CommandName=r"RunCustomJournal" ) -meshing.workflow.TaskObject["Run Custom Journal"].Rename(NewName=r"set-periodicity") -meshing.workflow.TaskObject["set-periodicity"].Arguments = dict( +meshing_session.workflow.TaskObject["Run Custom Journal"].Rename( + NewName=r"set-periodicity" +) +meshing_session.workflow.TaskObject["set-periodicity"].Arguments = dict( { r"JournalString": r"""/bo rps translational semi-auto periodic-1-high periodic-2-high periodic-3-high periodic-4-high , 0 0 -2.3 /bo rps translational semi-auto periodic-5* , 0 0 -2.3 @@ -347,18 +353,20 @@ } ) -meshing.workflow.TaskObject["set-periodicity"].Execute() +meshing_session.workflow.TaskObject["set-periodicity"].Execute() ############################################################################# # Update Boundary Layer Task # ========================== -meshing.workflow.TaskObject["Update Regions"].Execute() -meshing.workflow.TaskObject["Add Boundary Layers"].AddChildToTask() -meshing.workflow.TaskObject["Add Boundary Layers"].InsertCompoundChildTask() -meshing.workflow.TaskObject["smooth-transition_1"].Rename(NewName=r"aspect-ratio_1") +meshing_session.workflow.TaskObject["Update Regions"].Execute() +meshing_session.workflow.TaskObject["Add Boundary Layers"].AddChildToTask() +meshing_session.workflow.TaskObject["Add Boundary Layers"].InsertCompoundChildTask() +meshing_session.workflow.TaskObject["smooth-transition_1"].Rename( + NewName=r"aspect-ratio_1" +) -meshing.workflow.TaskObject["aspect-ratio_1"].Arguments.setState( +meshing_session.workflow.TaskObject["aspect-ratio_1"].Arguments.setState( { "BLControlName": r"aspect-ratio_1", "BLRegionList": [ @@ -403,23 +411,23 @@ } ) -meshing.workflow.TaskObject["aspect-ratio_1"].Execute() +meshing_session.workflow.TaskObject["aspect-ratio_1"].Execute() ############################################################################# # Generate Mesh # ============= -meshing.workflow.TaskObject["Generate the Volume Mesh"].Execute() +meshing_session.workflow.TaskObject["Generate the Volume Mesh"].Execute() ############################################################################# # Improve Volume Mesh # =================== -meshing.workflow.TaskObject["Generate the Volume Mesh"].InsertNextTask( +meshing_session.workflow.TaskObject["Generate the Volume Mesh"].InsertNextTask( CommandName=r"ImproveVolumeMesh" ) -meshing.workflow.TaskObject["Improve Volume Mesh"].Arguments.setState( +meshing_session.workflow.TaskObject["Improve Volume Mesh"].Arguments.setState( { r"CellQualityLimit": 0.05, r"VMImprovePreferences": { @@ -431,38 +439,38 @@ } ) -meshing.workflow.TaskObject["Improve Volume Mesh"].Execute() +meshing_session.workflow.TaskObject["Improve Volume Mesh"].Execute() ############################################################################# # Save Mesh File # ============== save_mesh_as = str(Path(pyfluent.EXAMPLES_PATH) / "hx-fin-2mm.msh.h5") -meshing.tui.file.write_mesh(save_mesh_as) +meshing_session.tui.file.write_mesh(save_mesh_as) ############################################################################# # Switch to Solution Mode # ======================= -solver = meshing.switch_to_solver() +solver_session = meshing_session.switch_to_solver() ############################################################################# # Auto-create Mesh Interfaces # =========================== -solver.tui.define.mesh_interfaces.create("int", "yes", "no") +solver_session.tui.define.mesh_interfaces.create("int", "yes", "no") ############################################################################# # Mesh Check; Review Fluent transcript for errors # =============================================== -solver.mesh.check() +solver_session.mesh.check() ############################################################################# # Create a few boundary list for display and post-processing # ========================================================== -mesh1 = Mesh(solver=solver) +mesh1 = Mesh(solver=solver_session) wall_list = [] periodic_list = [] @@ -500,66 +508,66 @@ # * Enable Energy Equation # * Enable Laminar Viscous Model -solver.setup.general.units.set_units( - quantity="temperature", units_name="c", scale_factor=1.0, offset=0.0 +solver_session.setup.general.units.set_units( + quantity="temperature", units_name="C", scale_factor=1.0, offset=273.15 ) -solver.setup.models.energy.enabled = True -solver.setup.models.viscous.model.set_state("laminar") +solver_session.setup.models.energy.enabled = True +solver_session.setup.models.viscous.model.set_state("laminar") ############################################################################# # Change a few material properties of default Air # =============================================== -air_dict = solver.setup.materials.fluid["air"].get_state() +air_dict = solver_session.setup.materials.fluid["air"].get_state() air_dict["density"]["value"] = 1.2 air_dict["viscosity"]["value"] = 1.5e-5 air_dict["thermal_conductivity"]["value"] = 0.026 air_dict["specific_heat"]["value"] = 1006.0 -solver.setup.materials.fluid["air"].set_state(air_dict) +solver_session.setup.materials.fluid["air"].set_state(air_dict) ############################################################################# # Change a few material properties of default Aluminum # ==================================================== -al_dict = solver.setup.materials.solid["aluminum"].get_state() +al_dict = solver_session.setup.materials.solid["aluminum"].get_state() al_dict["density"]["value"] = 2719.0 al_dict["thermal_conductivity"]["value"] = 200.0 al_dict["specific_heat"]["value"] = 871.0 -solver.setup.materials.solid["aluminum"].set_state(al_dict) +solver_session.setup.materials.solid["aluminum"].set_state(al_dict) ############################################################################# # Copy Copper and change a few material properties of default Copper # ================================================================== -solver.setup.materials.database.copy_by_name(type="solid", name="copper") -cu_dict = solver.setup.materials.solid["copper"].get_state() +solver_session.setup.materials.database.copy_by_name(type="solid", name="copper") +cu_dict = solver_session.setup.materials.solid["copper"].get_state() cu_dict["density"]["value"] = 8978.0 cu_dict["thermal_conductivity"]["value"] = 340.0 cu_dict["specific_heat"]["value"] = 381.0 -solver.setup.materials.solid["copper"].set_state(cu_dict) +solver_session.setup.materials.solid["copper"].set_state(cu_dict) ############################################################################# # Set Tube Cell Zone Material as Copper # ===================================== -tube_dict = solver.setup.cell_zone_conditions.solid["solid-tube-1"].get_state() +tube_dict = solver_session.setup.cell_zone_conditions.solid["solid-tube-1"].get_state() tube_dict["material"] = "copper" -solver.setup.cell_zone_conditions.solid["solid-tube-1"].set_state(tube_dict) +solver_session.setup.cell_zone_conditions.solid["solid-tube-1"].set_state(tube_dict) -tube_dict = solver.setup.cell_zone_conditions.solid["solid-tube-2"].get_state() +tube_dict = solver_session.setup.cell_zone_conditions.solid["solid-tube-2"].get_state() tube_dict["material"] = "copper" -solver.setup.cell_zone_conditions.solid["solid-tube-2"].set_state(tube_dict) +solver_session.setup.cell_zone_conditions.solid["solid-tube-2"].set_state(tube_dict) ############################################################################# # Set Boundary Condition for Inlet and Outlet # =========================================== -solver.setup.boundary_conditions.velocity_inlet["inlet"].momentum.velocity = 4.0 -solver.setup.boundary_conditions.velocity_inlet["inlet"].thermal.temperature = ( +solver_session.setup.boundary_conditions.velocity_inlet["inlet"].momentum.velocity = 4.0 +solver_session.setup.boundary_conditions.velocity_inlet["inlet"].thermal.temperature = ( 293.15 # Need to specify in Kelvin ) -solver.setup.boundary_conditions.pressure_outlet[ +solver_session.setup.boundary_conditions.pressure_outlet[ "outlet" ].thermal.backflow_total_temperature = 293.15 @@ -567,61 +575,71 @@ # Set Thermal Boundary Condition for Wall Inner Tube # ================================================== -solver.setup.boundary_conditions.wall["wall-inner-tube-1"].thermal.thermal_condition = ( - "Convection" -) -solver.setup.boundary_conditions.wall[ +solver_session.setup.boundary_conditions.wall[ + "wall-inner-tube-1" +].thermal.thermal_condition = "Convection" +solver_session.setup.boundary_conditions.wall[ "wall-inner-tube-1" ].thermal.heat_transfer_coeff = 1050.0 -solver.setup.boundary_conditions.wall["wall-inner-tube-1"].thermal.free_stream_temp = ( - 353.15 -) +solver_session.setup.boundary_conditions.wall[ + "wall-inner-tube-1" +].thermal.free_stream_temp = 353.15 -solver.setup.boundary_conditions.copy(from_="wall-inner-tube-1", to="wall-inner-tube-2") +solver_session.setup.boundary_conditions.copy( + from_="wall-inner-tube-1", to="wall-inner-tube-2" +) ############################################################################# # Enable HOTR # =========== -solver.solution.methods.high_order_term_relaxation.enable = True +solver_session.solution.methods.high_order_term_relaxation.enable = True ############################################################################# # Define Report Definitions # ========================= -solver.solution.report_definitions.surface["outlet-enthalpy-flow"] = {} -solver.solution.report_definitions.surface["outlet-enthalpy-flow"].report_type = ( - "surface-flowrate" +solver_session.solution.report_definitions.surface["outlet-enthalpy-flow"] = {} +solver_session.solution.report_definitions.surface[ + "outlet-enthalpy-flow" +].report_type = "surface-flowrate" +solver_session.solution.report_definitions.surface["outlet-enthalpy-flow"].field = ( + "enthalpy" ) -solver.solution.report_definitions.surface["outlet-enthalpy-flow"].field = "enthalpy" -solver.solution.report_definitions.surface["outlet-enthalpy-flow"].surface_names = [ - "outlet" -] +solver_session.solution.report_definitions.surface[ + "outlet-enthalpy-flow" +].surface_names = ["outlet"] -solver.solution.report_definitions.surface["avg-pressure-inlet"] = {} -solver.solution.report_definitions.surface["avg-pressure-inlet"].report_type = ( +solver_session.solution.report_definitions.surface["avg-pressure-inlet"] = {} +solver_session.solution.report_definitions.surface["avg-pressure-inlet"].report_type = ( "surface-areaavg" ) -solver.solution.report_definitions.surface["avg-pressure-inlet"].field = "pressure" -solver.solution.report_definitions.surface["avg-pressure-inlet"].surface_names = [ - "inlet" -] +solver_session.solution.report_definitions.surface["avg-pressure-inlet"].field = ( + "pressure" +) +solver_session.solution.report_definitions.surface[ + "avg-pressure-inlet" +].surface_names = ["inlet"] -solver.solution.report_definitions.volume["max-vel-louvers4"] = {} -solver.solution.report_definitions.volume["max-vel-louvers4"].report_type = "volume-max" -solver.solution.report_definitions.volume["max-vel-louvers4"].field = ( +solver_session.solution.report_definitions.volume["max-vel-louvers4"] = {} +solver_session.solution.report_definitions.volume["max-vel-louvers4"].report_type = ( + "volume-max" +) +solver_session.solution.report_definitions.volume["max-vel-louvers4"].field = ( "velocity-magnitude" ) -solver.solution.report_definitions.volume["max-vel-louvers4"].cell_zones = [ +solver_session.solution.report_definitions.volume["max-vel-louvers4"].cell_zones = [ "fluid-tet-4" ] -solver.solution.report_definitions.surface["wall-shear-int"] = {} -solver.solution.report_definitions.surface["wall-shear-int"].report_type = ( +solver_session.solution.report_definitions.surface["wall-shear-int"] = {} +solver_session.solution.report_definitions.surface["wall-shear-int"].report_type = ( "surface-integral" ) -solver.solution.report_definitions.surface["wall-shear-int"].field = "wall-shear" -solver.solution.report_definitions.surface["wall-shear-int"].surface_names = [ +solver_session.solution.report_definitions.surface["wall-shear-int"].field = ( + "wall-shear" +) +solver_session.solution.report_definitions.surface["wall-shear-int"].surface_names = [ "wall-fluid-sweep-fin-solid-sweep-fin-shadow", "wall-fluid-tet-1-solid-tet-1", "wall-fluid-tet-2-solid-tet-2", @@ -629,46 +647,46 @@ "wall-fluid-tet-4-solid-tet-4", ] -solver.solution.monitor.report_plots.create(name="outlet-enthalpy-flow-plot") -solver.solution.monitor.report_plots["outlet-enthalpy-flow-plot"].report_defs = ( - "outlet-enthalpy-flow" -) +solver_session.solution.monitor.report_plots.create(name="outlet-enthalpy-flow-plot") +solver_session.solution.monitor.report_plots[ + "outlet-enthalpy-flow-plot" +].report_defs = "outlet-enthalpy-flow" -solver.solution.monitor.report_files["outlet-enthalpy-flow-file"] = {} -solver.solution.monitor.report_files["outlet-enthalpy-flow-file"] = { +solver_session.solution.monitor.report_files["outlet-enthalpy-flow-file"] = {} +solver_session.solution.monitor.report_files["outlet-enthalpy-flow-file"] = { "report_defs": ["outlet-enthalpy-flow"], "file_name": r"outlet-enthalpy-flow.out", } -solver.solution.monitor.report_plots["avg-pressure-inlet-plot"] = {} -solver.solution.monitor.report_plots["avg-pressure-inlet-plot"] = { +solver_session.solution.monitor.report_plots["avg-pressure-inlet-plot"] = {} +solver_session.solution.monitor.report_plots["avg-pressure-inlet-plot"] = { "report_defs": ["avg-pressure-inlet"] } -solver.solution.monitor.report_files["avg-pressure-inlet-file"] = {} -solver.solution.monitor.report_files["avg-pressure-inlet-file"] = { +solver_session.solution.monitor.report_files["avg-pressure-inlet-file"] = {} +solver_session.solution.monitor.report_files["avg-pressure-inlet-file"] = { "report_defs": ["avg-pressure-inlet"], "file_name": r"avg-pressure-inlet.out", } -solver.solution.monitor.report_plots["max-vel-louvers4-plot"] = {} -solver.solution.monitor.report_plots["max-vel-louvers4-plot"] = { +solver_session.solution.monitor.report_plots["max-vel-louvers4-plot"] = {} +solver_session.solution.monitor.report_plots["max-vel-louvers4-plot"] = { "report_defs": ["max-vel-louvers4"] } -solver.solution.monitor.report_files["max-vel-louvers4-file"] = {} -solver.solution.monitor.report_files["max-vel-louvers4-file"] = { +solver_session.solution.monitor.report_files["max-vel-louvers4-file"] = {} +solver_session.solution.monitor.report_files["max-vel-louvers4-file"] = { "report_defs": ["max-vel-louvers4"], "file_name": r"max-vel-louvers4.out", } -solver.solution.monitor.report_plots["wall-shear-int-plot"] = {} -solver.solution.monitor.report_plots["wall-shear-int-plot"] = { +solver_session.solution.monitor.report_plots["wall-shear-int-plot"] = {} +solver_session.solution.monitor.report_plots["wall-shear-int-plot"] = { "report_defs": ["wall-shear-int"] } -solver.solution.monitor.report_files["wall-shear-int-file"] = {} -solver.solution.monitor.report_files["wall-shear-int-file"] = { +solver_session.solution.monitor.report_files["wall-shear-int-file"] = {} +solver_session.solution.monitor.report_files["wall-shear-int-file"] = { "report_defs": ["wall-shear-int"], "file_name": r"wall-shear-int.out", } @@ -677,38 +695,38 @@ # Hybrid Initialization; Slit Interior between Solid Zones; Save Case # =================================================================== -solver.solution.initialization.initialization_type = "hybrid" -solver.solution.initialization.hybrid_initialize() +solver_session.solution.initialization.initialization_type = "hybrid" +solver_session.solution.initialization.hybrid_initialize() -solver.setup.boundary_conditions.slit_interior_between_diff_solids() -solver.file.write(file_type="case", file_name="hx-fin-2mm.cas.h5") +solver_session.setup.boundary_conditions.slit_interior_between_diff_solids() +solver_session.file.write(file_type="case", file_name="hx-fin-2mm.cas.h5") ############################################################################# # Set Aggressive Length Scale Method; Run Calculation & Save Data # =============================================================== -solver.solution.run_calculation.pseudo_time_settings.time_step_method.time_step_method = ( +solver_session.solution.run_calculation.pseudo_time_settings.time_step_method.time_step_method = ( "automatic" ) -solver.solution.run_calculation.pseudo_time_settings.time_step_method.length_scale_methods = ( +solver_session.solution.run_calculation.pseudo_time_settings.time_step_method.length_scale_methods = ( "aggressive" ) -solver.solution.run_calculation.iterate(iter_count=250) +solver_session.solution.run_calculation.iterate(iter_count=250) -solver.file.write(file_type="case-data", file_name="hx-fin-2mm.dat.h5") +solver_session.file.write(file_type="case-data", file_name="hx-fin-2mm.dat.h5") ############################################################################# # Post-Processing Mass Balance Report # =================================== -inlet_mfr = solver.scheme.exec( +inlet_mfr = solver_session.scheme.exec( ('(ti-menu-load-string "/report/fluxes/mass-flow no inlet () no")',) ).split(" ")[-1] -outlet_mfr = solver.scheme.exec( +outlet_mfr = solver_session.scheme.exec( ('(ti-menu-load-string "/report/fluxes/mass-flow no outlet () no")',) ).split(" ")[-1] -net_mfr = solver.scheme.exec( +net_mfr = solver_session.scheme.exec( ('(ti-menu-load-string "/report/fluxes/mass-flow no inlet outlet () no")',) ).split(" ")[-1] print("Mass Balance Report\n") @@ -720,7 +738,7 @@ # Heat Balance Report # =================== -htr = solver.scheme.exec( +htr = solver_session.scheme.exec( ('(ti-menu-load-string "/report/fluxes/heat-transfer yes no")',) ).split(" ")[-1] print("Heat Balance Report\n") @@ -780,7 +798,7 @@ # Contour Plot # ============ -contour1 = Contour(solver=solver, field="temperature", surfaces=wall_list) +contour1 = Contour(solver=solver_session, field="temperature", surfaces=wall_list) window2 = GraphicsWindow() window2.add_graphics(contour1) window2.show() @@ -812,15 +830,15 @@ # Create Iso-Surface of X=0.012826 m # ================================== -solver.results.surfaces.iso_surface["x=0.012826"] = {} -solver.results.surfaces.iso_surface["x=0.012826"].field = "x-coordinate" -solver.results.surfaces.iso_surface["x=0.012826"] = {"iso_values": [0.012826]} +solver_session.results.surfaces.iso_surface["x=0.012826"] = {} +solver_session.results.surfaces.iso_surface["x=0.012826"].field = "x-coordinate" +solver_session.results.surfaces.iso_surface["x=0.012826"] = {"iso_values": [0.012826]} ############################################################################# # Vecotor Plot # ============ -vector1 = Vector(solver=solver, surfaces=["x=0.012826"], scale=2.0, skip=5) +vector1 = Vector(solver=solver_session, surfaces=["x=0.012826"], scale=2.0, skip=5) window3 = GraphicsWindow() window3.add_graphics(vector1) window3.show() @@ -851,7 +869,7 @@ # =================== p1 = XYPlot( - solver=solver, + solver=solver_session, surfaces=["x=0.012826"], y_axis_function="pressure", x_axis_function="direction-vector", @@ -877,4 +895,4 @@ ############################################################################# # Exit Fluent Session # =================== -solver.exit() +solver_session.exit() diff --git a/examples/00-fluent/exhaust_system_settings_api.py b/examples/00-fluent/exhaust_system_settings_api.py index 78f74303cad7..2127f2bf2ea0 100644 --- a/examples/00-fluent/exhaust_system_settings_api.py +++ b/examples/00-fluent/exhaust_system_settings_api.py @@ -80,19 +80,19 @@ # Launch Fluent as a service in meshing mode with double precision running on # two processors and print Fluent version. -meshing = pyfluent.launch_fluent( +meshing_session = pyfluent.launch_fluent( precision="double", processor_count=2, mode="meshing", ) -print(meshing.get_fluent_version()) +print(meshing_session.get_fluent_version()) ############################################################################### # Initialize workflow # ~~~~~~~~~~~~~~~~~~~ # Initialize the fault-tolerant meshing workflow. -meshing.workflow.InitializeWorkflow(WorkflowType="Fault-tolerant Meshing") +meshing_session.workflow.InitializeWorkflow(WorkflowType="Fault-tolerant Meshing") ############################################################################### # Fault-folerant meshing workflow @@ -105,12 +105,12 @@ # Import the CAD geometry file (``exhaust_system.fmd``) and selectively manage some # parts. -meshing.upload(import_file_name) -meshing.PartManagement.InputFileChanged( +meshing_session.upload(import_file_name) +meshing_session.PartManagement.InputFileChanged( FilePath=import_file_name, IgnoreSolidNames=False, PartPerBody=False ) -meshing.PMFileManagement.FileManager.LoadFiles() -meshing.PartManagement.Node["Meshing Model"].Copy( +meshing_session.PMFileManagement.FileManager.LoadFiles() +meshing_session.PartManagement.Node["Meshing Model"].Copy( Paths=[ "/dirty_manifold-for-wrapper," + "1/dirty_manifold-for-wrapper,1/main,1", "/dirty_manifold-for-wrapper," + "1/dirty_manifold-for-wrapper,1/flow-pipe,1", @@ -119,10 +119,10 @@ "/dirty_manifold-for-wrapper," + "1/dirty_manifold-for-wrapper,1/object1,1", ] ) -meshing.PartManagement.ObjectSetting["DefaultObjectSetting"].OneZonePer.set_state( - "part" -) -cad_import = meshing.workflow.TaskObject["Import CAD and Part Management"] +meshing_session.PartManagement.ObjectSetting[ + "DefaultObjectSetting" +].OneZonePer.set_state("part") +cad_import = meshing_session.workflow.TaskObject["Import CAD and Part Management"] cad_import.Arguments.set_state( { "Context": 0, @@ -144,7 +144,7 @@ # ~~~~~~~~~~~~~~~~~~~~~~~~~~ # Describe the geometry and the flow characteristics. -describe_geom = meshing.workflow.TaskObject["Describe Geometry and Flow"] +describe_geom = meshing_session.workflow.TaskObject["Describe Geometry and Flow"] describe_geom.Arguments.set_state( { "AddEnclosure": "No", @@ -181,7 +181,7 @@ # .. image:: /_static/exhaust_system_012.png # :width: 400pt # :align: center -capping = meshing.workflow.TaskObject["Enclose Fluid Regions (Capping)"] +capping = meshing_session.workflow.TaskObject["Enclose Fluid Regions (Capping)"] capping.Arguments.set_state( { "CreatePatchPreferences": { @@ -216,7 +216,7 @@ capping.InsertCompoundChildTask() capping.Arguments.set_state({}) -meshing.workflow.TaskObject["inlet-1"].Execute() +meshing_session.workflow.TaskObject["inlet-1"].Execute() capping.Arguments.set_state( { "PatchName": "inlet-2", @@ -245,7 +245,7 @@ capping.InsertCompoundChildTask() capping.Arguments.set_state({}) -meshing.workflow.TaskObject["inlet-2"].Execute() +meshing_session.workflow.TaskObject["inlet-2"].Execute() capping.Arguments.set_state( { "PatchName": "inlet-3", @@ -274,7 +274,7 @@ capping.InsertCompoundChildTask() capping.Arguments.set_state({}) -meshing.workflow.TaskObject["inlet-3"].Execute() +meshing_session.workflow.TaskObject["inlet-3"].Execute() capping.Arguments.set_state( { "PatchName": "outlet-1", @@ -305,13 +305,13 @@ capping.InsertCompoundChildTask() capping.Arguments.set_state({}) -meshing.workflow.TaskObject["outlet-1"].Execute() +meshing_session.workflow.TaskObject["outlet-1"].Execute() ############################################################################### # Extract edge features # ~~~~~~~~~~~~~~~~~~~~~ # Extract edge features. -edge_features = meshing.workflow.TaskObject["Extract Edge Features"] +edge_features = meshing_session.workflow.TaskObject["Extract Edge Features"] edge_features.Arguments.set_state( { "ExtractMethodType": "Intersection Loops", @@ -321,7 +321,7 @@ edge_features.AddChildToTask() edge_features.InsertCompoundChildTask() -edge_group = meshing.workflow.TaskObject["edge-group-1"] +edge_group = meshing_session.workflow.TaskObject["edge-group-1"] edge_group.Arguments.set_state( { "ExtractEdgesName": "edge-group-1", @@ -337,7 +337,7 @@ # Identify regions # ~~~~~~~~~~~~~~~~ # Identify regions. -identify_regions = meshing.workflow.TaskObject["Identify Regions"] +identify_regions = meshing_session.workflow.TaskObject["Identify Regions"] identify_regions.Arguments.set_state( { "SelectionType": "zone", @@ -369,7 +369,7 @@ identify_regions.AddChildToTask() identify_regions.InsertCompoundChildTask() -fluid_region_1 = meshing.workflow.TaskObject["fluid-region-1"] +fluid_region_1 = meshing_session.workflow.TaskObject["fluid-region-1"] fluid_region_1.Arguments.set_state( { "MaterialPointsName": "fluid-region-1", @@ -409,13 +409,13 @@ identify_regions.Arguments.set_state({}) -meshing.workflow.TaskObject["void-region-1"].Execute() +meshing_session.workflow.TaskObject["void-region-1"].Execute() ############################################################################### # Define thresholds for leakages # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Define thresholds for potential leakages. -leakage_threshold = meshing.workflow.TaskObject["Define Leakage Threshold"] +leakage_threshold = meshing_session.workflow.TaskObject["Define Leakage Threshold"] leakage_threshold.Arguments.set_state( { "AddChild": "yes", @@ -427,7 +427,7 @@ leakage_threshold.AddChildToTask() leakage_threshold.InsertCompoundChildTask() -leakage_1 = meshing.workflow.TaskObject["leakage-1"] +leakage_1 = meshing_session.workflow.TaskObject["leakage-1"] leakage_1.Arguments.set_state( { "AddChild": "yes", @@ -448,7 +448,7 @@ # Review region settings # ~~~~~~~~~~~~~~~~~~~~~~ # Review the region settings. -update_region = meshing.workflow.TaskObject["Update Region Settings"] +update_region = meshing_session.workflow.TaskObject["Update Region Settings"] update_region.Arguments.set_state( { "AllRegionFilterCategories": ["2"] * 5 + ["1"] * 2, @@ -491,7 +491,7 @@ # ~~~~~~~~~~~~~~~~~~~~~~~~ # Set mesh control options. -meshing.workflow.TaskObject["Choose Mesh Control Options"].Execute() +meshing_session.workflow.TaskObject["Choose Mesh Control Options"].Execute() ############################################################################### # Generate surface mesh @@ -503,32 +503,32 @@ # :width: 500pt # :align: center -meshing.workflow.TaskObject["Generate the Surface Mesh"].Execute() +meshing_session.workflow.TaskObject["Generate the Surface Mesh"].Execute() ############################################################################### # Confirm and update boundaries # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Confirm and update the boundaries. -meshing.workflow.TaskObject["Update Boundaries"].Execute() +meshing_session.workflow.TaskObject["Update Boundaries"].Execute() ############################################################################### # Add boundary layers # ~~~~~~~~~~~~~~~~~~~ # Add boundary layers. -meshing.workflow.TaskObject["Add Boundary Layers"].AddChildToTask() +meshing_session.workflow.TaskObject["Add Boundary Layers"].AddChildToTask() -meshing.workflow.TaskObject["Add Boundary Layers"].InsertCompoundChildTask() +meshing_session.workflow.TaskObject["Add Boundary Layers"].InsertCompoundChildTask() -meshing.workflow.TaskObject["aspect-ratio_1"].Arguments.set_state( +meshing_session.workflow.TaskObject["aspect-ratio_1"].Arguments.set_state( { "BLControlName": "aspect-ratio_1", } ) -meshing.workflow.TaskObject["Add Boundary Layers"].Arguments.set_state({}) +meshing_session.workflow.TaskObject["Add Boundary Layers"].Arguments.set_state({}) -meshing.workflow.TaskObject["aspect-ratio_1"].Execute() +meshing_session.workflow.TaskObject["aspect-ratio_1"].Execute() ############################################################################### # Generate volume mesh @@ -539,7 +539,7 @@ # .. image:: /_static/exhaust_system_014.png # :width: 500pt # :align: center -volume_mesh_gen = meshing.workflow.TaskObject["Generate the Volume Mesh"] +volume_mesh_gen = meshing_session.workflow.TaskObject["Generate the Volume Mesh"] volume_mesh_gen.Arguments.set_state( { "AllRegionNameList": [ @@ -563,7 +563,7 @@ # ~~~~~~~~~~ # Check the mesh. -meshing.tui.mesh.check_mesh() +meshing_session.tui.mesh.check_mesh() ############################################################################### # Solve and postprocess @@ -575,16 +575,16 @@ # ~~~~~~~~~~~~~~~~~~~~~~~ # Switch to the solution mode. -solver = meshing.switch_to_solver() +solver_session = meshing_session.switch_to_solver_session() -solver.mesh.check() +solver_session.mesh.check() ############################################################################### # Select turbulence model # ~~~~~~~~~~~~~~~~~~~~~~~ # Select the kw sst turbulence model. -viscous = solver.setup.models.viscous +viscous = solver_session.setup.models.viscous viscous.model = "k-omega" viscous.k_omega_model = "sst" @@ -595,7 +595,7 @@ # Set the velocity and turbulence boundary conditions for the first inlet # (``inlet-1``). -boundary_conditions = solver.setup.boundary_conditions +boundary_conditions = solver_session.setup.boundary_conditions boundary_conditions.velocity_inlet["inlet-1"] = { "momentum": { @@ -629,7 +629,7 @@ # ~~~~~~~~~~~~~~~~~~~~~ # Initialize the flow field using hybrid initialization. -solver.solution.initialization.hybrid_initialize() +solver_session.solution.initialization.hybrid_initialize() ############################################################################### # Start calculation @@ -641,13 +641,13 @@ # :width: 500pt # :align: center -solver.solution.run_calculation.iterate(iter_count=100) +solver_session.solution.run_calculation.iterate(iter_count=100) ############################################################################### # Write the case and data files # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -solver.file.write( +solver_session.file.write( file_type="case-data", file_name="exhaust_system.cas.h5", ) @@ -659,7 +659,7 @@ # picture files. Edit the picture settings to use a custom resolution so that # the images are large enough. -graphics = solver.results.graphics +graphics = solver_session.results.graphics # use_window_resolution option not active inside containers or Ansys Lab environment if graphics.picture.use_window_resolution.is_active(): graphics.picture.use_window_resolution = False @@ -697,7 +697,7 @@ # ~~~~~~~~~~~~~~~~~~ # Create an iso-surface through the manifold geometry. -solver.results.surfaces.iso_surface["surf-x-coordinate"] = { +solver_session.results.surfaces.iso_surface["surf-x-coordinate"] = { "field": "x-coordinate", "zones": ["fluid-region-1"], "iso_values": [0.38], @@ -745,8 +745,8 @@ # :width: 500pt # :align: center -solver.results.scene["scene-1"] = {} -scene1 = solver.results.scene["scene-1"] +solver_session.results.scene["scene-1"] = {} +scene1 = solver_session.results.scene["scene-1"] scene1.graphics_objects.add(name="mesh-1") scene1.graphics_objects["mesh-1"].transparency = 90 scene1.graphics_objects.add(name="contour-velocity") @@ -761,4 +761,4 @@ # ~~~~~~~~~~~~ # Close Fluent. -solver.exit() +solver_session.exit() diff --git a/examples/00-fluent/external_compressible_flow.py b/examples/00-fluent/external_compressible_flow.py index 8d563dda7dcc..af490c4154ca 100644 --- a/examples/00-fluent/external_compressible_flow.py +++ b/examples/00-fluent/external_compressible_flow.py @@ -81,19 +81,19 @@ # Launch Fluent as a service in meshing mode with double precision running on # four processors and print Fluent version. -meshing = pyfluent.launch_fluent( +meshing_session = pyfluent.launch_fluent( precision="double", processor_count=4, mode="meshing", ) -print(meshing.get_fluent_version()) +print(meshing_session.get_fluent_version()) ############################################################################### # Initialize workflow # ~~~~~~~~~~~~~~~~~~~ # Initialize the watertight geometry meshing workflow. -meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry") +meshing_session.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry") ############################################################################### # Watertight geometry meshing workflow @@ -104,21 +104,21 @@ # Import CAD and set length units # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Import the CAD geometry and set the length units to inches. -geo_import = meshing.workflow.TaskObject["Import Geometry"] +geo_import = meshing_session.workflow.TaskObject["Import Geometry"] geo_import.Arguments.set_state( { "FileName": wing_intermediary_file, } ) -meshing.upload(wing_intermediary_file) +meshing_session.upload(wing_intermediary_file) geo_import.Execute() ############################################################################### # Add local sizing # ~~~~~~~~~~~~~~~~ # Add local sizing controls to the faceted geometry. -local_sizing = meshing.workflow.TaskObject["Add Local Sizing"] +local_sizing = meshing_session.workflow.TaskObject["Add Local Sizing"] local_sizing.Arguments.set_state( { "AddChild": "yes", @@ -157,7 +157,7 @@ # Generate surface mesh # ~~~~~~~~~~~~~~~~~~~~~ # Generate the surface mash. -surface_mesh_gen = meshing.workflow.TaskObject["Generate the Surface Mesh"] +surface_mesh_gen = meshing_session.workflow.TaskObject["Generate the Surface Mesh"] surface_mesh_gen.Arguments.set_state( {"CFDSurfaceMeshControls": {"MaxSize": 1000, "MinSize": 2}} ) @@ -168,7 +168,7 @@ # Describe geometry # ~~~~~~~~~~~~~~~~~ # Describe geometry and define the fluid region. -describe_geo = meshing.workflow.TaskObject["Describe Geometry"] +describe_geo = meshing_session.workflow.TaskObject["Describe Geometry"] describe_geo.UpdateChildTasks(SetupTypeChanged=False) describe_geo.Arguments.set_state( @@ -184,21 +184,21 @@ # ~~~~~~~~~~~~~~~~~ # Update the boundaries. -meshing.workflow.TaskObject["Update Boundaries"].Execute() +meshing_session.workflow.TaskObject["Update Boundaries"].Execute() ############################################################################### # Update regions # ~~~~~~~~~~~~~~ # Update the regions. -meshing.workflow.TaskObject["Update Regions"].Execute() +meshing_session.workflow.TaskObject["Update Regions"].Execute() ############################################################################### # Add boundary layers # ~~~~~~~~~~~~~~~~~~~ # Add boundary layers, which consist of setting properties for the # boundary layer mesh. -add_boundary_layer = meshing.workflow.TaskObject["Add Boundary Layers"] +add_boundary_layer = meshing_session.workflow.TaskObject["Add Boundary Layers"] add_boundary_layer.Arguments.set_state({"NumberOfLayers": 12}) add_boundary_layer.AddChildAndUpdate() @@ -208,7 +208,7 @@ # ~~~~~~~~~~~~~~~~~~~~ # Generate the volume mesh, which consists of setting properties for the # volume mesh. -volume_mesh_gen = meshing.workflow.TaskObject["Generate the Volume Mesh"] +volume_mesh_gen = meshing_session.workflow.TaskObject["Generate the Volume Mesh"] volume_mesh_gen.Arguments.set_state( { "VolumeFill": "poly-hexcore", @@ -227,14 +227,14 @@ # ~~~~~~~~~~~~~~~~~~~~~~~~~~ # Check the mesh in meshing mode. -meshing.tui.mesh.check_mesh() +meshing_session.tui.mesh.check_mesh() ############################################################################### # Save mesh file # ~~~~~~~~~~~~~~ # Save the mesh file (``wing.msh.h5``). -meshing.meshing.File.WriteMesh(FileName="wing.msh.h5") +meshing_session.meshing_session.File.WriteMesh(FileName="wing.msh.h5") ############################################################################### # Solve and postprocess @@ -248,7 +248,7 @@ # using Fluent in meshing mode, you can switch to solver mode to complete the # setup of the simulation. -solver = meshing.switch_to_solver() +solver_session = meshing_session.switch_to_solver() ############################################################################### # Check mesh in solver mode @@ -258,7 +258,7 @@ # reports a number of other mesh features that are checked. Any errors in the # mesh are reported. -solver.mesh.check() +solver_session.mesh.check() ############################################################################### # Define model @@ -268,7 +268,7 @@ # model : k-omega # k-omega model : sst -viscous = solver.setup.models.viscous +viscous = solver_session.setup.models.viscous viscous.model = "k-omega" viscous.k_omega_model = "sst" @@ -285,7 +285,7 @@ # reference temperature : 273.11 [K] # effective temperature : 110.56 [K] -air = solver.setup.materials.fluid["air"] +air = solver_session.setup.materials.fluid["air"] air.density.option = "ideal-gas" @@ -312,7 +312,7 @@ # turbulent intensity : 5 [%] # turbulent viscosity ratio : 10 -pressure_farfield = solver.setup.boundary_conditions.pressure_far_field[ +pressure_farfield = solver_session.setup.boundary_conditions.pressure_far_field[ "pressure_farfield" ] @@ -337,41 +337,41 @@ # operating pressure : 80600 [Pa] -solver.setup.general.operating_conditions.operating_pressure = 80600 +solver_session.setup.general.operating_conditions.operating_pressure = 80600 ############################################################################### # Initialize flow field # ~~~~~~~~~~~~~~~~~~~~~ # Initialize the flow field using hybrid initialization. -solver.solution.initialization.hybrid_initialize() +solver_session.solution.initialization.hybrid_initialize() ############################################################################### # Save case file # ~~~~~~~~~~~~~~ # Save the case file ``external_compressible1.cas.h5``. -solver.file.write(file_name="external_compressible.cas.h5", file_type="case") +solver_session.file.write(file_name="external_compressible.cas.h5", file_type="case") ############################################################################### # Solve for 25 iterations # ~~~~~~~~~~~~~~~~~~~~~~~~ # Solve for 25 iterations (100 iterations is recommended, however for this example 25 is sufficient). -solver.solution.run_calculation.iterate(iter_count=25) +solver_session.solution.run_calculation.iterate(iter_count=25) ############################################################################### # Write final case file and data # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Write the final case file and the data. -solver.file.write(file_name="external_compressible1.cas.h5", file_type="case") +solver_session.file.write(file_name="external_compressible1.cas.h5", file_type="case") ############################################################################### # Close Fluent # ~~~~~~~~~~~~ # Close Fluent. -solver.exit() +solver_session.exit() ############################################################################### diff --git a/examples/00-fluent/frozen_rotor_workflow.py b/examples/00-fluent/frozen_rotor_workflow.py index dbe3e0cc27f3..05ecfc427adc 100644 --- a/examples/00-fluent/frozen_rotor_workflow.py +++ b/examples/00-fluent/frozen_rotor_workflow.py @@ -111,13 +111,13 @@ # Launch Fluent with solver mode and print Fluent version # ============================================================================================================== -solver = pyfluent.launch_fluent( +solver_session = pyfluent.launch_fluent( mode="solver", ui_mode="gui", processor_count=4, cleanup_on_exit=True, ) -print(solver.get_fluent_version()) +print(solver_session.get_fluent_version()) ################################################################################################################ @@ -125,19 +125,19 @@ # ============================================================================================================== # Read Impeller mesh file -solver.settings.file.read_mesh(file_name=impeller_mesh) +solver_session.settings.file.read_mesh(file_name=impeller_mesh) # Append Volute mesh file -solver.settings.mesh.modify_zones.append_mesh(file_name=volute_mesh) +solver_session.settings.mesh.modify_zones.append_mesh(file_name=volute_mesh) ################################################################################################################ # Display the mesh # ============================================================================================================== # Access the graphics object -graphics = solver.settings.results.graphics +graphics = solver_session.settings.results.graphics # Create a mesh object and configure its settings -mesh_object = solver.settings.results.graphics.mesh.create(name="mesh-1") +mesh_object = solver_session.settings.results.graphics.mesh.create(name="mesh-1") mesh_object.surfaces_list = [ "inlet", "mass-flow-inlet-11", @@ -176,7 +176,7 @@ # Set the unit for angular velocity, rad/s to rev/min # ============================================================================================================== -solver.settings.setup.general.units.set_units( +solver_session.settings.setup.general.units.set_units( quantity="angular-velocity", units_name="rev/min" ) @@ -185,21 +185,25 @@ # ============================================================================================================== # Models setting -viscous = solver.settings.setup.models.viscous -viscous = solver.settings.setup.models.viscous +viscous = solver_session.settings.setup.models.viscous +viscous = solver_session.settings.setup.models.viscous viscous.model = "k-omega" viscous.k_omega_model = "sst" ################################################################################################################ # Define Materials # ============================================================================================================== -solver.settings.setup.materials.database.copy_by_name(type="fluid", name="water-liquid") +solver_session.settings.setup.materials.database.copy_by_name( + type="fluid", name="water-liquid" +) ################################################################################################################ # Define Cell Zone Conditions # ============================================================================================================== -impeller_cell_zone = solver.settings.setup.cell_zone_conditions.fluid["impeller"] +impeller_cell_zone = solver_session.settings.setup.cell_zone_conditions.fluid[ + "impeller" +] impeller_cell_zone.general.material = "water-liquid" impeller_cell_zone.reference_frame.reference_frame_axis_origin = [0, 0, 0] @@ -211,20 +215,22 @@ # Volute Cell Zone Conditions -volute_cell_zone = solver.settings.setup.cell_zone_conditions.fluid["volute"] +volute_cell_zone = solver_session.settings.setup.cell_zone_conditions.fluid["volute"] volute_cell_zone.general.material = "water-liquid" # Boundary Conditions # impeller hub -impeller_hub = solver.settings.setup.boundary_conditions.wall["impeller-hub"].momentum +impeller_hub = solver_session.settings.setup.boundary_conditions.wall[ + "impeller-hub" +].momentum impeller_hub.wall_motion = "Moving Wall" impeller_hub.relative = True impeller_hub.velocity_spec = "Rotational" # inblock-shroud -inblock_shroud = solver.settings.setup.boundary_conditions.wall[ +inblock_shroud = solver_session.settings.setup.boundary_conditions.wall[ "inblock-shroud" ].momentum inblock_shroud.wall_motion = "Moving Wall" @@ -236,16 +242,18 @@ # ============================================================================================================== # Inlet Boundary Condition -pressure_inlet = solver.settings.setup.boundary_conditions.pressure_inlet["inlet"] +pressure_inlet = solver_session.settings.setup.boundary_conditions.pressure_inlet[ + "inlet" +] pressure_inlet.momentum.supersonic_or_initial_gauge_pressure.value = -100 # It seems, need to change the boundary condition to mass flow outlet -solver.settings.setup.boundary_conditions.set_zone_type( +solver_session.settings.setup.boundary_conditions.set_zone_type( zone_list=["mass-flow-inlet-11"], new_type="mass-flow-outlet" ) # Outlet Boundary Condition -mass_flow_outlet = solver.settings.setup.boundary_conditions.mass_flow_outlet[ +mass_flow_outlet = solver_session.settings.setup.boundary_conditions.mass_flow_outlet[ "mass-flow-inlet-11" ] mass_flow_outlet.momentum.mass_flow_rate.value = 90 # kg/s @@ -253,21 +261,23 @@ # Create a turbo interfaces # enable the turbo models -solver.settings.setup.turbo_models.enabled = True - -impeller_volute_interface = solver.settings.setup.mesh_interfaces.turbo_create.create( - adjacent_cell_zone_1="impeller", - adjacent_cell_zone_2="volute", - mesh_interface_name="imp-volute-interface", - turbo_choice="No-Pitch-Scale", - zone1="interface-impeller-outlet", - zone2="interface-volute-inlet", +solver_session.settings.setup.turbo_models.enabled = True + +impeller_volute_interface = ( + solver_session.settings.setup.mesh_interfaces.turbo_create.create( + adjacent_cell_zone_1="impeller", + adjacent_cell_zone_2="volute", + mesh_interface_name="imp-volute-interface", + turbo_choice="No-Pitch-Scale", + zone1="interface-impeller-outlet", + zone2="interface-volute-inlet", + ) ) ################################################################################################################ # Define Solver Settings # ============================================================================================================== -methods = solver.settings.solution.methods +methods = solver_session.settings.solution.methods methods.spatial_discretization.gradient_scheme = "green-gauss-node-based" methods.high_order_term_relaxation.enable = True @@ -275,7 +285,7 @@ # Define Named Expressions # ============================================================================================================== -pump_head = solver.settings.setup.named_expressions.create("head") +pump_head = solver_session.settings.setup.named_expressions.create("head") pump_head.definition = "(({p-out} - {p-in}) / (998.2 [kg/m^3] * 9.81[m/s^2]))" pump_head.output_parameter = True @@ -286,27 +296,27 @@ # Create a report definition # p-out -outlet_pressure_report_def = solver.settings.solution.report_definitions.surface.create( - "p-out" +outlet_pressure_report_def = ( + solver_session.settings.solution.report_definitions.surface.create("p-out") ) outlet_pressure_report_def.report_type = "surface-massavg" outlet_pressure_report_def.surface_names = ["mass-flow-inlet-11"] outlet_pressure_report_def.field = "total-pressure" outlet_pressure_report_def.per_surface = False -outlet_pressure_report_plot = solver.settings.solution.monitor.report_plots.create( - "p-out-rplot" +outlet_pressure_report_plot = ( + solver_session.settings.solution.monitor.report_plots.create("p-out-rplot") ) outlet_pressure_report_plot.report_defs = "p-out" -outlet_pressure_report_file = solver.settings.solution.monitor.report_files.create( - "p-out-rfile" +outlet_pressure_report_file = ( + solver_session.settings.solution.monitor.report_files.create("p-out-rfile") ) outlet_pressure_report_file.report_defs = "p-out" # p-in -inlet_pressure_report_def = solver.settings.solution.report_definitions.surface.create( - "p-in" +inlet_pressure_report_def = ( + solver_session.settings.solution.report_definitions.surface.create("p-in") ) inlet_pressure_report_def.report_type = "surface-massavg" inlet_pressure_report_def.surface_names = ["inlet"] @@ -316,7 +326,7 @@ # Pump Head pump_head_report_def = ( - solver.settings.solution.report_definitions.single_valued_expression.create( + solver_session.settings.solution.report_definitions.single_valued_expression.create( "pump-head" ) ) @@ -324,20 +334,20 @@ pump_head_report_def.definition = "head" # report plot -pump_head_report_plot = solver.settings.solution.monitor.report_plots.create( +pump_head_report_plot = solver_session.settings.solution.monitor.report_plots.create( "pump-head-rplot" ) pump_head_report_plot.report_defs = "pump-head" # report file -pump_head_report_file = solver.settings.solution.monitor.report_files.create( +pump_head_report_file = solver_session.settings.solution.monitor.report_files.create( "pump-head-rfile" ) pump_head_report_file.report_defs = "pump-head" # p-blade -blade_pressure_report_def = solver.settings.solution.report_definitions.surface.create( - "p-blade" +blade_pressure_report_def = ( + solver_session.settings.solution.report_definitions.surface.create("p-blade") ) blade_pressure_report_def.report_type = "surface-massavg" blade_pressure_report_def.surface_names = ["blade"] @@ -348,7 +358,7 @@ ################################################################################################################ # Initialization and run solver # ============================================================================================================== -initialization = solver.settings.solution.initialization +initialization = solver_session.settings.solution.initialization initialization.reference_frame = "absolute" initialization.hybrid_init_options.general_settings.initialization_options.initial_pressure = ( True @@ -356,12 +366,14 @@ initialization.hybrid_initialize() # Run calculation settings -run_calculation = solver.settings.solution.run_calculation +run_calculation = solver_session.settings.solution.run_calculation run_calculation.pseudo_time_settings.time_step_method.time_step_size_scale_factor = 10 run_calculation.iter_count = 200 # Write the case file -solver.settings.file.write(file_type="case", file_name="pump_voulte_setup.cas.h5") +solver_session.settings.file.write( + file_type="case", file_name="pump_voulte_setup.cas.h5" +) # Run the calculation run_calculation.calculate() @@ -370,13 +382,15 @@ # ============================================================================================================== # Create a mid-plane surface at z = -0.015 m -z_mid_plane = solver.settings.results.surfaces.plane_surface.create(name="z_mid_plane") +z_mid_plane = solver_session.settings.results.surfaces.plane_surface.create( + name="z_mid_plane" +) z_mid_plane.method = "xy-plane" z_mid_plane.z = -0.015 z_mid_plane.display() # Define the contour for static pressure -pressure_contour = solver.settings.results.graphics.contour.create( +pressure_contour = solver_session.settings.results.graphics.contour.create( name="static-pressure-contour" ) pressure_contour.field = "pressure" @@ -398,14 +412,14 @@ ################################################################################################################ # Save the case file # ============================================================================================================== -solver.settings.file.write( +solver_session.settings.file.write( file_type="case-data", file_name="pump_volute_setup_solved.cas.h5" ) ################################################################################################################ # Close the session # ============================================================================================================== -solver.exit() +solver_session.exit() ################################################################################################################ # References diff --git a/examples/00-fluent/lunar_lander_thermal.py b/examples/00-fluent/lunar_lander_thermal.py index 49776b2c8aa1..f0173a0a2ab0 100644 --- a/examples/00-fluent/lunar_lander_thermal.py +++ b/examples/00-fluent/lunar_lander_thermal.py @@ -261,19 +261,19 @@ def get_surf_mean_temp( # Launch Fluent and print Fluent version # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -solver = pyfluent.launch_fluent( +solver_session = pyfluent.launch_fluent( precision="double", processor_count=12, mode="solver", cwd=pyfluent.EXAMPLES_PATH, ) -print(solver.get_fluent_version()) +print(solver_session.get_fluent_version()) ############################################################################### # Load the mesh # ~~~~~~~~~~~~~ -solver.file.read_mesh(file_name=lander_mesh_file) +solver_session.file.read_mesh(file_name=lander_mesh_file) ############################################################################### # Case Setup @@ -288,10 +288,10 @@ def get_surf_mean_temp( # 1. # Set solution to transient -solver.setup.general.solver.time = "unsteady-2nd-order" +solver_session.setup.general.solver.time = "unsteady-2nd-order" # Set transient settings -trans_controls = solver.solution.run_calculation.transient_controls +trans_controls = solver_session.solution.run_calculation.transient_controls trans_controls.type = "Fixed" trans_controls.max_iter_per_time_step = 20 trans_controls.time_step_count = 1 @@ -303,7 +303,7 @@ def get_surf_mean_temp( # Enable the energy model. Since fluid flow is not simulated, we will set the # viscosity model to laminar. -models = solver.setup.models +models = solver_session.setup.models models.energy.enabled = True models.viscous.model = "laminar" @@ -353,7 +353,7 @@ def get_surf_mean_temp( # --- Properties of vacuum --- # Thermal conductivity: 0 -vacuum = solver.setup.materials.solid.create("vacuum") +vacuum = solver_session.setup.materials.solid.create("vacuum") vacuum.chemical_formula = "" vacuum.thermal_conductivity.value = 0 vacuum.absorption_coefficient.value = 0 @@ -364,7 +364,7 @@ def get_surf_mean_temp( # Specific heat capacity: 1050 [J kg^-1 K^-1] # Thermal conductivity: 9.22e-4*(1 + 1.48*(temperature/350 K)^3) [W m^-1 K^-1] -fluff = solver.setup.materials.solid.create("fluff") +fluff = solver_session.setup.materials.solid.create("fluff") fluff.chemical_formula = "" fluff.density.value = 1000 fluff.specific_heat.value = 1050 @@ -378,7 +378,7 @@ def get_surf_mean_temp( # Specific heat capacity: 1050 [J kg^-1 K^-1] # Thermal conductivity: 9.30e-4*(1 + 0.73*(temperature/350 K)^3) [W m^-1 K^-1] -regolith = solver.setup.materials.solid.create("regolith") +regolith = solver_session.setup.materials.solid.create("regolith") regolith.chemical_formula = "" regolith.density.value = 2000 regolith.specific_heat.value = 1050 @@ -395,7 +395,7 @@ def get_surf_mean_temp( # lander. This cell zone must be set to be a solid so that the fluid equations # are not solved there, then it must be assigned to the vacuum material. -cellzones = solver.setup.cell_zone_conditions +cellzones = solver_session.setup.cell_zone_conditions cellzones.set_zone_type( zone_list=["geom-2_domain"], new_type="solid", @@ -416,7 +416,7 @@ def get_surf_mean_temp( # Surface absorptivity: 0.87 # Surface emissivity: 0.97 -regolith_bc = solver.setup.boundary_conditions.wall["regolith"] +regolith_bc = solver_session.setup.boundary_conditions.wall["regolith"] regolith_bc.thermal.q.value = 0.031 regolith_bc.thermal.planar_conduction = True @@ -459,7 +459,7 @@ def get_surf_mean_temp( # Absorptivity: 1 # Solar flux: 1414 [W m^-2] -space_bc = solver.setup.boundary_conditions.wall["space"] +space_bc = solver_session.setup.boundary_conditions.wall["space"] space_bc.thermal.thermal_bc = "Temperature" space_bc.thermal.t.value = 3 @@ -487,7 +487,7 @@ def get_surf_mean_temp( # Absorptivity: 0.05 # Emissivity: 0.05 -sc_mli_bc = solver.setup.boundary_conditions.wall["sc-mli"] +sc_mli_bc = solver_session.setup.boundary_conditions.wall["sc-mli"] sc_mli_bc.thermal.planar_conduction = True sc_mli_bc.thermal.shell_conduction = [ @@ -514,7 +514,7 @@ def get_surf_mean_temp( # Absorptivity: 0.17 # Emissivity: 0.09 below 273 K, 0.70 otherwise -sc_rad_bc = solver.setup.boundary_conditions.wall["sc-radiator"] +sc_rad_bc = solver_session.setup.boundary_conditions.wall["sc-radiator"] sc_rad_bc.thermal.planar_conduction = True sc_rad_bc.thermal.shell_conduction = [ @@ -535,7 +535,7 @@ def get_surf_mean_temp( # definitions on them in the next step. The entire domain will be initialized # to a temperature of 230 K, or -43 °C. -sim_init = solver.solution.initialization +sim_init = solver_session.solution.initialization sim_init.defaults["temperature"] = 230 sim_init.initialize() @@ -544,7 +544,7 @@ def get_surf_mean_temp( # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Create reports for the spacecraft's minimum, mean, and maximum temperatures. -surf_report_defs = solver.solution.report_definitions.surface +surf_report_defs = solver_session.solution.report_definitions.surface sc_surfs = ["sc-radiator", "sc-mli"] @@ -570,7 +570,7 @@ def get_surf_mean_temp( # Create reports for the mean temperatures of each regolith layer. We will # store the report names for use later. -surf_report_defs = solver.solution.report_definitions.surface +surf_report_defs = solver_session.solution.report_definitions.surface # Loop over all regolith reports to set common properties regolith_report_names = [] @@ -593,7 +593,7 @@ def get_surf_mean_temp( # ~~~~~~~~~~~~~~~~~~~~~~~~ # Create temperature report files for post-processing. -surf_report_files = solver.solution.monitor.report_files +surf_report_files = solver_session.solution.monitor.report_files # Spacecraft temperatures surf_report_files["sc-temps-rfile"] = { @@ -610,7 +610,7 @@ def get_surf_mean_temp( # ~~~~~~~~ # Set the case to save only the data file at each timestep for post-processing. -autosave = solver.file.auto_save +autosave = solver_session.file.auto_save autosave.case_frequency = "if-mesh-is-modified" autosave.data_frequency = 1 @@ -623,7 +623,7 @@ def get_surf_mean_temp( # Turn off the convergence criteria pertaining to fluid flow as there is no # fluid flow in this simulation. Keep only the energy convergence criterion. -residuals = solver.solution.monitor.residual.equations +residuals = solver_session.solution.monitor.residual.equations for criterion in ["continuity", "x-velocity", "y-velocity", "z-velocity"]: residuals[criterion].check_convergence = False @@ -634,8 +634,8 @@ def get_surf_mean_temp( # ~~~~~~~~~~~~~~~ # Write the case file. Enable overwrite. -solver.file.batch_options.confirm_overwrite = True -solver.file.write( +solver_session.file.batch_options.confirm_overwrite = True +solver_session.file.write( file_name="lunar_lander_thermal.cas.h5", file_type="case", ) @@ -653,7 +653,7 @@ def get_surf_mean_temp( for i in range(n_steps): # Get current simulation time - t = solver.rp_vars("flow-time") + t = solver_session.rp_vars("flow-time") # Calculate sun vector sun_alt, sun_azm = calc_sun_vecs_for_moon( @@ -669,7 +669,9 @@ def get_surf_mean_temp( ) # Set beam direction - solver.setup.boundary_conditions.wall["space"].radiation.reference_direction = [ + solver_session.setup.boundary_conditions.wall[ + "space" + ].radiation.reference_direction = [ beam_x, beam_y, beam_z, @@ -682,7 +684,7 @@ def get_surf_mean_temp( ) # Simulate closing louvers below 273 K by changing emissivity - rad_emiss = solver.setup.boundary_conditions.wall[ + rad_emiss = solver_session.setup.boundary_conditions.wall[ "sc-radiator" ].radiation.band_in_emiss["thermal-ir"] if rad_mean_temp < 273: @@ -691,14 +693,14 @@ def get_surf_mean_temp( rad_emiss.value = 0.70 # Run simulation for 1 timestep - solver.solution.run_calculation.calculate() + solver_session.solution.run_calculation.calculate() ############################################################################### # Close Fluent # ~~~~~~~~~~~~ # Shut down the solver. -solver.exit() +solver_session.exit() ############################################################################### # Post-process diff --git a/examples/00-fluent/mixing_elbow_settings_api.py b/examples/00-fluent/mixing_elbow_settings_api.py index 575182e039ad..68ef071299f0 100644 --- a/examples/00-fluent/mixing_elbow_settings_api.py +++ b/examples/00-fluent/mixing_elbow_settings_api.py @@ -61,12 +61,12 @@ # Launch Fluent as a service in solver mode with double precision running on # two processors and print Fluent version. -solver = pyfluent.launch_fluent( +solver_session = pyfluent.launch_fluent( precision="double", processor_count=2, mode="solver", ) -print(solver.get_fluent_version()) +print(solver_session.get_fluent_version()) ############################################################################### # Import mesh and perform mesh check @@ -77,22 +77,22 @@ # in the mesh are reported. Ensure that the minimum volume is not negative because # Fluent cannot begin a calculation when this is the case. -solver.file.read_case(file_name=import_file_name) -solver.mesh.check() +solver_session.file.read_case(file_name=import_file_name) +solver_session.mesh.check() ############################################################################### # Enable heat transfer # ~~~~~~~~~~~~~~~~~~~~ # Enable heat transfer by activating the energy equation. -solver.setup.models.energy.enabled = True +solver_session.setup.models.energy.enabled = True ############################################################################### # Create material # ~~~~~~~~~~~~~~~ # Create a material named ``"water-liquid"``. -solver.setup.materials.database.copy_by_name(type="fluid", name="water-liquid") +solver_session.setup.materials.database.copy_by_name(type="fluid", name="water-liquid") ############################################################################### # Set up cell zone conditions @@ -100,7 +100,9 @@ # Set up the cell zone conditions for the fluid zone (``elbow-fluid``). Set ``material`` # to ``"water-liquid"``. -solver.setup.cell_zone_conditions.fluid["elbow-fluid"].general.material = "water-liquid" +solver_session.setup.cell_zone_conditions.fluid["elbow-fluid"].general.material = ( + "water-liquid" +) ############################################################################### # Set up boundary conditions for CFD analysis @@ -115,7 +117,7 @@ # Turbulent Intensity: 5 [%] # Hydraulic Diameter: 4 [inch] # Temperature: 293.15 [K] -cold_inlet = solver.setup.boundary_conditions.velocity_inlet["cold-inlet"] +cold_inlet = solver_session.setup.boundary_conditions.velocity_inlet["cold-inlet"] cold_inlet.momentum.velocity_magnitude.value = 0.4 cold_inlet.turbulence.turbulence_specification = "Intensity and Hydraulic Diameter" @@ -130,7 +132,7 @@ # Turbulent Intensity: 5 [%] # Hydraulic Diameter: 1 [inch] # Temperature: 313.15 [K] -hot_inlet = solver.setup.boundary_conditions.velocity_inlet["hot-inlet"] +hot_inlet = solver_session.setup.boundary_conditions.velocity_inlet["hot-inlet"] hot_inlet.momentum.velocity_magnitude.value = 1.2 hot_inlet.turbulence.turbulence_specification = "Intensity and Hydraulic Diameter" @@ -141,7 +143,7 @@ # Backflow Turbulent Intensity: 5 [%] # Backflow Turbulent Viscosity Ratio: 4 -solver.setup.boundary_conditions.pressure_outlet[ +solver_session.setup.boundary_conditions.pressure_outlet[ "outlet" ].turbulence.turbulent_viscosity_ratio = 4 @@ -150,14 +152,14 @@ # ~~~~~~~~~~~~~~~~~~~~~ # Initialize the flow field using hybrid initialization. -solver.solution.initialization.hybrid_initialize() +solver_session.solution.initialization.hybrid_initialize() ############################################################################### # Solve for 150 iterations # ~~~~~~~~~~~~~~~~~~~~~~~~ # Solve for 150 iterations. -solver.solution.run_calculation.iterate(iter_count=150) +solver_session.solution.run_calculation.iterate(iter_count=150) ############################################################################### # Configure graphics picture export @@ -166,7 +168,7 @@ # picture files. Edit the picture settings to use a custom resolution so that # the images are large enough. -graphics = solver.results.graphics +graphics = solver_session.results.graphics # use_window_resolution option not active inside containers or Ansys Lab environment if graphics.picture.use_window_resolution.is_active(): graphics.picture.use_window_resolution = False @@ -180,10 +182,10 @@ # Create and display velocity vectors on the ``symmetry-xyplane`` plane, then # export the image for inspection. -graphics = solver.results.graphics +graphics = solver_session.results.graphics graphics.vector["velocity_vector_symmetry"] = {} -velocity_symmetry = solver.results.graphics.vector["velocity_vector_symmetry"] +velocity_symmetry = solver_session.results.graphics.vector["velocity_vector_symmetry"] velocity_symmetry.print_state() velocity_symmetry.field = "velocity-magnitude" velocity_symmetry.surfaces_list = [ @@ -206,9 +208,9 @@ # Compute mass flow rate # ~~~~~~~~~~~~~~~~~~~~~~ # Compute the mass flow rate. -solver.solution.report_definitions.flux["mass_flow_rate"] = {} +solver_session.solution.report_definitions.flux["mass_flow_rate"] = {} -mass_flow_rate = solver.solution.report_definitions.flux["mass_flow_rate"] +mass_flow_rate = solver_session.solution.report_definitions.flux["mass_flow_rate"] mass_flow_rate.boundaries.allowed_values() mass_flow_rate.boundaries = [ "cold-inlet", @@ -216,11 +218,11 @@ "outlet", ] mass_flow_rate.print_state() -solver.solution.report_definitions.compute(report_defs=["mass_flow_rate"]) +solver_session.solution.report_definitions.compute(report_defs=["mass_flow_rate"]) ######################################################################### # Close Fluent # ~~~~~~~~~~~~ # Close Fluent. -solver.exit() +solver_session.exit() diff --git a/examples/00-fluent/mixing_tank_workflow.py b/examples/00-fluent/mixing_tank_workflow.py index f3b0d5ba5a3b..518f5ff9fb0b 100644 --- a/examples/00-fluent/mixing_tank_workflow.py +++ b/examples/00-fluent/mixing_tank_workflow.py @@ -122,7 +122,7 @@ ############################################################################################################# # Switch to the Solver Mode # =========================================================================================================== -solver = session.switch_to_solver() +solver_session = session.switch_to_solver() ############################################################################################################### @@ -130,14 +130,16 @@ # =========================================================================================================== # Create a middle plane to display the mesh -y_mid_plane = solver.settings.results.surfaces.plane_surface.create(name="mid_plane") +y_mid_plane = solver_session.settings.results.surfaces.plane_surface.create( + name="mid_plane" +) y_mid_plane.method = "zx-plane" y_mid_plane.y = 0 y_mid_plane.display() # Access the graphics object -graphics = solver.settings.results.graphics +graphics = solver_session.settings.results.graphics # Set the hardcopy format for saving the image graphics.picture.driver_options.hardcopy_format = "png" @@ -147,11 +149,11 @@ geom_view.view_name = "top" # Get the list of all walls -all_walls = solver.settings.setup.boundary_conditions.wall.get_object_names() +all_walls = solver_session.settings.setup.boundary_conditions.wall.get_object_names() filtered_walls_to_display = [wall for wall in all_walls if "mrf" not in wall] # Create a mesh object and configure its settings -mesh_object = solver.settings.results.graphics.mesh.create(name="mesh-1") +mesh_object = solver_session.settings.results.graphics.mesh.create(name="mesh-1") mesh_object.surfaces_list = filtered_walls_to_display mesh_object.options.edges = False @@ -193,14 +195,20 @@ ############################################################################################################# # Solver Setup and Solve Workflow # =========================================================================================================== -solver.settings.setup.general.operating_conditions.gravity.enable = True -solver.settings.setup.general.operating_conditions.gravity.components = [0.0, 0.0, -g] +solver_session.settings.setup.general.operating_conditions.gravity.enable = True +solver_session.settings.setup.general.operating_conditions.gravity.components = [ + 0.0, + 0.0, + -g, +] ############################################################################################################# # Define Materials # =========================================================================================================== -solver.settings.setup.materials.database.copy_by_name(type="fluid", name="water-liquid") -fluid_mat = solver.settings.setup.materials.fluid["water-liquid"] +solver_session.settings.setup.materials.database.copy_by_name( + type="fluid", name="water-liquid" +) +fluid_mat = solver_session.settings.setup.materials.fluid["water-liquid"] fluid_mat.density.value = water_density fluid_mat.viscosity.value = water_viscosity @@ -209,13 +217,17 @@ # =========================================================================================================== # Get the list of all Fluid Cell Zones, -fluid_cell_zones = solver.settings.setup.cell_zone_conditions.fluid.get_object_names() +fluid_cell_zones = ( + solver_session.settings.setup.cell_zone_conditions.fluid.get_object_names() +) fluid_mrf_cell_zones = [zone for zone in fluid_cell_zones if "mrf" in zone] for cell_zone in fluid_mrf_cell_zones: print(cell_zone) # Set the material for each cell zone - fluid_cell_zone = solver.settings.setup.cell_zone_conditions.fluid[cell_zone] + fluid_cell_zone = solver_session.settings.setup.cell_zone_conditions.fluid[ + cell_zone + ] fluid_cell_zone.general.material = "water-liquid" # Set the reference frame for each cell zone fluid_cell_zone.reference_frame.reference_frame_axis_origin = [0, 0, 0.4] @@ -225,7 +237,7 @@ fluid_cell_zone.reference_frame.mrf_omega.value = agitation_speed stationary_cell_zones = [zone for zone in fluid_cell_zones if "mrf" not in zone] -stationary_cell_zones = solver.settings.setup.cell_zone_conditions.fluid[ +stationary_cell_zones = solver_session.settings.setup.cell_zone_conditions.fluid[ stationary_cell_zones[0] ] stationary_cell_zones.general.material = "water-liquid" @@ -235,7 +247,7 @@ for wall in wall_shaft: print(wall) - wall_boundary = solver.settings.setup.boundary_conditions.wall[wall] + wall_boundary = solver_session.settings.setup.boundary_conditions.wall[wall] wall_boundary.momentum.wall_motion = "Moving Wall" wall_boundary.momentum.relative = False wall_boundary.momentum.rotating = True @@ -243,34 +255,36 @@ wall_boundary.momentum.rotation_speed = agitation_speed -liquid_level_bc = solver.settings.setup.boundary_conditions.wall["wall_liquid_level"] +liquid_level_bc = solver_session.settings.setup.boundary_conditions.wall[ + "wall_liquid_level" +] liquid_level_bc.momentum.wall_motion = "Stationary Wall" liquid_level_bc.momentum.shear_condition = "Specified Shear" # Change the Zone type for internal walls to interior -solver.setup.boundary_conditions.set_zone_type( +solver_session.setup.boundary_conditions.set_zone_type( zone_list=["fluid_mrf_1-fluid_tank"], new_type="interior" ) ############################################################################################################# # Solution Methods and Controls # =========================================================================================================== -solver.settings.solution.methods.p_v_coupling.flow_scheme = "SIMPLE" -solver.settings.solution.methods.spatial_discretization.discretization_scheme[ +solver_session.settings.solution.methods.p_v_coupling.flow_scheme = "SIMPLE" +solver_session.settings.solution.methods.spatial_discretization.discretization_scheme[ "pressure" ] = "presto!" -solver.settings.solution.controls.under_relaxation["pressure"] = 0.5 -solver.settings.solution.controls.under_relaxation["mom"] = 0.3 -solver.settings.solution.controls.under_relaxation["k"] = 0.6 -solver.settings.solution.controls.under_relaxation["omega"] = 0.6 -solver.settings.solution.controls.under_relaxation["turb-viscosity"] = 0.6 +solver_session.settings.solution.controls.under_relaxation["pressure"] = 0.5 +solver_session.settings.solution.controls.under_relaxation["mom"] = 0.3 +solver_session.settings.solution.controls.under_relaxation["k"] = 0.6 +solver_session.settings.solution.controls.under_relaxation["omega"] = 0.6 +solver_session.settings.solution.controls.under_relaxation["turb-viscosity"] = 0.6 ############################################################################################################## # Residuals Criteria & Initialization # =========================================================================================================== # Residuals criteria -residuals_options = solver.settings.solution.monitor.residual +residuals_options = solver_session.settings.solution.monitor.residual residuals_options.equations["continuity"].absolute_criteria = 0.0001 residuals_options.equations["continuity"].monitor = True # Enable continuity residuals residuals_options.equations["x-velocity"].absolute_criteria = 0.0001 @@ -281,7 +295,7 @@ # Initialize the solution -initialization = solver.settings.solution.initialization +initialization = solver_session.settings.solution.initialization initialization.reference_frame = "absolute" initialization.initialization_type = "standard" initialization.standard_initialize() @@ -292,8 +306,8 @@ # =========================================================================================================== # Create a report definition for the volume average velocity magnitude -volume_avg_vmag_report_def = solver.settings.solution.report_definitions.volume.create( - "volume-avg-vmag" +volume_avg_vmag_report_def = ( + solver_session.settings.solution.report_definitions.volume.create("volume-avg-vmag") ) volume_avg_vmag_report_def.report_type.allowed_values() # output the allowed values for report type volume_avg_vmag_report_def.report_type = "volume-average" @@ -301,19 +315,23 @@ volume_avg_vmag_report_def.cell_zones = fluid_cell_zones # Report plot -volume_avg_vmag_report_plot = solver.settings.solution.monitor.report_plots.create( - "volume-avg-vmag-rplot" +volume_avg_vmag_report_plot = ( + solver_session.settings.solution.monitor.report_plots.create( + "volume-avg-vmag-rplot" + ) ) volume_avg_vmag_report_plot.report_defs = "volume-avg-vmag" # Report file -volume_avg_vmag_report_file = solver.settings.solution.monitor.report_files.create( - "volume-avg-vmag-rfile" +volume_avg_vmag_report_file = ( + solver_session.settings.solution.monitor.report_files.create( + "volume-avg-vmag-rfile" + ) ) volume_avg_vmag_report_file.report_defs = "volume-avg-vmag" # Create a report definition for the torque on the impeller walls -torque_report_def = solver.settings.solution.report_definitions.moment.create( +torque_report_def = solver_session.settings.solution.report_definitions.moment.create( "torque_imp_walls" ) torque_report_def.report_output_type.allowed_values() # output the allowed values for report output type @@ -322,12 +340,12 @@ torque_report_def.zones = filtered_walls # Report plot -torque_report_plot = solver.settings.solution.monitor.report_plots.create( +torque_report_plot = solver_session.settings.solution.monitor.report_plots.create( "torque_imp_walls_rplot" ) torque_report_plot.report_defs = "torque_imp_walls" # Report file -torque_report_file = solver.settings.solution.monitor.report_files.create( +torque_report_file = solver_session.settings.solution.monitor.report_files.create( "torque_imp_walls_rfile" ) torque_report_file.report_defs = "torque_imp_walls" @@ -335,7 +353,7 @@ # Average and maximum dissipation rate report definitions average_dissipation_rate_report_def = ( - solver.settings.solution.report_definitions.volume.create( + solver_session.settings.solution.report_definitions.volume.create( "average-dissipation-rate" ) ) @@ -344,7 +362,7 @@ average_dissipation_rate_report_def.cell_zones = fluid_cell_zones maximum_dissipation_rate_report_def = ( - solver.settings.solution.report_definitions.volume.create( + solver_session.settings.solution.report_definitions.volume.create( "maximum-dissipation-rate" ) ) @@ -354,7 +372,9 @@ # Average and maximum strain rate report definitions average_strain_rate_report_def = ( - solver.settings.solution.report_definitions.volume.create("average-strain-rate") + solver_session.settings.solution.report_definitions.volume.create( + "average-strain-rate" + ) ) average_strain_rate_report_def.report_type = "volume-average" average_strain_rate_report_def.field = "strain-rate-mag" @@ -362,7 +382,9 @@ maximum_strain_rate_report_def = ( - solver.settings.solution.report_definitions.volume.create("maximum-strain-rate") + solver_session.settings.solution.report_definitions.volume.create( + "maximum-strain-rate" + ) ) maximum_strain_rate_report_def.report_type = "volume-max" maximum_strain_rate_report_def.field = "strain-rate-mag" @@ -373,11 +395,13 @@ # =========================================================================================================== # Run the calculation -run_calculation = solver.settings.solution.run_calculation +run_calculation = solver_session.settings.solution.run_calculation run_calculation.iter_count = 500 # Write the case file -solver.settings.file.write(file_type="case", file_name="mixing_tank_final.cas.h5") +solver_session.settings.file.write( + file_type="case", file_name="mixing_tank_final.cas.h5" +) # Run the calculation run_calculation.calculate() @@ -391,7 +415,7 @@ contour_view.view_name = "top" # Define the contour for velocity magnitude -velocity_contour = solver.settings.results.graphics.contour.create( +velocity_contour = solver_session.settings.results.graphics.contour.create( name="velocity-contour" ) velocity_contour.field = "velocity-magnitude" @@ -412,7 +436,9 @@ ############################################################################################################# # Save the case file # =========================================================================================================== -solver.settings.file.write(file_type="case-data", file_name="mixing_tank_final.cas.h5") +solver_session.settings.file.write( + file_type="case-data", file_name="mixing_tank_final.cas.h5" +) ############################################################################################################# # Close the session diff --git a/examples/00-fluent/modeling_ablation.py b/examples/00-fluent/modeling_ablation.py index 47d969d33282..4529a56c6fec 100644 --- a/examples/00-fluent/modeling_ablation.py +++ b/examples/00-fluent/modeling_ablation.py @@ -97,59 +97,63 @@ # Launch Fluent session with solver mode and print Fluent version # ================================================================================== -solver = pyfluent.launch_fluent( +solver_session = pyfluent.launch_fluent( dimension=3, precision="double", processor_count=4, ) -print(solver.get_fluent_version()) +print(solver_session.get_fluent_version()) #################################################################################### # Import mesh # ================================================================================== -solver.file.read_case(file_name=import_filename) +solver_session.file.read_case(file_name=import_filename) #################################################################################### # Define models # ================================================================================== -solver.setup.general.solver.type = "density-based-implicit" -solver.setup.general.solver.time = "unsteady-1st-order" -solver.setup.general.operating_conditions.operating_pressure = 0.0 -solver.setup.models.energy = {"enabled": True} -solver.setup.models.ablation = {"enabled": True} +solver_session.setup.general.solver.type = "density-based-implicit" +solver_session.setup.general.solver.time = "unsteady-1st-order" +solver_session.setup.general.operating_conditions.operating_pressure = 0.0 +solver_session.setup.models.energy = {"enabled": True} +solver_session.setup.models.ablation = {"enabled": True} ################################################################### # Define material # ================================================================= -solver.setup.materials.fluid["air"] = { +solver_session.setup.materials.fluid["air"] = { "density": {"option": "ideal-gas"}, "molecular_weight": {"value": 28.966, "option": "constant"}, } -solver.setup.materials.fluid["air"] = {"density": {"option": "ideal-gas"}} +solver_session.setup.materials.fluid["air"] = {"density": {"option": "ideal-gas"}} ############################ # Define boundary conditions # ========================== -solver.setup.boundary_conditions.set_zone_type( +solver_session.setup.boundary_conditions.set_zone_type( zone_list=["inlet"], new_type="pressure-far-field" ) -solver.setup.boundary_conditions.pressure_far_field["inlet"].momentum.gauge_pressure = ( - 13500 -) -solver.setup.boundary_conditions.pressure_far_field["inlet"].momentum.mach_number = 3 -solver.setup.boundary_conditions.pressure_far_field["inlet"].thermal.temperature = 4500 -solver.setup.boundary_conditions.pressure_far_field[ +solver_session.setup.boundary_conditions.pressure_far_field[ + "inlet" +].momentum.gauge_pressure = 13500 +solver_session.setup.boundary_conditions.pressure_far_field[ + "inlet" +].momentum.mach_number = 3 +solver_session.setup.boundary_conditions.pressure_far_field[ + "inlet" +].thermal.temperature = 4500 +solver_session.setup.boundary_conditions.pressure_far_field[ "inlet" ].turbulence.turbulent_intensity = 0.001 -solver.setup.boundary_conditions.pressure_outlet["outlet"].momentum.gauge_pressure = ( - 13500 -) -solver.setup.boundary_conditions.pressure_outlet[ +solver_session.setup.boundary_conditions.pressure_outlet[ + "outlet" +].momentum.gauge_pressure = 13500 +solver_session.setup.boundary_conditions.pressure_outlet[ "outlet" ].momentum.prevent_reverse_flow = True @@ -161,18 +165,22 @@ # Remeshing options, #creates the wall-ablation dynamic mesh zone, and configure # appropriate dynamic mesh settings. -solver.setup.boundary_conditions.wall[ +solver_session.setup.boundary_conditions.wall[ "wall_ablation" ].ablation.ablation_select_model = "Vielle's Model" -solver.setup.boundary_conditions.wall["wall_ablation"].ablation.ablation_vielle_a = 5 -solver.setup.boundary_conditions.wall["wall_ablation"].ablation.ablation_vielle_n = 0.1 +solver_session.setup.boundary_conditions.wall[ + "wall_ablation" +].ablation.ablation_vielle_a = 5 +solver_session.setup.boundary_conditions.wall[ + "wall_ablation" +].ablation.ablation_vielle_n = 0.1 ############################## # Define dynamic mesh controls # ============================ -solver.tui.define.dynamic_mesh.dynamic_mesh("yes") -solver.tui.define.dynamic_mesh.zones.create( +solver_session.tui.define.dynamic_mesh.dynamic_mesh("yes") +solver_session.tui.define.dynamic_mesh.zones.create( "interior--flow", "deforming", "faceted", @@ -185,7 +193,7 @@ "no", "yes", ) -solver.tui.define.dynamic_mesh.zones.create( +solver_session.tui.define.dynamic_mesh.zones.create( "outlet", "deforming", "faceted", @@ -198,7 +206,7 @@ "0.1", "yes", ) -solver.tui.define.dynamic_mesh.zones.create( +solver_session.tui.define.dynamic_mesh.zones.create( "symm1", "deforming", "plane", @@ -217,7 +225,7 @@ "0.1", "yes", ) -solver.tui.define.dynamic_mesh.zones.create( +solver_session.tui.define.dynamic_mesh.zones.create( "symm2", "deforming", "plane", @@ -236,7 +244,7 @@ "0.1", "yes", ) -solver.tui.define.dynamic_mesh.zones.create( +solver_session.tui.define.dynamic_mesh.zones.create( "wall_ablation", "user-defined", "**ablation**", @@ -256,68 +264,78 @@ # Define solver settings # ======================= -solver.setup.general.solver.time = "unsteady-2nd-order" -solver.solution.controls.limits = {"max_temperature": 25000} -solver.solution.monitor.residual.equations["energy"].absolute_criteria = 1e-06 +solver_session.setup.general.solver.time = "unsteady-2nd-order" +solver_session.solution.controls.limits = {"max_temperature": 25000} +solver_session.solution.monitor.residual.equations["energy"].absolute_criteria = 1e-06 ############################################ # Create report definitions # ========================== -solver.solution.report_definitions.drag["drag_force_x"] = {} -solver.solution.report_definitions.drag["drag_force_x"].zones = ["wall_ablation"] +solver_session.solution.report_definitions.drag["drag_force_x"] = {} +solver_session.solution.report_definitions.drag["drag_force_x"].zones = [ + "wall_ablation" +] -solver.solution.monitor.report_plots.create(name="drag_force_x") -solver.solution.monitor.report_plots["drag_force_x"].report_defs = "drag_force_x" -solver.tui.solve.report_plots.axes( +solver_session.solution.monitor.report_plots.create(name="drag_force_x") +solver_session.solution.monitor.report_plots["drag_force_x"].report_defs = ( + "drag_force_x" +) +solver_session.tui.solve.report_plots.axes( "drag_force_x", "numbers", "float", "4", "exponential", "2", "q" ) -solver.solution.monitor.report_files.create(name="drag_force_x") -solver.solution.monitor.report_files["drag_force_x"] = { +solver_session.solution.monitor.report_files.create(name="drag_force_x") +solver_session.solution.monitor.report_files["drag_force_x"] = { "report_defs": ["drag_force_x"], "file_name": r"drag_force_x.out", } -solver.solution.report_definitions.surface["pressure_avg_abl_wall"] = {} -solver.solution.report_definitions.surface["pressure_avg_abl_wall"].report_type = ( - "surface-areaavg" +solver_session.solution.report_definitions.surface["pressure_avg_abl_wall"] = {} +solver_session.solution.report_definitions.surface[ + "pressure_avg_abl_wall" +].report_type = "surface-areaavg" +solver_session.solution.report_definitions.surface["pressure_avg_abl_wall"].field = ( + "pressure" ) -solver.solution.report_definitions.surface["pressure_avg_abl_wall"].field = "pressure" -solver.solution.report_definitions.surface["pressure_avg_abl_wall"].surface_names = [ - "wall_ablation" -] +solver_session.solution.report_definitions.surface[ + "pressure_avg_abl_wall" +].surface_names = ["wall_ablation"] -solver.solution.monitor.report_plots.create(name="pressure_avg_abl_wall") -solver.solution.monitor.report_plots["pressure_avg_abl_wall"].report_defs = ( +solver_session.solution.monitor.report_plots.create(name="pressure_avg_abl_wall") +solver_session.solution.monitor.report_plots["pressure_avg_abl_wall"].report_defs = ( "pressure_avg_abl_wall" ) -solver.tui.solve.report_plots.axes( +solver_session.tui.solve.report_plots.axes( "pressure_avg_abl_wall", "numbers", "float", "4", "exponential", "2", "q" ) -solver.solution.monitor.report_files.create(name="pressure_avg_abl_wall") -solver.solution.monitor.report_files["pressure_avg_abl_wall"] = { +solver_session.solution.monitor.report_files.create(name="pressure_avg_abl_wall") +solver_session.solution.monitor.report_files["pressure_avg_abl_wall"] = { "report_defs": ["pressure_avg_abl_wall"], "file_name": r"pressure_avg_abl_wall.out", } -solver.solution.report_definitions.surface["recede_point"] = {} -solver.solution.report_definitions.surface["recede_point"].report_type = ( +solver_session.solution.report_definitions.surface["recede_point"] = {} +solver_session.solution.report_definitions.surface["recede_point"].report_type = ( "surface-vertexmax" ) -solver.solution.report_definitions.surface["recede_point"].field = "z-coordinate" -solver.solution.report_definitions.surface["recede_point"].surface_names = [ +solver_session.solution.report_definitions.surface["recede_point"].field = ( + "z-coordinate" +) +solver_session.solution.report_definitions.surface["recede_point"].surface_names = [ "wall_ablation" ] -solver.solution.monitor.report_plots.create(name="recede_point") -solver.solution.monitor.report_plots["recede_point"].report_defs = "recede_point" -solver.tui.solve.report_plots.axes( +solver_session.solution.monitor.report_plots.create(name="recede_point") +solver_session.solution.monitor.report_plots["recede_point"].report_defs = ( + "recede_point" +) +solver_session.tui.solve.report_plots.axes( "recede_point", "numbers", "float", "4", "exponential", "2", "q" ) -solver.solution.monitor.report_files.create(name="recede_point") -solver.solution.monitor.report_files["recede_point"] = { +solver_session.solution.monitor.report_files.create(name="recede_point") +solver_session.solution.monitor.report_files["recede_point"] = { "report_defs": ["recede_point"], "file_name": r"recede_point.out", } @@ -326,19 +344,19 @@ # Initialize and Save case # ======================== -solver.tui.solve.initialize.compute_defaults.pressure_far_field("inlet") -solver.solution.initialization.initialization_type = "standard" -solver.solution.initialization.standard_initialize() -solver.solution.run_calculation.transient_controls.time_step_size = 1e-06 +solver_session.tui.solve.initialize.compute_defaults.pressure_far_field("inlet") +solver_session.solution.initialization.initialization_type = "standard" +solver_session.solution.initialization.standard_initialize() +solver_session.solution.run_calculation.transient_controls.time_step_size = 1e-06 -solver.file.write(file_type="case", file_name="ablation.cas.h5") +solver_session.file.write(file_type="case", file_name="ablation.cas.h5") ############################################ # Run the calculation # =================== # Note: It may take about half an hour to finish the calculation. -solver.solution.run_calculation.dual_time_iterate( +solver_session.solution.run_calculation.dual_time_iterate( time_step_count=100, max_iter_per_step=20 ) @@ -346,7 +364,7 @@ # Save simulation data # ==================== # Write case and data files -solver.file.write(file_type="case-data", file_name="ablation_Solved.cas.h5") +solver_session.file.write(file_type="case-data", file_name="ablation_Solved.cas.h5") #################################################################################### # Post Processing @@ -393,22 +411,22 @@ # ================ # Following contours are displayed in the Fluent GUI: -solver.results.surfaces.plane_surface.create(name="mid_plane") -solver.results.surfaces.plane_surface["mid_plane"].method = "zx-plane" +solver_session.results.surfaces.plane_surface.create(name="mid_plane") +solver_session.results.surfaces.plane_surface["mid_plane"].method = "zx-plane" -solver.results.graphics.contour.create(name="contour_pressure") -solver.results.graphics.contour["contour_pressure"] = { +solver_session.results.graphics.contour.create(name="contour_pressure") +solver_session.results.graphics.contour["contour_pressure"] = { "field": "pressure", "surfaces_list": ["mid_plane"], } -solver.results.graphics.contour.display(object_name="contour_pressure") +solver_session.results.graphics.contour.display(object_name="contour_pressure") -solver.results.graphics.contour.create(name="contour_mach") -solver.results.graphics.contour["contour_mach"] = { +solver_session.results.graphics.contour.create(name="contour_mach") +solver_session.results.graphics.contour["contour_mach"] = { "field": "mach-number", "surfaces_list": ["mid_plane"], } -solver.results.graphics.contour.display(object_name="contour_mach") +solver_session.results.graphics.contour.display(object_name="contour_mach") ############################################### # Post processing with PyVista (3D visualization) @@ -416,7 +434,7 @@ # Following graphics is displayed in the a new window/notebook -contour1 = Contour(solver=solver, field="pressure", surfaces=["mid_plane"]) +contour1 = Contour(solver=solver_session, field="pressure", surfaces=["mid_plane"]) window = GraphicsWindow() window.add_graphics(contour1) @@ -449,6 +467,6 @@ # Close the session # ================================================================================== -solver.exit() +solver_session.exit() # sphinx_gallery_thumbnail_path = '_static/ablation-mach-number-thumbnail.png' diff --git a/examples/00-fluent/modeling_cavitation.py b/examples/00-fluent/modeling_cavitation.py index 5cc7e0ab07be..eb68324dbbfe 100644 --- a/examples/00-fluent/modeling_cavitation.py +++ b/examples/00-fluent/modeling_cavitation.py @@ -73,37 +73,37 @@ # Launch a Fluent session in the 2d solution mode with double precision running # on four processors and print Fluent version. -solver = pyfluent.launch_fluent( +solver_session = pyfluent.launch_fluent( precision="double", processor_count=4, mode="solver", version="2d", ) -print(solver.get_fluent_version()) +print(solver_session.get_fluent_version()) ############################################################################### # Read the mesh that was downloaded. -solver.file.read_mesh(file_name=cav_file) +solver_session.file.read_mesh(file_name=cav_file) -solver.mesh.check() +solver_session.mesh.check() ############################################################################### # Specify an axisymmetric model. -solver.setup.general.solver.two_dim_space = "axisymmetric" +solver_session.setup.general.solver_session.two_dim_space = "axisymmetric" ############################################################################### # Enable the multiphase mixture model. -solver.setup.models.multiphase.models = "mixture" +solver_session.setup.models.multiphase.models = "mixture" -solver.tui.define.models.multiphase.mixture_parameters("no", "implicit") +solver_session.tui.define.models.multiphase.mixture_parameters("no", "implicit") ############################################################################### # Enable the k-ω SST turbulence model. -solver.setup.models.viscous = { +solver_session.setup.models.viscous = { "model": "k-omega", "k_omega_model": "sst", } @@ -116,7 +116,7 @@ # the copy by changing the density to 0.02558 kg/m3 and the viscosity to # 1.26e-06 kg/m–s. -solver.setup.materials.fluid["water"] = { +solver_session.setup.materials.fluid["water"] = { "density": { "option": "constant", "value": 1000, @@ -127,9 +127,9 @@ }, } -solver.setup.materials.database.copy_by_name(type="fluid", name="water-vapor") +solver_session.setup.materials.database.copy_by_name(type="fluid", name="water-vapor") -solver.setup.materials.fluid["water-vapor"] = { +solver_session.setup.materials.fluid["water-vapor"] = { "density": {"value": 0.02558}, "viscosity": {"value": 1.26e-06}, } @@ -142,17 +142,19 @@ # transfer mechanisms to 1. Finally, specify cavitation as a mass transfer # mechanism occurring from the liquid to the vapor. -solver.tui.define.phases.set_domain_properties.change_phases_names("vapor", "liquid") +solver_session.tui.define.phases.set_domain_properties.change_phases_names( + "vapor", "liquid" +) -solver.tui.define.phases.set_domain_properties.phase_domains.liquid.material( +solver_session.tui.define.phases.set_domain_properties.phase_domains.liquid.material( "yes", "water" ) -solver.tui.define.phases.set_domain_properties.phase_domains.vapor.material( +solver_session.tui.define.phases.set_domain_properties.phase_domains.vapor.material( "yes", "water-vapor" ) -solver.tui.define.phases.set_domain_properties.interaction_domain.heat_mass_reactions.mass_transfer( +solver_session.tui.define.phases.set_domain_properties.interaction_domain.heat_mass_reactions.mass_transfer( 1, "liquid", "vapor", "cavitation", "1", "no", "no", "no" ) @@ -167,7 +169,7 @@ # turbulent specification. Set turbulent intensity and turbulent viscosity # ratio to 0.05 and 10 respectively. -inlet_1 = solver.setup.boundary_conditions.pressure_inlet["inlet_1"].phase +inlet_1 = solver_session.setup.boundary_conditions.pressure_inlet["inlet_1"].phase inlet_1["mixture"] = { "momentum": { @@ -192,13 +194,13 @@ }, } -solver.setup.boundary_conditions.copy(from_="inlet_1", to="inlet_2") +solver_session.setup.boundary_conditions.copy(from_="inlet_1", to="inlet_2") ############################################################################### # For the outlet boundary conditions, set the gauge pressure as 95 kPa. Use # the same turbulence and volume fraction settings as the inlets. -outlet = solver.setup.boundary_conditions.pressure_outlet["outlet"].phase +outlet = solver_session.setup.boundary_conditions.pressure_outlet["outlet"].phase outlet["mixture"] = { "momentum": { @@ -222,7 +224,7 @@ # ~~~~~~~~~~~~~~~~~~~~ # Set the operating pressure to 0. -solver.setup.general.operating_conditions.operating_pressure = 0 +solver_session.setup.general.operating_conditions.operating_pressure = 0 ############################################################################### # Solution @@ -231,7 +233,7 @@ # upwind' method for turbulent kinetic energy and turbulent dissipation rate, 'quick' # for the momentum and volume fraction, and 'presto!' for pressure. -methods = solver.solution.methods +methods = solver_session.solution.methods methods.discretization_scheme = { "k": "first-order-upwind", @@ -253,7 +255,7 @@ methods.high_order_term_relaxation.enable = True -solver.solution.controls.pseudo_time_explicit_relaxation_factor.global_dt_pseudo_relax[ +solver_session.solution.controls.pseudo_time_explicit_relaxation_factor.global_dt_pseudo_relax[ "mp" ] = 0.3 @@ -262,7 +264,7 @@ # 1e-05 for x-velocity, y-velocity, k, omega, and vf-vapor. Enable the specified # initial pressure then initialize the solution with hybrid initialization. -resid_eqns = solver.solution.monitor.residual.equations +resid_eqns = solver_session.solution.monitor.residual.equations resid_eqns["continuity"].absolute_criteria = 1e-5 resid_eqns["x-velocity"].absolute_criteria = 1e-5 @@ -271,7 +273,7 @@ resid_eqns["omega"].absolute_criteria = 1e-5 resid_eqns["vf-vapor"].absolute_criteria = 1e-5 -initialization = solver.solution.initialization +initialization = solver_session.solution.initialization initialization.initialization_type = "hybrid" initialization.hybrid_init_options.general_settings.initial_pressure = True @@ -283,11 +285,11 @@ # Save the case file 'cav.cas.h5'. Then, start the calculation by requesting # 500 iterations. Save the final case file and the data. -solver.file.write_case(file_name="cav.cas.h5") +solver_session.file.write_case(file_name="cav.cas.h5") -solver.solution.run_calculation.iterate(iter_count=500) +solver_session.solution.run_calculation.iterate(iter_count=500) -solver.file.write_case_data(file_name="cav.cas.h5") +solver_session.file.write_case_data(file_name="cav.cas.h5") ############################################################################### # Post Processing @@ -296,7 +298,7 @@ # picture files. Edit the picture settings to use a custom resolution so that # the images are large enough. -graphics = solver.results.graphics +graphics = solver_session.results.graphics # use_window_resolution option not active inside containers or Ansys Lab environment if graphics.picture.use_window_resolution.is_active(): graphics.picture.use_window_resolution = False @@ -311,7 +313,7 @@ # volume fraction of water vapor. For each plot enable banded coloring and # filled option. -graphics = solver.results.graphics +graphics = solver_session.results.graphics graphics.contour["contour_static_pressure"] = { "coloring": { @@ -325,7 +327,7 @@ ############################################################################### # Mirror the display around the symmetry plane to show the full model. -solver.settings.results.graphics.views.mirror_zones = ["symm_2", "symm_1"] +solver_session.settings.results.graphics.views.mirror_zones = ["symm_2", "symm_1"] graphics.contour["contour_static_pressure"].display() @@ -378,6 +380,6 @@ # Save case to 'cav.cas.h5' and exit -solver.settings.file.write_case(file_name="cav.cas.h5") +solver_session.settings.file.write_case(file_name="cav.cas.h5") -solver.exit() +solver_session.exit() diff --git a/examples/00-fluent/radiation_headlamp.py b/examples/00-fluent/radiation_headlamp.py index 32564cfadb6d..088f78b5438b 100644 --- a/examples/00-fluent/radiation_headlamp.py +++ b/examples/00-fluent/radiation_headlamp.py @@ -82,19 +82,19 @@ # Launch Fluent as a service in meshing mode with single precision running on # four processors and print Fluent version. -meshing = pyfluent.launch_fluent( +meshing_session = pyfluent.launch_fluent( precision="single", processor_count=4, mode="meshing", ) -print(meshing.get_fluent_version()) +print(meshing_session.get_fluent_version()) ############################################################################### # Initialize workflow # ~~~~~~~~~~~~~~~~~~~ # Initialize the watertight geometry meshing workflow. -meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry") +meshing_session.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry") ############################################################################### # Watertight geometry meshing workflow @@ -106,7 +106,7 @@ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Import the CAD geometry and set the length units to millimeters. -geo_import = meshing.workflow.TaskObject["Import Geometry"] +geo_import = meshing_session.workflow.TaskObject["Import Geometry"] geo_import.Arguments.set_state( { "FileName": headlamp_pmdb_file, @@ -121,7 +121,7 @@ # ~~~~~~~~~~~~~~~~ # Add local sizing controls to the geometry. -local_sizing = meshing.workflow.TaskObject["Add Local Sizing"] +local_sizing = meshing_session.workflow.TaskObject["Add Local Sizing"] local_sizing.Arguments.set_state( { "AddChild": "yes", @@ -151,7 +151,7 @@ # ~~~~~~~~~~~~~~~~~~~~~ # Generate the surface mesh. -surface_mesh_gen = meshing.workflow.TaskObject["Generate the Surface Mesh"] +surface_mesh_gen = meshing_session.workflow.TaskObject["Generate the Surface Mesh"] surface_mesh_gen.Arguments.set_state( { "CFDSurfaceMeshControls": { @@ -170,14 +170,14 @@ surface_mesh_gen.InsertNextTask(CommandName="ImproveSurfaceMesh") -meshing.workflow.TaskObject["Improve Surface Mesh"].Execute() +meshing_session.workflow.TaskObject["Improve Surface Mesh"].Execute() ############################################################################### # Describe geometry # ~~~~~~~~~~~~~~~~~ # Describe geometry and define the fluid region. -describe_geo = meshing.workflow.TaskObject["Describe Geometry"] +describe_geo = meshing_session.workflow.TaskObject["Describe Geometry"] describe_geo.Arguments.set_state( { "SetupType": "The geometry consists of both fluid and solid regions and/or voids", @@ -195,7 +195,7 @@ # ~~~~~~~~~~~~~~~~~ # Update the boundaries. -update_bc = meshing.workflow.TaskObject["Update Boundaries"] +update_bc = meshing_session.workflow.TaskObject["Update Boundaries"] update_bc.Arguments.set_state( { "BoundaryLabelList": ["rad-input"], @@ -210,7 +210,7 @@ # ~~~~~~~~~~~~~~~~~~~ # Create the fluid region. -create_regions = meshing.workflow.TaskObject["Create Regions"] +create_regions = meshing_session.workflow.TaskObject["Create Regions"] create_regions.Arguments.set_state({"NumberOfFlowVolumes": 1}) create_regions.Execute() @@ -220,14 +220,14 @@ # ~~~~~~~~~~~~~~ # Update the regions. -meshing.workflow.TaskObject["Update Regions"].Execute() +meshing_session.workflow.TaskObject["Update Regions"].Execute() ############################################################################### # Boundary layers # ~~~~~~~~~~~~~~~~~~~ # Do not add boundary layers and proceed to the next task. -add_boundary_layers = meshing.workflow.TaskObject["Add Boundary Layers"] +add_boundary_layers = meshing_session.workflow.TaskObject["Add Boundary Layers"] add_boundary_layers.Arguments.set_state({"AddChild": "no"}) add_boundary_layers.Execute() @@ -238,7 +238,7 @@ # Generate the volume mesh, which consists of setting properties for the # volume mesh. -volume_mesh_gen = meshing.workflow.TaskObject["Generate the Volume Mesh"] +volume_mesh_gen = meshing_session.workflow.TaskObject["Generate the Volume Mesh"] volume_mesh_gen.Arguments.set_state( { "VolumeMeshPreferences": { @@ -253,14 +253,14 @@ # ~~~~~~~~~~~~~~~~~~~~~~~~~~ # Check the mesh in meshing mode. -meshing.tui.mesh.check_mesh() +meshing_session.tui.mesh.check_mesh() ############################################################################### # Save mesh file # ~~~~~~~~~~~~~~ # Save the mesh file (``headlamp.msh.h5``). -meshing.meshing.File.WriteMesh(FileName="headlamp.msh.h5") +meshing_session.meshing.File.WriteMesh(FileName="headlamp.msh.h5") ############################################################################### # Solve and postprocess @@ -274,14 +274,14 @@ # using Fluent in meshing mode, you can switch to solver mode to complete the # setup of the simulation. -solver = meshing.switch_to_solver() +solver_session = meshing_session.switch_to_solver() ############################################################################### # Enable energy and viscosity models # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Set up the energy and viscosity models. -models = solver.settings.setup.models +models = solver_session.settings.setup.models models.energy.enabled = True models.viscous.model = "laminar" @@ -312,7 +312,7 @@ # Absorption coefficient: 5.302 # Refractive index: 1.4714 -glass = solver.settings.setup.materials.solid.create("glass") +glass = solver_session.settings.setup.materials.solid.create("glass") glass.set_state( { "chemical_formula": "", @@ -344,7 +344,7 @@ # Specific heat capacity: 2302 [J/(kg K)] # Thermal conductivity: 0.316 [W/(m K)] -plastic = solver.settings.setup.materials.solid.create("plastic") +plastic = solver_session.settings.setup.materials.solid.create("plastic") plastic.chemical_formula = "" plastic.density.value = 1545.3 plastic.specific_heat.value = 2302 @@ -357,8 +357,8 @@ # ~~~~~~~~~~~~~~~~~~~~ # Set the cell zone conditions for the bezel and the lens. -solver.settings.setup.cell_zone_conditions.solid["bezel"].material = "plastic" -solver.settings.setup.cell_zone_conditions.copy( +solver_session.settings.setup.cell_zone_conditions.solid["bezel"].material = "plastic" +solver_session.settings.setup.cell_zone_conditions.copy( from_="bezel", to=[ "holder", @@ -370,7 +370,7 @@ ], ) -lens_cellzone_conds = solver.settings.setup.cell_zone_conditions.solid["lens"] +lens_cellzone_conds = solver_session.settings.setup.cell_zone_conditions.solid["lens"] lens_cellzone_conds.material = "glass" lens_cellzone_conds.general.participates_in_radiation = True @@ -385,21 +385,21 @@ # Internal emissivity: 1 # Diffuse fraction: 1 -bezel_enc_bc = solver.settings.setup.boundary_conditions.wall["bezel-enclosure"] +bezel_enc_bc = solver_session.settings.setup.boundary_conditions.wall["bezel-enclosure"] bezel_enc_bc.thermal.material = "plastic" bezel_enc_bc.radiation.radiation_bc = "Opaque" bezel_enc_bc.radiation.internal_emissivity = 1 bezel_enc_bc.radiation.diffuse_irradiation_settings.diffuse_fraction_band = {"s-": 1} # Get list of wall zones -bc_state = solver.settings.setup.boundary_conditions.get_state() +bc_state = solver_session.settings.setup.boundary_conditions.get_state() zones_to_copy = list(bc_state["wall"].keys()) incompatible_zones = ["bezel-enclosure", "enclosure:1", "rad-input"] for incompatible_zone in incompatible_zones: zones_to_copy.remove(incompatible_zone) # Copy bezel-enclosure BC to all other BCs -solver.settings.setup.boundary_conditions.copy( +solver_session.settings.setup.boundary_conditions.copy( from_="bezel-enclosure", to=zones_to_copy, ) @@ -409,13 +409,13 @@ # BC type: semi-transparent # Diffuse fraction: 0 -enc_lens_bc = solver.settings.setup.boundary_conditions.wall["enclosure-lens"] +enc_lens_bc = solver_session.settings.setup.boundary_conditions.wall["enclosure-lens"] enc_lens_bc.thermal.material = "glass" enc_lens_bc.radiation.radiation_bc = "Semi Transparent" enc_lens_bc.radiation.diffuse_irradiation_settings.diffuse_fraction_band = {"s-": 0} # Copy enclosure-lens BC to other lens boundary -solver.settings.setup.boundary_conditions.copy( +solver_session.settings.setup.boundary_conditions.copy( from_="enclosure-lens", to=["enclosure-lens-shadow"], ) @@ -426,7 +426,9 @@ # Internal emissivity: 0.16 # Diffuse fraction: 0.1 -enc_rim_bezel_bc = solver.settings.setup.boundary_conditions.wall["enclosure-rim-bezel"] +enc_rim_bezel_bc = solver_session.settings.setup.boundary_conditions.wall[ + "enclosure-rim-bezel" +] enc_rim_bezel_bc.thermal.material = "plastic" enc_rim_bezel_bc.radiation.radiation_bc = "Opaque" enc_rim_bezel_bc.radiation.internal_emissivity = 0.16 @@ -435,7 +437,7 @@ } # Copy enclosure-rim-bezel BC to other rim bezel boundaries -solver.settings.setup.boundary_conditions.copy( +solver_session.settings.setup.boundary_conditions.copy( from_="enclosure-rim-bezel", to=[ "enclosure-rim-bezel-shadow", @@ -450,7 +452,7 @@ # BC type: temperature # Temperature: 298.15 [K] -enc1_bc = solver.settings.setup.boundary_conditions.wall["enclosure:1"] +enc1_bc = solver_session.settings.setup.boundary_conditions.wall["enclosure:1"] enc1_bc.thermal.thermal_condition = "Temperature" enc1_bc.thermal.temperature.value = 298.15 @@ -461,7 +463,7 @@ # Direct irradiation: 1200 [W/m^2] # Radiation direction: (-0.848, 0, -0.53) -rad_input_bc = solver.settings.setup.boundary_conditions.wall["rad-input"] +rad_input_bc = solver_session.settings.setup.boundary_conditions.wall["rad-input"] rad_input_bc.thermal.thermal_condition = "Temperature" rad_input_bc.thermal.temperature.value = 298.15 rad_input_bc.radiation.boundary_source = True @@ -477,7 +479,7 @@ # ~~~~~~~~~~~~~~~~~~~~~~~~ # Enable residual plots and set the convergence criteria to 'none'. -solver.solution.monitor.residual.options.criterion_type = "none" +solver_session.solution.monitor.residual.options.criterion_type = "none" ########################################################################################################### # Define surface reports @@ -485,14 +487,16 @@ # Define a surface report to find the maximum temperature of the inner bezel, # then print the state of the report object. -solver.settings.solution.report_definitions.surface["max-temp"] = {} -max_temp_surf_report = solver.settings.solution.report_definitions.surface["max-temp"] +solver_session.settings.solution.report_definitions.surface["max-temp"] = {} +max_temp_surf_report = solver_session.settings.solution.report_definitions.surface[ + "max-temp" +] max_temp_surf_report.surface_names = ["enclosure-inner-bezel"] max_temp_surf_report.report_type = "surface-facetmax" max_temp_surf_report.field = "temperature" -solver.settings.solution.monitor.report_plots["max-temp-rplot"] = {} -max_temp_surf_report_plot = solver.settings.solution.monitor.report_plots[ +solver_session.settings.solution.monitor.report_plots["max-temp-rplot"] = {} +max_temp_surf_report_plot = solver_session.settings.solution.monitor.report_plots[ "max-temp-rplot" ] max_temp_surf_report_plot.report_defs = "max-temp" @@ -503,8 +507,8 @@ # ~~~~~~~~~~~~~~~~~~~ # Define a plot of the maximum temperature. -solver.settings.solution.monitor.report_plots["max-temp-rplot"] = {} -max_temp_rplot = solver.settings.solution.monitor.report_plots["max-temp-rplot"] +solver_session.settings.solution.monitor.report_plots["max-temp-rplot"] = {} +max_temp_rplot = solver_session.settings.solution.monitor.report_plots["max-temp-rplot"] max_temp_rplot.report_defs = "max-temp" max_temp_rplot.print = True @@ -513,14 +517,14 @@ # ~~~~~~~~~~~~~~ # Save the case file (``headlamp.cas.h5``). -solver.settings.file.write(file_name="headlamp.cas.h5", file_type="case") +solver_session.settings.file.write(file_name="headlamp.cas.h5", file_type="case") ############################################################################### # Initialize flow field # ~~~~~~~~~~~~~~~~~~~~~ # Initialize the solution. -solver.settings.solution.initialization.initialize() +solver_session.settings.solution.initialization.initialize() ############################################################################### # Solve for 19 iterations @@ -528,7 +532,7 @@ # Solve for 19 iterations. 99 iterations is recommended by the tutorial, but is # reduced to 19 for this example for demonstration purposes. -solver.settings.solution.run_calculation.iterate(iter_count=19) +solver_session.settings.solution.run_calculation.iterate(iter_count=19) ############################################################################### # Write final case file and data @@ -536,14 +540,14 @@ # Enable overwrite so that the original case file will be overwritten. Write # the final case file and the data. -solver.settings.file.batch_options.confirm_overwrite = True -solver.settings.file.write(file_name="headlamp.cas.h5", file_type="case-data") +solver_session.settings.file.batch_options.confirm_overwrite = True +solver_session.settings.file.write(file_name="headlamp.cas.h5", file_type="case-data") ############################################################################### # Close Fluent # ~~~~~~~~~~~~ # Close Fluent. -solver.exit() +solver_session.exit() ############################################################################### diff --git a/examples/00-fluent/species_transport.py b/examples/00-fluent/species_transport.py index c490641f257e..48f54ac2b0c0 100644 --- a/examples/00-fluent/species_transport.py +++ b/examples/00-fluent/species_transport.py @@ -83,8 +83,8 @@ import ansys.fluent.core as pyfluent -solver = pyfluent.launch_fluent(dimension=2) -print(solver.get_fluent_version()) +solver_session = pyfluent.launch_fluent(dimension=2) +print(solver_session.get_fluent_version()) # %% # Import some direct settings classes which will be used in the following sections. @@ -113,7 +113,7 @@ # Download the mesh file and read it into the Fluent session. mesh_file = download_file("gascomb.msh.gz", "pyfluent/tutorials/species_transport") -solver.settings.file.read_mesh(file_name=mesh_file) +solver_session.settings.file.read_mesh(file_name=mesh_file) # %% # General Settings @@ -123,7 +123,7 @@ # Fluent will perform various checks on the mesh and will report the progress in the console. # Ensure that the reported minimum volume reported is a positive number. -solver.settings.mesh.check() +solver_session.settings.mesh.check() # %% # Scale the mesh and check it again. @@ -135,16 +135,16 @@ # We should check the mesh after we manipulate it (scale, convert to polyhedra, merge, separate, fuse, add zones, or smooth and swap). # This will ensure that the quality of the mesh has not been compromised. -solver.settings.mesh.scale(x_scale=0.001, y_scale=0.001) -solver.settings.mesh.check() +solver_session.settings.mesh.scale(x_scale=0.001, y_scale=0.001) +solver_session.settings.mesh.check() # %% # Display the mesh in Fluent and save the image to a file to examine locally. -mesh = Mesh(solver, new_instance_name="mesh") +mesh = Mesh(solver_session, new_instance_name="mesh") mesh.surfaces_list = mesh.surfaces_list.allowed_values() mesh.display() -graphics = solver.settings.results.graphics +graphics = solver_session.settings.results.graphics graphics.views.auto_scale() if graphics.picture.use_window_resolution.is_active(): graphics.picture.use_window_resolution = False @@ -163,28 +163,28 @@ # %% # Inspect the available options for the two-dimensional space setting and set it to axisymmetric. -solver.settings.setup.general.solver.two_dim_space.allowed_values() +solver_session.settings.setup.general.solver.two_dim_space.allowed_values() # %% -solver.settings.setup.general.solver.two_dim_space = "axisymmetric" +solver_session.settings.setup.general.solver.two_dim_space = "axisymmetric" # %% # Models # ^^^^^^ # Enable heat transfer by enabling the energy model. -Energy(solver).enabled = True +Energy(solver_session).enabled = True # %% # Inspect the default settings for the k-ω SST viscous model. -Viscous(solver).print_state() +Viscous(solver_session).print_state() # %% # Inspect the available options for the species model and set it to species transport. -species = Species(solver) +species = Species(solver_session) species.model.option.allowed_values() # %% @@ -236,14 +236,14 @@ # Print some specific properties of the mixture material (methane-air). # We avoid printing the entire state of the mixture material to keep the output concise. -mixture_material = MixtureMaterial(solver, name="methane-air") +mixture_material = MixtureMaterial(solver_session, name="methane-air") print(f"Species list: {mixture_material.species.volumetric_species.get_object_names()}") print(f"Reactions option: {mixture_material.reactions.option()}") print(f"Density option: {mixture_material.density.option()}") print(f"Cp (specific heat) option: {mixture_material.specific_heat.option()}") print(f"Thermal conductivity value: {mixture_material.thermal_conductivity.value()}") print(f"Viscosity value: {mixture_material.viscosity.value()}") -if solver.get_fluent_version() < FluentVersion.v252: +if solver_session.get_fluent_version() < FluentVersion.v252: print(f"Mass diffusivity value: {mixture_material.mass_diffusivity.value()}") else: print( @@ -257,7 +257,7 @@ # # *The symmetry zone must be converted to an axis to prevent numerical difficulties where the radius reduces to zero.* -solver.settings.setup.boundary_conditions.set_zone_type( +solver_session.settings.setup.boundary_conditions.set_zone_type( zone_list=["symmetry-5"], new_type="axis" ) @@ -268,9 +268,9 @@ # # *This name is more descriptive for the zone than velocity-inlet-8.* -solver.settings.setup.boundary_conditions.velocity_inlet["velocity-inlet-8"].rename( - "air-inlet" -) +solver_session.settings.setup.boundary_conditions.velocity_inlet[ + "velocity-inlet-8" +].rename("air-inlet") # %% # Set the following boundary conditions for the air-inlet: @@ -285,7 +285,7 @@ # # * Species mass fraction for o2: 0.23 -air_inlet = VelocityInlet(solver, name="air-inlet") +air_inlet = VelocityInlet(solver_session, name="air-inlet") air_inlet.momentum.velocity_magnitude = 0.5 air_inlet.turbulence.turbulence_specification = "Intensity and Hydraulic Diameter" air_inlet.turbulence.turbulent_intensity = 0.1 @@ -305,9 +305,9 @@ # # *This name is more descriptive for the zone than velocity-inlet-6.* -solver.settings.setup.boundary_conditions.velocity_inlet["velocity-inlet-6"].rename( - "fuel-inlet" -) +solver_session.settings.setup.boundary_conditions.velocity_inlet[ + "velocity-inlet-6" +].rename("fuel-inlet") # %% # Set the following boundary conditions for the fuel-inlet: @@ -322,7 +322,7 @@ # # * Species mass fraction for ch4: 1 -fuel_inlet = VelocityInlet(solver, name="fuel-inlet") +fuel_inlet = VelocityInlet(solver_session, name="fuel-inlet") fuel_inlet.momentum.velocity_magnitude = 80 fuel_inlet.turbulence.turbulence_specification = "Intensity and Hydraulic Diameter" fuel_inlet.turbulence.turbulent_intensity = 0.1 @@ -351,7 +351,7 @@ # *The Backflow values in the pressure outlet boundary condition are utilized only when backflow occurs at the pressure outlet. # Always assign reasonable values because backflow may occur during intermediate iterations and could affect the solution stability.* -pressure_outlet = PressureOutlet(solver, name="pressure-outlet-9") +pressure_outlet = PressureOutlet(solver_session, name="pressure-outlet-9") pressure_outlet.momentum.gauge_pressure = 0 pressure_outlet.turbulence.turbulence_specification = "Intensity and Hydraulic Diameter" pressure_outlet.turbulence.backflow_turbulent_intensity = 0.1 @@ -371,14 +371,14 @@ # # *This name is more descriptive for the zone than wall-7.* -solver.settings.setup.boundary_conditions.wall["wall-7"].rename("outer-wall") +solver_session.settings.setup.boundary_conditions.wall["wall-7"].rename("outer-wall") # %% # Set the following boundary conditions for the outer-wall: # # * Temperature: 300 K -outer_wall = WallBoundary(solver, name="outer-wall") +outer_wall = WallBoundary(solver_session, name="outer-wall") outer_wall.thermal.thermal_condition = "Temperature" outer_wall.thermal.temperature = 300 @@ -394,14 +394,14 @@ # # *This name is more descriptive for the zone than wall-2.* -solver.settings.setup.boundary_conditions.wall["wall-2"].rename("nozzle") +solver_session.settings.setup.boundary_conditions.wall["wall-2"].rename("nozzle") # %% # Set the following boundary conditions for the nozzle for adiabatic wall conditions: # # * Heat flux: 0 :math:`W/m^2` -nozzle = WallBoundary(solver, name="nozzle") +nozzle = WallBoundary(solver_session, name="nozzle") nozzle.thermal.thermal_condition = "Heat Flux" nozzle.thermal.heat_flux = 0 @@ -417,27 +417,27 @@ # # Inspect the solution methods settings. -solver.settings.solution.methods.print_state() +solver_session.settings.solution.methods.print_state() # %% # Ensure that plot is enabled in residual monitor options. -solver.settings.solution.monitor.residual.options.plot() +solver_session.settings.solution.monitor.residual.options.plot() # %% # Initialize the field variables. -solver.settings.solution.initialization.hybrid_initialize() +solver_session.settings.solution.initialization.hybrid_initialize() # %% # Save the case file (gascomb1.cas.h5). -solver.settings.file.write_case(file_name="gascomb1.cas.h5") +solver_session.settings.file.write_case(file_name="gascomb1.cas.h5") # %% # Run the calculation for 200 iterations. -solver.settings.solution.run_calculation.iterate(iter_count=200) +solver_session.settings.solution.run_calculation.iterate(iter_count=200) # %% # Set time scale factor to 5. @@ -445,19 +445,19 @@ # *The Time Scale Factor allows us to further manipulate the computed time step size calculated by Fluent. # Larger time steps can lead to faster convergence. However, if the time step is too large it can lead to solution instability.* -solver.settings.solution.run_calculation.pseudo_time_settings.time_step_method.time_step_size_scale_factor = ( +solver_session.settings.solution.run_calculation.pseudo_time_settings.time_step_method.time_step_size_scale_factor = ( 5 ) # %% # Run the calculation for 200 iterations. -solver.settings.solution.run_calculation.iterate(iter_count=200) +solver_session.settings.solution.run_calculation.iterate(iter_count=200) # %% # Save the case and data files (gascomb1.cas.h5 and gascomb1.dat.h5). -solver.settings.file.write_case_data(file_name="gascomb1.cas.h5") +solver_session.settings.file.write_case_data(file_name="gascomb1.cas.h5") # %% # Postprocessing @@ -467,12 +467,12 @@ # Report the total sensible heat flux. # We shall use wildcards to specify all zones. -solver.settings.results.report.fluxes.get_heat_transfer_sensible(zones="*") +solver_session.settings.results.report.fluxes.get_heat_transfer_sensible(zones="*") # %% # Display filled contours of temperature and save the image to a file. -contour1 = Contour(solver, new_instance_name="contour-temp") +contour1 = Contour(solver_session, new_instance_name="contour-temp") contour1.field = "temperature" contour1.surfaces_list = contour1.surfaces_list.allowed_values() contour1.colorings.banded = True @@ -492,7 +492,7 @@ # %% # Display velocity vectors and save the image to a file. -vector1 = Vector(solver, new_instance_name="vector-vel") +vector1 = Vector(solver_session, new_instance_name="vector-vel") vector1.surfaces_list = ["interior-4"] vector1.options.scale = 0.01 vector1.vector_opt.fixed_length = True @@ -519,7 +519,7 @@ # %% # Display filled contours of mass fraction of :math:`CH_4` and save the image to a file. -contour2 = Contour(solver, new_instance_name="contour-ch4-mass-fraction") +contour2 = Contour(solver_session, new_instance_name="contour-ch4-mass-fraction") contour2.field = "ch4" contour2.surfaces_list = contour2.surfaces_list.allowed_values() contour2.display() @@ -537,7 +537,7 @@ # %% # Display filled contours of mass fraction of :math:`O_2` and save the image to a file. -contour3 = Contour(solver, new_instance_name="contour-o2-mass-fraction") +contour3 = Contour(solver_session, new_instance_name="contour-o2-mass-fraction") contour3.field = "o2" contour3.surfaces_list = contour3.surfaces_list.allowed_values() contour3.display() @@ -554,7 +554,7 @@ # %% # Display filled contours of mass fraction of :math:`CO_2` and save the image to a file. -contour4 = Contour(solver, new_instance_name="contour-co2-mass-fraction") +contour4 = Contour(solver_session, new_instance_name="contour-co2-mass-fraction") contour4.field = "co2" contour4.surfaces_list = contour4.surfaces_list.allowed_values() contour4.display() @@ -571,7 +571,7 @@ # %% # Display filled contours of mass fraction of :math:`H_2O` and save the image to a file. -contour5 = Contour(solver, new_instance_name="contour-h2o-mass-fraction") +contour5 = Contour(solver_session, new_instance_name="contour-h2o-mass-fraction") contour5.field = "h2o" contour5.surfaces_list = contour5.surfaces_list.allowed_values() contour5.display() @@ -594,7 +594,7 @@ # # *The mass-averaged temperature at the exit is approximately 1840 K.* -solver.settings.results.report.surface_integrals.get_mass_weighted_avg( +solver_session.settings.results.report.surface_integrals.get_mass_weighted_avg( report_of="temperature", surface_names=["pressure-outlet-9"] ) @@ -607,20 +607,20 @@ # # *The Area-Weighted Average field will show that the exit velocity is approximately 3.37 m/s.* -solver.settings.results.report.surface_integrals.get_area_weighted_avg( +solver_session.settings.results.report.surface_integrals.get_area_weighted_avg( report_of="velocity-magnitude", surface_names=["pressure-outlet-9"] ) # %% # Save the case file (gascomb1.cas.h5). -solver.settings.file.write_case(file_name="gascomb1.cas.h5") +solver_session.settings.file.write_case(file_name="gascomb1.cas.h5") # %% # Close Fluent # ^^^^^^^^^^^^ -solver.exit() +solver_session.exit() # %% # Summary From bfdd4356da93d91c3340732bd635886e49a17e61 Mon Sep 17 00:00:00 2001 From: pyansys-ci-bot <92810346+pyansys-ci-bot@users.noreply.github.com> Date: Wed, 4 Jun 2025 12:26:08 +0000 Subject: [PATCH 2/2] chore: adding changelog file 4110.documentation.md [dependabot-skip] --- doc/changelog.d/4110.documentation.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 doc/changelog.d/4110.documentation.md diff --git a/doc/changelog.d/4110.documentation.md b/doc/changelog.d/4110.documentation.md new file mode 100644 index 000000000000..7de00f227e5c --- /dev/null +++ b/doc/changelog.d/4110.documentation.md @@ -0,0 +1 @@ +Update solver and meshing in examples [skip tests] \ No newline at end of file