git:20260511.73fbe2e to git:20260710.2b52ce8

26 added, 0 removed. Audit A to A.

---

name: fluent-sim

description: Use when working with Ansys Fluent through live sim sessions, direct PyFluent scripts, or file-side artifact review.

---

# fluent-sim

This skill is the Fluent-specific operating guide. Choose the control path

that fits the task, then load only the references needed for that path.

## Choose The Control Path

| Path | Best for | Starting point |

|---|---|---|

| Live sim session | Stateful edits, GUI observation, incremental solver work, remote Windows diagnostics, version probes, and inspecting a running Fluent session | `uv run sim connect --solver fluent --mode <solver|meshing> --ui-mode <gui|no_gui>` |

| Direct PyFluent script | Deterministic batch runs, reproducible examples, CI-friendly smoke scripts, and workflows that can own their process lifecycle | `from ansys.fluent.core import launch_fluent` in a normal Python script |

| File-side artifact review | Case/data/mesh inventory, transcript tails, CSV/PNG/PDF outputs, and offline checks that do not need a live solver | Use Python file readers, text inspection, and Fluent artifact helpers before opening a session |

Use sim when the task needs a persistent runtime or live observation. Use a

direct PyFluent script when a one-shot batch program is clearer. Use file-side

helpers when the question is about artifacts already on disk.

## Live Sim Session

After connecting, inspect:

```bash

uv run sim inspect session.versions

uv run sim inspect session.health

uv run sim inspect session.summary

```

The `session.versions` payload selects the active overlays. Always read

`base/`, then the active `sdk/<active_sdk_layer>/`, then the active

`solver/<active_solver_layer>/` when present. Later layers override earlier

files with the same name.

Expected SDK layer directories are:

- `sdk/0.38/` for PyFluent 0.38.x

- `sdk/0.37/` for PyFluent 0.37.x

Useful live inspect targets:

- `session.summary`

- `session.health`

- `session.versions`

- `last.result`

- `workflow.summary`

- `field.catalog` / `fluent.field.catalog`

- `fluent.models.summary`

- `fluent.boundaries.summary`

- `fluent.case.summary`

- `fluent.mesh.summary`

- `fluent.files`

Use `uv run sim exec` snippets with the injected `session`, `solver`, or `meshing`

object. Keep snippets small enough that `last.result` can prove the current

state before the next step.

## Direct PyFluent Script

For direct scripts, own the launch and teardown explicitly:

```python

from ansys.fluent.core import launch_fluent

solver = launch_fluent(mode="solver", ui_mode="no_gui", precision="double")

try:

solver.settings.file.read_case(file_name="case.cas.h5")

solver.solution.initialization.hybrid_initialize()

solver.solution.run_calculation.iterate(iter_count=10)

finally:

solver.exit()

```

This path is a good fit when the result can be produced in one deterministic

program and you do not need a live agent-visible session between steps.

For direct PyFluent scripts, launch the session normally with PyFluent and do

not rely on sim-injected variables.

+ ## Long-running execution and recovery

+ Keep bounded Fluent work in the foreground when it fits the active tool-call

+ budget. Use a native journal, direct PyFluent script, or background process only

+ when the solve is expected to outlive that budget, must continue across agent

+ turns, or the user explicitly asks for background execution. Keep live sessions

+ for incremental setup and inspection; use a settled script or journal for a

+ repeatable long solve.

+ For a long run, use absolute transcript/log and case/data output paths so the

+ agent can inspect progress and results later. Do not require a fixed directory

+ tree, a job manifest, or sim-cli when the direct Fluent or PyFluent path is

+ sufficient.

+ A shell or tool timeout ends that observation call; it does not prove Fluent

+ stopped. Before retrying or stopping, check the Fluent/PyFluent process,

+ transcript tail, monitor output, and case/data timestamps. Confirm process

+ ownership from the executable, full command line, start time, and working or

+ output paths. Never terminate every `fluent`, `ansys`, or `cortex` process

+ by name.

+ Use *resume* only when a usable `.cas/.dat(.h5)` pair, autosave, or another

+ Fluent-native checkpoint can actually continue the calculation. Without one,

+ describe the action as a restart rather than promising generic resume behavior.

+ Keep direct PyFluent scripts responsible for their own launch and teardown.

## File-Side Artifact Review

Before launching Fluent, inventory what is already present:

- `.cas` / `.cas.h5`: case setup

- `.dat` / `.dat.h5`: solution data

- `.msh` / `.msh.h5`: mesh input

- `.trn` / `.jou`: transcript and journal evidence

- `.pdf` / `.fla`: flamelet and PDF table artifacts

- `.csv` / `.png` / `.json`: exported reports, figures, and structured output

Use this path for quick triage, output extraction, and deciding whether a live

session is necessary.

## Layered References

| Path | Use |

|---|---|

| `base/reference/task_templates.md` | Required inputs and workflow step order |

| `base/reference/runtime_patterns.md` | Fluent dependency chains and state ordering |

| `base/reference/acceptance_checklists.md` | Completion checks for bundled workflows |

| `base/reference/api_discovery.md` | `dir()` and `child_names` patterns for renamed APIs |

| `base/reference/tui_vs_settings.md` | When to prefer Settings API or TUI |

| `base/reference/pyfluent_overview.md` | Quick PyFluent orientation |

| `base/snippets/` | Reusable live-session snippets |

| `base/workflows/` | Longer workflow examples |

| `sdk/0.38/` | PyFluent 0.38.x docs and examples |

| `sdk/0.37/` | PyFluent 0.37.x compatibility notes |

| `solver/25.2/` | Fluent 25.2-specific notes |

| `doc-search/` | Local Fluent documentation search helper |

For PyFluent API questions, start with the active `sdk/` overlay. For Fluent

physics, meshing, UDF, or solver-model questions, use `doc-search/` against the

local Ansys documentation tree rather than guessing names or defaults.

## Live Sim Session Constraints

These constraints apply only after sim has already created a live Fluent

session:

1. Do not call `pyfluent.launch_fluent()` inside a `uv run sim exec` snippet. Use the

injected `session`, `solver`, or `meshing` object.

2. Do not switch between meshing and solver mode by assumption. The mode is

selected at connect time unless a Fluent workflow explicitly returns a

solver object.

3. Confirm each stateful step before sending the next dependent step. Fluent

meshing and solver workflows are order-sensitive.

4. Use GUI actuation only for surfaces the SDK cannot reach. Prefer

`solver.settings.*`, `session.tui.*`, and `meshing.workflow.*` for

reproducible work.

## Flamelet And PDF Table Workflows

For partially premixed steady-diffusion flamelet workflows, load:

- `base/reference/task_templates.md` - Template 5

- `base/reference/runtime_patterns.md` - staged flamelet/PDF dependency chain

- `base/reference/acceptance_checklists.md` - Checklist 5

- `base/snippets/setup_partially_premixed_flamelet.py`

- `base/snippets/write_pdf_table.py`

- `base/snippets/read_case_pdf_data.py`

- `base/snippets/inspect_reacting_bc_scalars.py`

Short version: import CHEMKIN as `flamelet-mixture`, generate flamelets and the

PDF table, persist the table with `write_pdf_cmd(...)`, and restart or

postprocess with `read_case -> read_pdf -> read_data`.