吾生有涯 学海无涯
析模有界 知识无界
        找回密码

PyFluent｜01 会话管理

2025-08-06 分类：仿真学习 阅读() 评论(0)

 

若想要有效地使用 PyFluent，需要熟悉用于连接和启动 Fluent 的函数，以及这些函数返回的会话对象。本节将对会话对象进行简要概述。

1 启动并连接 Fluent

本文档全面介绍了如何使用 PyFluent（Fluent 的 Python 接口）启动并连接 Ansys Fluent 会话。内容涵盖多种 Fluent 启动方式，包括从本地安装启动、在容器化环境（Docker 或 Podman）中启动，以及连接至现有 Fluent 会话的方法。通过详细示例，说明了如何在不同模式下初始化 Fluent，如网格划分、求解、前后处理等。

此外，指南还阐述了高级启动选项，如精度设置、维度配置及并行执行参数的设定。内容涉及与 Slurm 等作业调度器的集成，以支持高效运行高性能计算任务。同时提供了在 PIM 环境中启动 Fluent 的具体步骤，以及在 Windows、Linux 和 WSL 主机之间实现跨平台远程连接与文件传输的操作指南。

本参考文档旨在为用户提供必要的知识与工具，以在多样化的计算环境中灵活、高效地管理 Fluent 会话。

1.1 从本地安装启动

from_install() 方法使用本地安装的 Ansys Fluent 版本来启动 Fluent。

在以下情况下可采用此方法：

  • • 本地计算机已安装 Fluent。
  • • 希望通过 Python 直接运行 Fluent，无需借助 Docker 或 Podman 等容器工具。

示例：

import ansys.fluent.core as pyfluent
meshing = pyfluent.Meshing.from_install()
pure_meshing = pyfluent.PureMeshing.from_install()
solver = pyfluent.Solver.from_install()
solver_aero = pyfluent.SolverAero.from_install()
solver_icing = pyfluent.SolverIcing.from_install()
pre_post = pyfluent.PrePost.from_install()

1.2 在容器中启动

利用from_container() 方法可以在 Docker 容器内启动 Fluent。

在以下情况下适用此方法：

  • • 处于容器化环境中。
  • • 需要设置端口映射。
  • • 运行隔离或并行会话时。

示例：

import os
os.environ["PYFLUENT_LAUNCH_CONTAINER"] = "1"
os.environ["PYFLUENT_USE_DOCKER_COMPOSE"] = "1"# or os.environ["PYFLUENT_USE_PODMAN_COMPOSE"] = "1"

import ansys.fluent.core as pyfluent
from ansys.fluent.core.utils.networking import get_free_port

port_1 = get_free_port()
port_2 = get_free_port()
container_dict = {"ports": {f"{port_1}": port_1, f"{port_2}": port_2}}

meshing = pyfluent.Meshing.from_container(container_dict=container_dict, product_version=pyfluent.FluentVersion.v252)
pure_meshing = pyfluent.PureMeshing.from_container(container_dict=container_dict, product_version=pyfluent.FluentVersion.v252)
solver = pyfluent.Solver.from_container(container_dict=container_dict, product_version=pyfluent.FluentVersion.v252)
solver_aero = pyfluent.SolverAero.from_container(container_dict=container_dict, product_version=pyfluent.FluentVersion.v252)
solver_icing = pyfluent.SolverIcing.from_container(container_dict=container_dict, product_version=pyfluent.FluentVersion.v252)
pre_post = pyfluent.PrePost.from_container(container_dict=container_dict, product_version=pyfluent.FluentVersion.v252)

1.3 连接到已有会话

利用from_connection() 方法可以连接到先前已启动的 Fluent 会话。

在以下情况下适用此方法：

  • • Fluent 已通过外部方式或先前已启动。
  • • 需要从不同进程或系统建立连接。

示例：

import ansys.fluent.core as pyfluent

# Launch to retrieve credentials
solver = pyfluent.Solver.from_local_install()
print(solver.health_check.check_health())

