Exasim¶

Exasim is a framework for generating and running high-performance solvers for parametrized partial differential equations (PDEs). It combines high-order DG, HDG, and LDG discretizations with symbolic/code-generation workflows and a portable C++/Kokkos backend for CPU, GPU, MPI, and MPI+GPU execution.

Exasim is designed for scientific computing workflows where users need to move from a mathematical PDE model to a production solver that can run on laptops, workstations, and large-scale HPC systems.

New to Exasim? Start with the Quickstart, then choose an Application Mode.

Why Exasim?¶

Advantage	What it gives you
Code generation	Write models at a high level and generate optimized C++ kernels for the solver.
High-order accuracy	Use configurable polynomial order, quadrature order, DG/HDG/LDG formulations, and curved/high-order mesh support.
Performance portability	Build the same solver stack for CPU, NVIDIA GPU, AMD GPU, MPI, or MPI+GPU through Kokkos and Exasim package variants.
Scalable solver infrastructure	Use Newton-GMRES, preconditioners, domain decomposition, and distributed-memory execution.
Reusable application modes	Run installed built-in models, external built-ins, shared-library apps, or frontend-generated apps.
Reproducible studies	Organize parameter sweeps, warm starts, postprocessing, and output metadata consistently.

Key Capabilities¶

Capability	Summary	Start here
Text-to-code workflow	Generate solver kernels and input data from `pdeapp.txt` and `pdemodel.txt`.	Text2Code Applications
Built-in PDE model library	Select installed Poisson, Navier-Stokes, reacting-flow, and related application models by `builtinmodelID`.	Built-in library
External built-in models	Register new built-in-style models out of tree without modifying the Exasim install.	External built-in library
Shared-library applications	Compile Text2Code-generated kernels into `libt2cmodel*` and link them into a standalone C++ app.	Shared library
MATLAB, Python, and Julia frontends	Configure PDEs, meshes, sweeps, export apps, and postprocess results from high-level languages.	Frontends
AI-assisted development	Use Codex, Claude, ChatGPT, Copilot, Gemini, and similar tools to draft examples, meshes, models, debugging plans, and validation workflows.	Using AI Tools
Physics model formulation	Choose `ModelC`, `ModelD`, or `ModelW`; add `w`, `v`, EOS, AV, and coupling mechanisms consistently.	Physics Models
Custom PDE development	Define fluxes, sources, boundary conditions, initial conditions, QoI, and visualization callbacks.	pdemodel abstraction
Parameter studies	Sweep `physicsparam` cases, write deterministic per-case outputs, and optionally warm-start continuation runs.	Parameter sweeps
Postprocessing and visualization	Generate VTK/ParaView output, QoI, surface/volume data, output-CG fields, and frontend visualization products.	Postprocessing
HPC execution	Build and run on local CPU/GPU systems and HPC machines such as Frontier and Tuolumne.	Installation
Reduced-basis solver support	Configure reduced-basis dimensions and related solver/preconditioner parameters in the runtime input.	pdeapp.txt fields

Getting Started Path¶

Install Exasim for your local or HPC platform.
Run the Quickstart to build and execute a built-in Poisson example.
Choose an Application Mode: built-in, external built-in, shared library, parameter sweep, or postprocessing.
Use the Frontends if you prefer MATLAB, Python, or Julia workflows.
Use Text2Code Applications if you want a text-file workflow based on pdeapp.txt and pdemodel.txt.
Use Using AI Tools to draft examples, meshes, model files, debugging prompts, and validation plans efficiently.
Learn how Exasim represents PDEs in Physics Models.
Learn custom model development through the pdemodel abstraction and pdemodel.txt guide.
Generate visualization and derived quantities with Postprocessing.
Explore design or physics spaces with Parameter sweeps.

Documentation Roadmap¶

If you are...	Recommended path
A new user	Quickstart → Installation → Application Modes
Running checked-in applications	Built-in library → pdeapp.txt fields → Postprocessing
Developing a custom PDE	Using AI Tools → Physics Models → Frontends → pdemodel abstraction → Text2Code `pdemodel.txt`
Building standalone text apps	Text2Code overview → pdeapp.txt guide → Workflow
Running parameter studies	Parameter sweeps → Postprocessing
Targeting HPC or GPUs	HPC build chain → Frontier or Tuolumne → CMake reference
Embedding Exasim in C++	Driving the solver → Model contract → CMake targets
Contributing or debugging internals	Architecture → Testing → Known divergences

Core Workflows¶

Run a Built-in Application¶

Use this path when an installed built-in model already matches your equations and variable ordering.

pdeapp.txt -> builtinmodelID -> Exasim builtin provider -> solver -> dataout/

Start with Built-in library applications.

Generate a Solver From Text Files¶

Use pdeapp.txt for application/runtime configuration and pdemodel.txt for the PDE model definition.

pdeapp.txt + pdemodel.txt -> Text2Code -> datain/ + kernels -> executable

Start with Text2Code Applications.

Develop a Custom PDE Model¶

Use frontend pdemodel callbacks or Text2Code model files to define fluxes, sources, boundary conditions, initial conditions, outputs, QoI, and visualization fields.

Start with Physics Models, pdemodel abstraction, and the model contract.

Perform Parameter Sweeps¶

Run the same generated solver over multiple physicsparam vectors, with deterministic output directories and optional warm-start continuation.

physicsparamcases -> paramcase_0001/, paramcase_0002/, ...

Start with Parameter sweeps.

Postprocess Results¶

Use solve-time or standalone postprocessing to generate visualization files, QoI, surface output, volume output, and frontend-readable results.

Start with Postprocessing.

Major Documentation Sections¶

Section	Purpose
Getting started	First build/run path and application-mode selection.
Installation	Local and HPC builds, dependencies, CUDA/HIP, and platform notes.
Text2Code Applications	Text-file application setup, model syntax, generation workflow, and references.
Frontends	MATLAB, Python, and Julia APIs, preprocessing, execution, postprocessing, and data structures.
Application Modes	Built-in, external built-in, shared-library, parameter-sweep, and postprocessing workflows.
Using AI Tools	Prompting, example generation, mesh generation, model implementation, debugging, extension, and validation workflows for AI assistants.
Physics Models	PDE formulations, auxiliary equations, EOS, external variables, AV, multiphysics, and coupling.
Theory	DG, LDG, HDG, DIRK, Newton-GMRES, preconditioning, parallelism, GPU execution, and scalability.
Reference	Model contract, `pdeapp.txt`, `pdemodel.txt`, Text2Code, and CMake details.
Driving the solver	C++ API entry points for embedding or custom applications.
Internals	Architecture, testing, baselines, and implementation notes.

Notes On Scope¶

Exasim emphasizes high-order PDE discretizations, generated model kernels, and portable HPC execution. It supports configurable polynomial order and stabilization/artificial-viscosity workflows; full automatic mesh adaptivity is not documented as a primary built-in workflow on this page. When in doubt, use the reference pages and checked-in examples as the implementation source of truth.