Gyredocs
Depth Practice
API

Gyre/Overview

What Gyre is

In one minuteGyre is a differentiable high-order flow solver delivered as a service. It gives a design-optimization framework what it needs from an aerodynamics discipline — converged flows, outputs, coupling fields and exact derivatives — and deliberately nothing more.

Written at L1 Essentials goes to L3 Mechanicseveryone 704 words Markdown

High-fidelity multidisciplinary design optimization (MDO) couples a flow solver with structures, propulsion, controls and a geometry engine, and drives the whole with a gradient-based optimizer. The flow solver is usually the most expensive and the least cooperative member: its gradients are hard to obtain, hard to trust and hard to keep in sync with the code.

Gyre is a flow discipline designed for that seat. It is built around three commitments.

  1. Everything is differentiable. The solver is written in JAX. Jacobian products, adjoints, shape sensitivities and error estimates are produced by automatic differentiation of the same kernels that compute the flow, so they are exact for the discrete problem and can never drift out of sync.
  2. High order, with entropy-conservative volume terms. A split-form discontinuous Galerkin spectral element method on curved meshes whose volume terms conserve entropy exactly, so aliasing inside an element cannot feed the instability that limits under-resolved high-order methods. A discrete entropy inequality is proven with the entropy-stable interface fluxes (es_roe, llf); with the default classical Roe flux entropy decay is measured, not proven, and positivity is not enforced (the exact conditions).
  3. A service, not a script. One deployable unit exposes a REST API, warm analysis sessions for design loops, an agent (MCP) interface, declarative pipelines and this documentation — built from the revision that is running.
  • Solve steady compressible Euler, laminar Navier–Stokes and Reynolds-averaged (Spalart–Allmaras) flows on curved high-order meshes in two and three dimensions: aerofoils, cylinders, channels, flat plates, spheres and ellipsoids from the built-in generators.
  • Use the built-in mesh generators or bring a mesh of curved quadrilaterals or hexahedra from Gmsh (mesh files).
  • Obtain lift, drag, side force, moments, heat flux and consistent nodal surface loads.
  • Obtain total derivatives of any scalar output with respect to Mach number, angle of attack, sideslip, Reynolds number, turbulence-model data and the position of every surface node, by adjoint or direct method.
  • Couple to another discipline through surface displacements (in) and loads (out), with the forward and reverse products a coupled adjoint needs.
  • Estimate the discretization error of an output with one extra linear solve, and let the solver raise the polynomial degree until that estimate meets a tolerance.
  • Run all of this in-process (Python), from the command line, over HTTP from another machine, or from an AI agent through the Model Context Protocol.
bash
gyre run naca0012_euler --gradients --of cl,cd --wrt alpha,mach --error cd

solves inviscid flow over a NACA 0012 at Mach 0.5 and 2°, and prints the force coefficients, their adjoint derivatives with respect to angle of attack and Mach number, and an adjoint-based estimate of how much of the (physically zero) drag is discretization error. The worked example shows the numbers.

Mach number, NACA 0012, M = 0.5, α = 2°Part of the domain: window x ∈ [-1, 2.5], y ∈ [-1.5, 1.5] · the 354 mesh elements that reach into it · 8×8 points each

Fields: mach [0.05156, 0.7167], pressure [2.397, 3.389], density [0.8823, 1.13], entropy [2.846, 2.888]. Raw sample (JSON)

gyre 0.4.0 · 39979fcf90 · · gpu · NVIDIA GeForce RTX 3060 Ti · example_airfoil/field.jsonSame code as this build

You are… You interact with… Start at
integrating Gyre into an MDO framework FlowDiscipline / RemoteDiscipline, OpenMDAO adapter MDO integration
running analyses CLI, REST jobs Getting started
an AI agent or building one MCP tools Agent interface
operating a deployment tools/deploy.py, container, metrics Deployment
extending the solver gyre.dg, gyre.physics, gyre.implicit Code structure
assessing the numerics verification studies Verification
  • One execution path. CLI, service workers, sessions, pipelines and agent tools all call the same run_case / FlowDiscipline code. There is no second implementation to diverge.
  • Geometry is data. Node coordinates are an argument of the differentiated function, not configuration, so shape derivatives need no dedicated code.
  • Matrix-free everywhere. Jacobians are applied, never stored; preconditioner blocks come from AD as well.
  • Evidence travels with the code. Verification numbers shown in these pages are files produced by gyre verify and stamped with commit, device and time.
  • Honest scope. Limits are stated where they apply (capabilities and limits).

    ↑ ↓ moveEnter open[ ] change depthResults show section and depth level