ip = solver.connection_properties.ip
password = solver.connection_properties.password
port = solver.connection_properties.port

# Connect to the session
solver_connected = pyfluent.Solver.from_connection(ip=ip, password=password, port=port)
print(solver_connected.health_check.check_health())

solver.exit()
solver_connected.exit()

1.4 以 PIM 模式启动

利用from_pim() 方法可以以 PIM 模式启动 Fluent。

在以下情况下使用此方法：

  • • 在已配置 PIM 的环境中使用 PyFluent 时。

示例：

import ansys.fluent.core as pyfluent
meshing = pyfluent.Meshing.from_pim()
pure_meshing = pyfluent.PureMeshing.from_pim()
solver = pyfluent.Solver.from_pim()
solver_aero = pyfluent.SolverAero.from_pim()
solver_icing = pyfluent.SolverIcing.from_pim()
pre_post = pyfluent.PrePost.from_pim()

1.5 使用launch_fluent()函数

通过调用 launch_fluent() 函数，可从 Python 中启动 Fluent。该函数在后台启动 Fluent 并运行其 gRPC 服务器，使其能够接收用户通过 Python 解释器发送的命令。

import ansys.fluent.core as pyfluent
solver_session = pyfluent.launch_fluent()

使用 connect_to_fluent() 函数可连接至已启动 gRPC 服务器的运行中 Fluent 会话。可通过以下方式启动 Fluent 的 gRPC 服务器：

  1. 1. 启动 Fluent 时执行命令  -sifile=，或
  2. 2. 在 Fluent Solution 模式下的 TUI 命令中输入 server/start-server，或
  3. 3. 在 Fluent Solution 模式下通过功能区菜单选择 File -> Applications -> Server -> Start...。

启动 gRPC 服务器后，Fluent 将在  指定位置生成一个 server-info 文件，并在控制台输出相关信息。若未指定 ，系统将自动生成该文件。

以下代码用于连接至一个正在运行的 Fluent 会话，其中 server-info 文件为当前工作目录下的 server.txt：

import ansys.fluent.core as pyfluent
solver_session = pyfluent.connect_to_fluent(
    server_info_file_name="server.txt"
)

1.5.1 启动选项

以下示例展示了在本地启动 Fluent 的不同方式。

1.5.1.1 Solution模式

以下两个示例展示了以 Solution 模式启动 Fluent 的等效方式：

solver_session = pyfluent.launch_fluent(mode=pyfluent.FluentMode.SOLVER)
solver_session = pyfluent.launch_fluent()

1.5.1.2 Meshing模式

此示例展示以Meshing模式启动 Fluent：

meshing_session = pyfluent.launch_fluent(
     mode=pyfluent.FluentMode.MESHING
)

1.5.1.3 Pre/Post模式

以仅启用前处理设置和后处理功能的模式运行 Ansys Fluent。该模式下无法执行计算任务。

以下示例展示了如何在 Pre/Post 模式下启动 Fluent：

pre_post_session = pyfluent.launch_fluent(mode=pyfluent.FluentMode.PRE_POST)

1.5.1.4 精度

此示例演示了如何在 Solution 模式下启动 Fluent 并将其设置为双精度。

solver_session = pyfluent.launch_fluent(
     precision=pyfluent.Precision.DOUBLE
)

1.5.1.5 维度

下面的示例展示了在 Solution 模式下启动 Fluent 并将模拟维度设置为二维的方法。

solver_session = pyfluent.launch_fluent(
     precision=pyfluent.Precision.DOUBLE,
     dimension=pyfluent.Dimension.TWO
)

1.5.1.6 本地并行

本例说明如何以 Solution 模式启动 Fluent，并设置用于本地并行执行的处理器数量：

solver_session = pyfluent.launch_fluent(
     precision=pyfluent.Precision.DOUBLE,
     dimension=pyfluent.Dimension.TWO,
     processor_count=2
)

1.5.1.7 分布式并行

