diff --git a/doc/changelog.d/4224.documentation.md b/doc/changelog.d/4224.documentation.md new file mode 100644 index 000000000000..a21452b29d24 --- /dev/null +++ b/doc/changelog.d/4224.documentation.md @@ -0,0 +1 @@ +Add podman usage examples and documentation improvements [skip tests] \ No newline at end of file diff --git a/doc/source/user_guide/make_container_image.rst b/doc/source/user_guide/make_container_image.rst index 035ccb18260f..867f569e9bb1 100644 --- a/doc/source/user_guide/make_container_image.rst +++ b/doc/source/user_guide/make_container_image.rst @@ -63,13 +63,13 @@ Run Docker container using the command line When you run the Docker container, you must specify the Ansys license file. -Execute this command to run the Docker container in solver mode: +To launch the container in solution mode, use: .. code:: console sudo docker run -it --name ansys-inc -e ANSYSLMD_LICENSE_FILE= ansys_inc 3ddp -gu -Execute this command to run the Docker container in meshing mode: +To launch the container in meshing mode, use: .. code:: console @@ -79,14 +79,65 @@ Execute this command to run the Docker container in meshing mode: Run Docker container using PyFluent ----------------------------------- -Install `PyFluent `_ and execute this code -to run the Docker container using PyFluent: +1. Install `PyFluent `_. +2. Use the following Python code to run the container: .. code:: python import os import ansys.fluent.core as pyfluent + os.environ["PYFLUENT_USE_DOCKER_COMPOSE"] = "1" os.environ["ANSYSLMD_LICENSE_FILE"] = "" custom_config = {'fluent_image': 'ansys_inc:latest', 'mount_source': f"{os.getcwd()}", 'auto_remove': False} solver_session = pyfluent.launch_fluent(container_dict=custom_config) + +Run Podman container using the command line +------------------------------------------- + +Follow these steps to pull and run a Fluent container using Podman. + +1. Pull the Docker image into Podman: + +.. code:: console + + sudo podman pull docker-daemon:ansys-inc:latest + + +2. Verify the image in the local Podman registry: + +.. code:: console + + sudo podman images + + +When you run the Podman container, you must specify the Ansys license file. + +To launch the container in solution mode, use: + +.. code:: console + + sudo podman run -it --name ansys-inc -e ANSYSLMD_LICENSE_FILE= ansys_inc 3ddp -gu + +To launch the container in meshing mode, use: + +.. code:: console + + sudo podman run -it --name ansys-inc -e ANSYSLMD_LICENSE_FILE= ansys_inc 3ddp -gu -meshing + + +Run Podman container using PyFluent +----------------------------------- + +1. Install `PyFluent `_. +2. Use the following Python code to run the container: + +.. code:: python + + import os + import ansys.fluent.core as pyfluent + os.environ["ANSYSLMD_LICENSE_FILE"] = "" + os.environ["PYFLUENT_USE_PODMAN_COMPOSE"] = "1" + custom_config = {'fluent_image': 'ansys_inc:latest', 'mount_source': f"{os.getcwd()}", 'auto_remove': False} + solver_session = pyfluent.launch_fluent(container_dict=custom_config) + diff --git a/doc/source/user_guide/meshing/meshing_workflows.rst b/doc/source/user_guide/meshing/meshing_workflows.rst index 24e1b26f5947..55aaa33911b0 100644 --- a/doc/source/user_guide/meshing/meshing_workflows.rst +++ b/doc/source/user_guide/meshing/meshing_workflows.rst @@ -819,10 +819,10 @@ Export Fluent 2D mesh >>> ) >>> export_mesh.Execute() -Switch to solver mode -~~~~~~~~~~~~~~~~~~~~~ +Switch to solution mode +~~~~~~~~~~~~~~~~~~~~~~~ -Switching to solver mode is not allowed in 2D Meshing mode. +Switching to solution mode is not allowed in 2D Meshing mode. State access diff --git a/doc/source/user_guide/session/launching_ansys_fluent.rst b/doc/source/user_guide/session/launching_ansys_fluent.rst index 07d9a4351dca..4b5929944745 100644 --- a/doc/source/user_guide/session/launching_ansys_fluent.rst +++ b/doc/source/user_guide/session/launching_ansys_fluent.rst @@ -40,8 +40,8 @@ Launcher options The following examples show different ways that you can launch Fluent locally. For more information, see :func:`launch_fluent() `. -Solver mode -~~~~~~~~~~~ +Solution mode +~~~~~~~~~~~~~ These two examples show equivalent ways to launch Fluent in solution mode: .. code:: python @@ -329,7 +329,7 @@ Set environment variables to select the container engine: >>> import os >>> os.environ["PYFLUENT_LAUNCH_CONTAINER"] = "1" - >>> os.environ["PYFLUENT_USE_PODMAN_COMPOSE"] = "1" # or os.environ["PYFLUENT_USE_PODMAN_COMPOSE"] = "1" + >>> os.environ["PYFLUENT_USE_DOCKER_COMPOSE"] = "1" # or os.environ["PYFLUENT_USE_PODMAN_COMPOSE"] = "1" Then launch: diff --git a/doc/source/user_guide/usability.rst b/doc/source/user_guide/usability.rst index 0a2e230bfddd..bcf39bdc33ce 100644 --- a/doc/source/user_guide/usability.rst +++ b/doc/source/user_guide/usability.rst @@ -20,69 +20,78 @@ Examples >>> import ansys.fluent.core as pyfluent >>> >>> # Semantic search - >>> pyfluent.search("font") - .meshing_utilities.count_marked_faces (Query) (similarity: 98.31%) - .meshing_utilities.delete_marked_faces_in_zones (Command) (similarity: 98.31%) - .meshing_utilities.get_free_faces_count (Query) (similarity: 98.31%) - .meshing_utilities.get_multi_faces_count (Query) (similarity: 98.31%) - .meshing_utilities.get_zones_with_free_faces_for_given_face_zones (Query) (similarity: 98.31%) - .meshing_utilities.get_zones_with_marked_faces_for_given_face_zones (Query) (similarity: 98.31%) - .meshing_utilities.get_zones_with_multi_faces_for_given_face_zones (Query) (similarity: 98.31%) - .meshing_utilities.mark_bad_quality_faces (Query) (similarity: 98.31%) - .meshing_utilities.mark_duplicate_faces (Query) (similarity: 98.31%) - .meshing_utilities.mark_faces_by_quality (Query) (similarity: 98.31%) - .meshing_utilities.mark_faces_deviating_from_size_field (Query) (similarity: 98.31%) - .meshing_utilities.mark_faces_in_self_proximity (Query) (similarity: 98.31%) - .meshing_utilities.mark_faces_using_node_degree (Query) (similarity: 98.31%) - .meshing_utilities.mark_free_faces (Query) (similarity: 98.31%) - .meshing_utilities.mark_island_faces (Query) (similarity: 98.31%) - .meshing_utilities.mark_multi_faces (Query) (similarity: 98.31%) - .meshing_utilities.mark_self_intersecting_faces (Query) (similarity: 98.31%) - .meshing_utilities.mark_sliver_faces (Query) (similarity: 98.31%) - .meshing_utilities.refine_marked_faces_in_zones (Query) (similarity: 98.31%) - .preferences.Appearance.Charts.Font (Object) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.Axes (Parameter) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.AxesTitles (Parameter) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.Legend (Parameter) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.Title (Parameter) (similarity: 98.31%) + >>> pyfluent.search("speed") ... - .mesh.swap_mesh_faces (Command) (similarity: 98.31%) - .preferences.Appearance.Charts.Font (Object) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.Axes (Parameter) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.AxesTitles (Parameter) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.Legend (Parameter) (similarity: 98.31%) - .preferences.Appearance.Charts.Font.Title (Parameter) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[] (Object) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[].field_name (Parameter) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[].list_properties (Command) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[].option (Parameter) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[].profile_name (Parameter) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[].resize (Command) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[].udf (Parameter) (similarity: 98.31%) + .setup.physics.volumes.solid[""].solid_motion.solid_motion_velocity[].value (Parameter) (similarity: 98.31%) + .setup.reference_frames[""].motion.constant_velocity (Object) (similarity: 98.31%) + .setup.reference_frames[""].motion.constant_velocity.linear_velocity (Parameter) (similarity: 98.31%) + .setup.reference_frames[""].motion.constant_velocity.rotational_velocity (Object) (similarity: 98.31%) + .setup.reference_frames[""].motion.constant_velocity.rotational_velocity.rotation_axis (Parameter) (similarity: 98.31%) + .setup.reference_frames[""].motion.constant_velocity.rotational_velocity.speed (Parameter) (similarity: 98.31%) + .setup.reference_values.velocity (Parameter) (similarity: 98.31%) + .solution.initialization.hybrid_init_options.general_settings.initialization_options.const_velocity (Parameter) (similarity: 98.31%) + .solution.methods.expert.physical_velocity_formulation (Parameter) (similarity: 98.31%) + .solution.methods.expert.velocity_formulation (Parameter) (similarity: 98.31%) + .solution.methods.high_speed_numerics (Object) (similarity: 98.31%) + .solution.methods.high_speed_numerics.enable (Parameter) (similarity: 98.31%) + .solution.methods.high_speed_numerics.expert (Parameter) (similarity: 98.31%) + .solution.methods.high_speed_numerics.robust_fluxes (Parameter) (similarity: 98.31%) + .solution.methods.high_speed_numerics.visualize_pressure_discontinuity_sensor (Parameter) (similarity: 98.31%) + .solution.methods.multiphase_numerics.advanced_stability_controls.hybrid_nita.instability_detector.set_velocity_limit (Parameter) (similarity: 98.31%) ... >>> >>> # Semantic search within a specific API object - >>> pyfluent.search("font", api_path=".results.annotation") - .results.annotation[""].font_color (Parameter) (similarity: 98.31%) - .results.annotation[""].font_name (Parameter) (similarity: 98.31%) - .results.annotation[""].font_size (Parameter) (similarity: 98.31%) - .results.annotation[""].font_slant (Parameter) (similarity: 98.31%) - .results.annotation[""].font_weight (Parameter) (similarity: 98.31%) + >>> pyfluent.search("load", api_path=".parallel.partition.set") + .parallel.partition.set.dpm_load_balancing (Object) (similarity: 98.31%) + .parallel.partition.set.dpm_load_balancing.interval (Parameter) (similarity: 98.31%) + .parallel.partition.set.dpm_load_balancing.load_balancing (Parameter) (similarity: 98.31%) + .parallel.partition.set.dpm_load_balancing.threshold (Parameter) (similarity: 98.31%) + .parallel.partition.set.load_distribution (Parameter) (similarity: 98.31%) >>> - >>> # Chinese semantic search - >>> pyfluent.search("读", language="cmn") # search 'read' in Chinese - .file.convert_hanging_nodes_during_read (Parameter) (similarity: 100.0%) - .file.import_.read (Command) (similarity: 100.0%) - .file.interpolate.read_data (Command) (similarity: 100.0%) - .file.read (Command) (similarity: 100.0%) - .file.read_case (Command) (similarity: 100.0%) - .file.read_case_data (Command) (similarity: 100.0%) - .file.read_case_lightweight (Command) (similarity: 100.0%) - .file.read_data (Command) (similarity: 100.0%) - .file.read_field_functions (Command) (similarity: 100.0%) - .file.read_injections (Command) (similarity: 100.0%) - .file.read_isat_table (Command) (similarity: 100.0%) - .file.read_journal (Command) (similarity: 100.0%) - .file.read_macros (Command) (similarity: 100.0%) - .file.read_mesh (Command) (similarity: 100.0%) - .file.read_pdf (Command) (similarity: 100.0%) - .file.read_profile (Command) (similarity: 100.0%) - .file.read_settings (Command) (similarity: 100.0%) - .file.read_surface_mesh (Command) (similarity: 100.0%) - .file.table_file_manager.read_table_file (Command) (similarity: 100.0%) + >>> # Spanish semantic search + >>> pyfluent.search("superficie", language="spa") # search 'surface' in Spanish + .preferences.Appearance.SurfaceEmissivity (Parameter) (similarity: 100.0%) + .preferences.Appearance.SurfaceSpecularity (Parameter) (similarity: 100.0%) + .preferences.Appearance.SurfaceSpecularityForContours (Parameter) (similarity: 100.0%) + .preferences.Graphics.Performance.SurfaceCaching (Parameter) (similarity: 100.0%) + .preferences.Graphics.SurfaceGeneralDisplacement (Parameter) (similarity: 100.0%) + .design.geometry.parameterize_and_explore.design_change.export.stl_surfaces (Command) (similarity: 100.0%) + .design.geometry.parameterize_and_explore.design_change.history.surfaces (Parameter) (similarity: 100.0%) + .design.geometry.parameterize_and_explore.design_change.preview.surfaces (Parameter) (similarity: 100.0%) + ... + .setup.boundary_conditions.intake_fan[""].multiphase.ht_bottom (Object) (similarity: 88.89%) + .setup.boundary_conditions.intake_fan[""].multiphase.ht_bottom.field_name (Parameter) (similarity: 88.89%) + .setup.boundary_conditions.intake_fan[""].multiphase.ht_bottom.option (Parameter) (similarity: 88.89%) + .setup.boundary_conditions.intake_fan[""].multiphase.ht_bottom.profile_name (Parameter) (similarity: 88.89%) + .setup.boundary_conditions.intake_fan[""].multiphase.ht_bottom.udf (Parameter) (similarity: 88.89%) + .setup.boundary_conditions.intake_fan[""].multiphase.ht_bottom.value (Parameter) (similarity: 88.89%) + ... + .setup.boundary_conditions.outlet_vent[""].list (Command) (similarity: 85.71%) + .setup.boundary_conditions.outlet_vent[""].list_properties (Command) (similarity: 85.71%) + .setup.boundary_conditions.outlet_vent[""].make_a_copy (Command) (similarity: 85.71%) + .setup.boundary_conditions.outlet_vent[""].momentum (Object) (similarity: 85.71%) + ... + .results.graphics.pathline[""].axes.rules.x_axis.major_rule_line_color (Parameter) (similarity: 83.33%) + .results.graphics.pathline[""].axes.rules.x_axis.major_rule_weight (Parameter) (similarity: 83.33%) + .results.graphics.pathline[""].axes.rules.x_axis.minor_rule_line_color (Parameter) (similarity: 83.33%) + .results.graphics.pathline[""].axes.rules.x_axis.minor_rule_weight (Parameter) (similarity: 83.33%) + .results.graphics.pathline[""].axes.rules.y_axis.major_rule_line_color (Parameter) (similarity: 83.33%) + .results.graphics.pathline[""].axes.rules.y_axis.major_rule_weight (Parameter) (similarity: 83.33%) + .results.graphics.pathline[""].axes.rules.y_axis.minor_rule_line_color (Parameter) (similarity: 83.33%) + ... + .setup.physics.volumes.solid[""].boundaries.pressure_outlet[""].settings.species.tss_scalar[""].profile_name (Parameter) (similarity: 82.35%) + .setup.physics.volumes.solid[""].boundaries.pressure_outlet[""].settings.structure.x_disp_boundary_value.profile_name (Parameter) (similarity: 82.35%) + .setup.physics.volumes.solid[""].boundaries.pressure_outlet[""].settings.structure.y_disp_boundary_value.profile_name (Parameter) (similarity: 82.35%) + .setup.physics.volumes.solid[""].boundaries.pressure_outlet[""].settings.structure.z_disp_boundary_value.profile_name (Parameter) (similarity: 82.35%) + .setup.physics.volumes.solid[""].boundaries.pressure_outlet[""].settings.thermal.backflow_total_temperature.profile_name (Parameter) (similarity: 82.35%) + .setup.physics.volumes.solid[""].boundaries.pressure_outlet[""].settings.turbulence.backflow_intermittency.profile_name (Parameter) (similarity: 82.35%) ... >>> >>> # Chinese semantic search within a specific API object @@ -102,11 +111,8 @@ Examples .tui.results.report.simulation_reports.read_simulation_report_template_file (Command) (similarity: 100.0%) >>> >>> # Whole word search - >>> pyfluent.search("ApplicationFontSize", match_whole_word=True) - .preferences.Appearance.ApplicationFontSize (Parameter) - .preferences.Appearance.ApplicationFontSize (Parameter) - .tui.preferences.appearance.application_font_size (Command) - .tui.preferences.appearance.application_font_size (Command) + >>> pyfluent.search("iteration_at_creation_or_edit", match_whole_word=True) + .solution.monitor.convergence_conditions.convergence_reports[""].iteration_at_creation_or_edit (Parameter) >>> >>> # Whole word search within a specific API object >>> pyfluent.search("ApplicationFontSize", match_whole_word=True, api_path="preferences") @@ -128,9 +134,11 @@ Examples ... >>> >> # Wildcard pattern search within a specific API object - >>> pyfluent.search("local*", api_path="mesh_interfaces") - .setup.mesh_interfaces.interface[""].local_absolute_mapped_tolerance (Parameter) - .setup.mesh_interfaces.interface[""].local_relative_mapped_tolerance (Parameter) + >>> pyfluent.search("iter*", api_path=".parallel.multidomain") + .parallel.multidomain.conjugate_heat_transfer.set.coupling.iter_per_coupling_count (Parameter) + .parallel.multidomain.conjugate_heat_transfer.set.coupling.single_session_coupling.iteration (Parameter) + .parallel.multidomain.solve.dual_time_iterate (Command) + .parallel.multidomain.solve.iterate (Command) >>> >>> # Misspelled search >>> pyfluent.search("cfb_lma") diff --git a/examples/00-fluent/conjugate_heat_transfer.py b/examples/00-fluent/conjugate_heat_transfer.py index 4e83c58b4130..afe05d990dee 100644 --- a/examples/00-fluent/conjugate_heat_transfer.py +++ b/examples/00-fluent/conjugate_heat_transfer.py @@ -848,8 +848,8 @@ solver_session.results.surfaces.iso_surface["x=0.012826"] = {"iso_values": [0.012826]} ############################################################################# -# Vecotor Plot -# ============ +# Vector Plot +# =========== vector1 = Vector(solver=solver_session, surfaces=["x=0.012826"], scale=2.0, skip=5) window3 = GraphicsWindow() diff --git a/pyproject.toml b/pyproject.toml index 9cd472526104..f09321832d87 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -30,7 +30,7 @@ dependencies = [ "grpcio-status>=1.26.0", "nltk>=3.9.1", "numpy>=1.14.0,<3.0.0", - "pandas>=1.1.0,<2.3", + "pandas>=1.1.0,<3.0.0", "pyansys-tools-report>=0.8.1", "pyyaml>=6.0", ]