此示例展示了如何在 Solution 模式下启动 Fluent，并使用分布于多台计算机的 16 个处理器进行计算。

solver_session = pyfluent.launch_fluent(
    precision=pyfluent.Precision.DOUBLE,
    dimension=pyfluent.Dimension.THREE,
    processor_count=16
    additional_arguments="-cnf=m1:8,m2:8",
)

1.6 日志支持

PyFluent 提供了启用日志记录的选项。以下语句可用于启用日志记录：

pyfluent.logger.enable()

如需更多详情，请参见[Logging]。

1.7 调度器支持

当在作业调度器环境中使用 PyFluent 时，launch_fluent() 函数会自动识别用于启动 Fluent 的机器列表及核心数量。支持的调度器环境包括 Altair Grid Engine（以前称为 UGE）、Sun Grid Engine（SGE）、Load Sharing Facility（LSF）、Portable Batch System（PBS）和 Slurm。

以下示例展示了一个 bash shell 脚本，可通过 sbatch 命令提交至 Slurm 调度器：

#!/bin/bash
#SBATCH --job-name="pyfluent"
#SBATCH --nodes=8
#SBATCH --ntasks=32
#SBATCH --output="%x_%j.log"
#SBATCH --partition=mpi01
#
# Change to the directory where the Slurm job was submitted
#
cd $SLURM_SUBMIT_DIR
#
# Activate your favorite Python environment
#
export AWP_ROOT252=/apps/ansys_inc/v252
. ./venv/bin/activate
#
# Run a PyFluent script
#
python run.py

以下是本示例的一些说明：

  • • 请求了共 8 台机器，每台机器包含 32 个核心，总计 256 个核心。通过命令行参数 -t 和 -cnf 配置相应选项，以启动 Fluent。
  • • 已设置环境变量 AWP_ROOT251，确保 PyFluent 能够定位 Fluent 的安装路径。
  • • 假设在将作业脚本提交至 Slurm 之前，已预先配置好包含 PyFluent 的 Python 虚拟环境；如有需要，也可在作业脚本中完成虚拟环境的激活与配置。
  • • run.py 文件可包含任意数量的 PyFluent 命令，并可调用任意数量受支持的接口。

在调度器环境中，launch_fluent() 函数支持多种使用方式。本示例展示了如何在所有请求的机器及计算核心上启动 Fluent 的三维双精度版本。

solver_session = pyfluent.launch_fluent(
     precision=pyfluent.Precision.DOUBLE,
     dimension=pyfluent.Dimension.THREE
)

可以使用 processor_count 参数来设置 Fluent 使用的处理器核心数量：

solver_session = pyfluent.launch_fluent(
    precision=pyfluent.Precision.DOUBLE,
    dimension=pyfluent.Dimension.THREE,
    processor_count=16,
)

以这种方式传递processor_count参数会强制 Fluent 在 16 个核心上运行，即使 Slurm 提交作业时请求了总共 32 个核心。当调度器环境会将某台机器上的全部核心分配出来，而用户已知 Fluent 在所有被分配的核心上可能无法有效扩展时，该做法可能具有实际意义。

最后，若需忽略调度器的资源分配，可通过 additional_arguments 参数向 launch_fluent() 函数传递 -t 参数，或同时传递 -t 和 -cnf 参数。对于本地并行执行，仅需传递 -t 参数即可：

solver_session = pyfluent.launch_fluent(
    precision=pyfluent.Precision.DOUBLE,
    dimension=pyfluent.Dimension.THREE,
    additional_arguments="-t16"
)

对于分布式并行处理，通常需同时传递以下两个参数：

solver_session = pyfluent.launch_fluent(
    precision=pyfluent.Precision.DOUBLE,
    dimension=pyfluent.Dimension.THREE,
    additional_arguments="-t16 -cnf=m1:8,m2:8",
)

launch_fluent()函数支持scheduler_options参数，可将Fluent作业直接提交至Slurm调度器，无需依赖任何bash脚本。

slurm = pyfluent.launch_fluent(
    scheduler_options={
        "scheduler": "slurm",
        "scheduler_headnode": "",
        "scheduler_queue": "",
        "scheduler_account": ""
    },
    additional_arguments="-t16 -cnf=m1:8,m2:8",
)
solver_session = slurm.result()

键 scheduler_headnode、scheduler_queue 和 scheduler_account 为可选项，其指定方式应参考 Fluent 调度器选项的配置方法。在此配置下，launch_fluent 函数将返回一个 SlurmFuture 实例，可通过该实例获取 PyFluent 会话。具体使用方式可参见 slurm_launcher 模块的文档。

参数 scheduler_options 不支持自动调度器分配，需通过 additional_arguments 参数将 -t 和 -cnf 传入 launch_fluent() 函数，以实现分布式并行处理。

1.8 启动一个PIM会话

当 PyFluent 在 [PIM] 配置的环境中运行时，launch_fluent() 函数将自动以 [PIM] 模式启动 Fluent 会话。在同一环境中，亦可通过 create_launcher() 进行显式启动，方式如下：

from ansys.fluent.core.launcher.launcher import create_launcher
from ansys.fluent.core.launcher.launch_options import LaunchMode, FluentMode

pim_meshing_launcher = create_launcher(LaunchMode.PIM, mode=FluentMode.MESHING)
pim_meshing_session = pim_meshing_launcher()

pim_solver_launcher = create_launcher(LaunchMode.PIM)
pim_solver_session = pim_solver_launcher()

1.9 以容器模式启动 Fluent

使用PyFluent结合Docker Compose或Podman Compose，可在一致且可复现的容器化环境中运行Fluent。

  1. 1. Docker Compose

    预备条件：

    • • [Docker]
    • • [Docker Compose]
  2. 2. Podman Compose

    预备条件：

    • • [Podman]
    • • [Podman Compose]

示例：

设置环境变量以选择容器引擎：

import os
os.environ["PYFLUENT_LAUNCH_CONTAINER"] = "1"
os.environ["PYFLUENT_USE_PODMAN_COMPOSE"] = "1" # or os.environ["PYFLUENT_USE_PODMAN_COMPOSE"] = "1"

然后启动：

import ansys.fluent.core as pyfluent
from ansys.fluent.core import examples
solver_session = pyfluent.launch_fluent()
case_file_name = examples.download_file("mixing_elbow.cas.h5", "pyfluent/mixing_elbow")
solver_session.file.read(file_name=case_file_name, file_type="case")
solver_session.exit()

1.10 从 Windows 主机连接到在 WSL 内运行的 Fluent 容器

  1. 1. 在 WSL 中启动 Fluent 容器

    docker run -it -p 63084:63084 -v /mnt/d/testing:/testing -e "ANSYSLMD_LICENSE_FILE=" -e "REMOTING_PORTS=63084/portspan=2" ghcr.io/ansys/pyfluent:v25.2.0 3ddp -gu -sifile=/testing/server.txt
    /ansys_inc/v252/fluent/fluent25.2.0/bin/fluent -r25.2.0 3ddp -gu -sifile=/testing/server.txt
  2. 2. 从在 Windows 主机上运行的 PyFluent 进行连接

    import ansys.fluent.core as pyfluent
    solver_session = pyfluent.connect_to_fluent(ip="localhost", port=63084, password=)

1.11 从 Windows 主机连接到在 Linux 内运行的 Fluent 容器

  1. 1. 在 Linux 内启动 Fluent 容器

    ansys_inc/v251/fluent/bin/fluent 3ddp -gu -sifile=server.txt
    cat server.txt
    10.18.19.151:44383
    hbsosnni
  2. 2. 从在 Windows 主机上运行的 PyFluent 进行连接

    import ansys.fluent.core as pyfluent
    solver_session = pyfluent.connect_to_fluent(ip="10.18.19.151", port=44383, password="hbsosnni")

1.12 从 Linux 或 WSL 主机连接到 Windows 上运行的 Fluent

本指南描述了如何从 Linux 或 WSL 主机连接到在 Windows 计算机上运行的 ANSYS Fluent 实例。同时包含启用远程文件传输的步骤。

Prerequisites:

  • • [Docker]
  • • [Build file transfer server]
  1. 1. 在 Windows 上设置 Fluent 及文件传输服务器
    1. 1. 启动 Fluent

      打开命令提示符并运行：

      ANSYS Incv252fluentntbinwin64fluent.exe 3ddp -sifile=server_info.txt
      type server_info.txt

      示例输出：10.18.44.179:51344, 5scj6c8l

    2. 2. 获取连接详细信息

      从server_info.txt文件中获取IP地址、端口和密码。例如：- IP: 10.18.44.179 - Port: 51344 - Password: 5scj6c8l

    3. 3. 启动文件传输服务器

      在Fluent工作目录下，启动文件传输服务器的容器。

      docker run -p 50000:50000 -v %cd%:/home/container/workdir filetransfer-tool-server
    4. 4. 允许入站 TCP 连接

      配置Windows防火墙：

      注意：Fluent会话结束后需删除添加的入站规则。

      • • 打开路径：Control Panel > Windows Defender Firewall > Advanced Settings > Inbound Rules
      • • 右键点击Inbound Rules，选择New Rule
      • • 选择Port，点击Next
      • • 保持TCP为选中状态
      • • 在Specific local ports中输入端口号：51344, 50000，然后点击Next
      • • 选择Allow the connection，点击Next
      • • 保持所有配置文件（Domain、Private、Public）处于勾选状态，点击Next
      • • 命名规则：Inbound TCP for Fluent
  2. 2. Connect from Linux or WSL Host

    运行以下Python代码连接Fluent并传输文件：

    from ansys.fluent.core import connect_to_fluent
    from ansys.fluent.core.utils.file_transfer_service import RemoteFileTransferStrategy

    file_service = RemoteFileTransferStrategy("10.18.44.179", 50000)
    solver_session = connect_to_fluent(ip="10.18.44.179", port=51344, password="5scj6c8l", file_transfer_service=file_service)

    # `mixing_elbow.cas.h5` will be uploaded to remote Fluent working directory
    solver_session.file.read_case(file_name="/home/user_name/mixing_elbow.cas.h5")

    # `elbow_remote.cas.h5` will be downloaded to local working directory
    solver_session.file.write_case(file_name="elbow_remote.cas.h5")

1.13 从Windows主机连接Linux或WSL上的Fluent

本指南说明如何从Windows主机连接运行在Linux或WSL机器上的ANSYS Fluent实例，同时包含启用远程文件传输的步骤。

前提条件：需要Docker容器及文件服务器。

  1. 1. 在Linux或WSL上设置Fluent及文件传输服务器
    1. 1. 启动Fluent

      打开终端并执行：

      ansys_inc/v252/fluent/bin/fluent 3ddp -sifile=server_info.txt
      cat server_info.txt

      示例输出：10.18.19.150:41429，u5s3iivh

    2. 2. 允许入站TCP连接

      从server_info.txt文件中获取IP地址、端口和密码。示例： - IP: 10.18.19.150 - Port: 41429 - Password: u5s3iivh

    3. 3. 启动文件传输服务器

      从 Fluent 的工作目录启动文件传输服务器的容器。

      docker run -p 50000:50000 -v `pwd`:/home/container/workdir -u `id -u`:`id -g` filetransfer-tool-server
  2. 2. 从Windows主机连接

运行以下Python代码连接至Fluent并传输文件：

from ansys.fluent.core import connect_to_fluent
from ansys.fluent.core.utils.file_transfer_service import RemoteFileTransferStrategy

file_service = RemoteFileTransferStrategy("10.18.19.150", 50000)
solver_session = connect_to_fluent(ip="10.18.19.150", port=41429, password="u5s3iivh", file_transfer_service=file_service)

# `mixing_elbow.cas.h5` will be uploaded to remote Fluent working directory
solver_session.file.read_case(file_name="D:path_to_filemixing_elbow.cas.h5")

# `elbow_remote.cas.h5` will be downloaded to local working directory
solver_session.file.write_case(file_name="elbow_remote.cas.h5")

2 使用 PyFluent 会话

通过调用launch_fluent()或connect_to_fluent()函数可获取 PyFluent 会话对象。

import ansys.fluent.core as pyfluent
from ansys.fluent.core.examples import download_file
case_file_name = download_file("mixing_elbow.cas.h5", "pyfluent/mixing_elbow")
data_file_name = download_file("mixing_elbow.dat.h5", "pyfluent/mixing_elbow")
solver_session = pyfluent.launch_fluent(case_data_file_name=case_file_name)

2.1 solution模式会话

上述 Solver会话对象提供了多种 Python 子对象，用于访问已连接的 Fluent solver_session 的数据和功能。这些 Python 对象保持一致的接口风格，每个对象承担特定职责，并反映在其专属接口中。例如，Solver会话分别提供用于求解器设置和场数据访问的子对象。通过执行dir(solver)可查看这些fields和settings子对象。分别调用dir(solver_session.fields)和dir(solver_session.settings)即可探索fields和settings 的子对象，以此类推：

solver_children = dir(solver_session)
settings = solver_session.settings
settings_children = dir(settings)
fields = solver_session.fields
fields_children = dir(fields)

可通过调用Python的help()函数了解更多关于PyFluent中各项功能的信息。

help(solver_session.settings.file.read_case)

可以创建额外的PyFluent会话。以下代码创建了一个独立于现有PyFluent Solver会话的Meshing模式会话，该会话将启动第二个Fluent实例。

import ansys.fluent.core as pyfluent
meshing_session = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING)

求解器设置对象采用统一接口。例如，get_state()、set_state()和is_active()为通用方法，而allowed_values()、min()和max()则应用于相关条目。以下示例展示了viscous和discrete_phase模型的使用方法。

viscous_model = settings.setup.models.viscous.model
viscous_model.get_state()
      'k-omega'
from pprint import pprint
pprint(viscous_model.allowed_values())
      ['inviscid',
       'laminar',
       'k-epsilon',
       'k-omega',
       'mixing-length',
       'spalart-allmaras',
       'k-kl-w',
       'transition-sst',
       'reynolds-stress',
       'scale-adaptive-simulation',
       'detached-eddy-simulation',
       'large-eddy-simulation']
viscous_model.set_state("laminar")
viscous_model.get_state()
'laminar'
discrete_phase = settings.setup.models.discrete_phase
discrete_phase.is_active()
True
max_num_refinements = discrete_phase.numerics.tracking.accuracy_control.max_num_refinements
max_num_refinements.get_state()
      20
max_num_refinements.min(), max_num_refinements.max()
 (0, 1000000)

求解器设置对象树中的某些条目属于方法，调用这些方法可在Fluent中请求特定操作。

solver_session.settings.solution.run_calculation.iterate(iter_count=100)

fields下的对象提供了与settings对象风格相似的接口：

field_data = fields.field_data
transaction = field_data.new_transaction()
add_scalar_fields = transaction.add_scalar_fields_request
allowed_field_names = add_scalar_fields.field_name.allowed_values()
pprint(allowed_field_names[:min([len(allowed_field_names), 5])])
['abs-angular-coordinate',
'absolute-pressure',
'angular-coordinate',
'anisotropic-adaption-cells',
'aspect-ratio']
add_scalar_fields.surface_names.allowed_values()
['cold-inlet', 'hot-inlet', 'outlet', 'symmetry-xyplane', 'wall-elbow', 'wall-inlet']
add_scalar_fields(field_name='absolute-pressure', surfaces=['cold-inlet', 'hot-inlet', 'outlet', 'symmetry-xyplane', 'wall-elbow', 'wall-inlet'])
pressure_fields = transaction.get_fields()
solver_session.fields.reduction.sum_if(
    expression="AbsolutePressure",
    condition="AbsolutePressure > 0[Pa]",
    locations=[settings.setup.boundary_conditions.velocity_inlet["cold-inlet"]],
    weight="Area",
)
15401477.28604886

2.2 Meshing模式会话

网格模式还提供了一种与上述交互方式一致的界面风格。以下是一些基于任务的网格工作流代码：

watertight = meshing_session.watertight()
from ansys.fluent.core.examples import download_file
import_file_name = examples.download_file('mixing_elbow.pmdb', 'pyfluent/mixing_elbow')
import_geometry = watertight.import_geometry
import_geometry.file_name.set_state(import_file_name)
length_unit = import_geometry.length_unit
length_unit.get_state()
 "mm"
length_unit.allowed_values()
 ["m", "cm", "mm", "in", "ft", "um", "nm"]
length_unit.set_state("mm")
import_geometry()

Meshing模式会话对象提供额外的子对象。例如，meshing包含fields和events子对象。这些子对象与Solver会话对象中同名的子对象具有相同的接口。

也可创建PureMeshing会话：

import ansys.fluent.core as pyfluent
pure_meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.PURE_MESHING)

两种网格会话类型之间的唯一区别在于，无法将会话直接切换至求解模式。纯会话类型的存在促进了最小化服务器镜像的创建，这一特性在容器化场景中具有重要意义。

2.3 会话模式切换

通过调用switch_to_solver()方法实现Meshing模式与Solution模式之间的切换。

switched_solver = meshing_session.switch_to_solver()

switched_solver会话使用与之前Meshing会话相同的Fluent实例，该实例现已无法使用。

对PureMeshing会话执行类似操作会引发异常：

failed_solver = pure_meshing.switch_to_solver() # raises an AttributeError!

注意：无法从solution模式切换回Meshing模式。

2.4 跨会话共享案例

作为模式切换的替代方案，可在不同会话之间转移案例。该操作既适用于纯网格划分会话，也适用于常规网格划分会话：

pure_meshing.transfer_mesh_to_solvers(solvers=[solver, switched_solver])

2.5 结束PyFluent会话

PyFluent会话对象在单个Python解释器会话中独立启动并存在，每个会话也可独立终止。调用Solver和PureMeshing会话对象的exit()方法，可结束这些PyFluent会话并终止所连接的Fluent会话：

solver_session.exit()
pure_meshing.exit()

在此场景中，每次Fluent会话均会终止，因为两个PyFluent [Session]对象均通过调用launch_fluent()函数获取。若改用connect_to_fluent()函数，则Fluent会话仅当满足以下条件时会在exit()方法调用后终止：调用connect_to_fluent()函数时参数值设为cleanup_on_exit=True。

当[Session]对象被垃圾回收时，会话也可能隐式退出。无论通过显式调用.exit()方法还是隐式退出，关于Fluent终止的规则均相同。隐式退出通过Python垃圾回收机制实现。调用session.exit()等同于会话被垃圾回收：

def run_solver():
    solver_session = pyfluent.launch_fluent()
    # 
    # solver is exited at the end of the function

结束Python解释器会话时，所有活动的PyFluent会话将自动退出。

（完）

 

本篇文章来源于微信公众号: CFD之道

赞(1) 打赏
版权声明：未经允许，请勿随意用于商业用途。
文章名称：《PyFluent｜01 会话管理》
文章链接：https://www.topcfd.cn/41449/
本站资源仅供个人学习交流，请于下载后24小时内删除，不允许用于商业用途，否则法律问题自行承担。
分享到

相关推荐

说两句 抢沙发

评论前必须登录！

 

最新文章

2025 年 12 月
一 二 三 四 五 六 日
 1
2345678
9101112131415
16171819202122
23242526272829
30  

觉得文章有用就打赏一下文章作者吧

非常感谢你的打赏，我们将继续给力更多优质内容，让我们一起创建更加美好的网络世界！

支付宝扫一扫

微信扫一扫

登录

找回密码

注册