File size: 7,743 Bytes
73e6b79 30884fe 149dc59 30884fe 149dc59 30884fe 149dc59 30884fe 149dc59 30884fe 149dc59 30884fe | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | ---
license: cc-by-4.0
pretty_name: solve-anywhere linear-system sequences
size_categories:
- 10K<n<100K
tags:
- sparse-matrices
- linear-systems
- linear-solvers
- finite-element-method
- scientific-computing
---
# solve-anywhere linear-system sequences
Sparse linear systems `A x = b` captured from FEM simulations (MFEM and FEniCSx/DOLFINx).
Each problem is run across a refinement ladder (~1k up to 5-10M DoFs), several
polynomial orders, and a sweep of physical parameters. Every run keeps the *sequence*
of systems it solved (time steps, Newton iterations, load steps, frequencies), with
metadata, so selection and online learning can be studied on realistic sequences.
## Quick start
```python
import sys; sys.path.insert(0, "data/sequences")
from load import runs, systems, load, meta
for run in runs(problem="ex16p", max_n=1e6): # filter the catalog
m = meta(run) # mesh, order, parameters, ...
for rec in systems(run, "heat"): # per-system metadata
A, b, x = load(run, "heat", rec["sys"]) # scipy CSR, numpy arrays
```
`python load.py` prints a summary of the catalog; `python load.py --mtx <run> <stream> <i> <prefix>`
writes one system as Matrix Market files.
## Layout
```
catalog.jsonl one line per run (if a run was redone, the last line counts)
<source>/<problem>/<run>/ one simulation: fixed mesh + parameters
meta.json run metadata
log.txt the program's output
<stream>/index.jsonl one line per saved system, in order
<stream>/A_0000.npz matrix, CSR (scipy.sparse.load_npz); written only when it changes,
so consecutive systems may share one file (index field "A")
<stream>/sys_00000.npz b, x (the program's own solution), and extra vectors if any
```
A *stream* is one kind of system within a run (e.g. `jacobian`, or `pressure` and `velocity`
for Navier-Stokes).
## Metadata
**Run (`meta.json`)**: `description`; `mesh_file`, `dim`, `mesh_elements`, `mesh_element_types`,
`mesh_h_min`/`mesh_h_max`; per stream `space_<stream>`, `order_<stream>`, `vdim_<stream>`,
`ordering_<stream>`, `true_dofs_<stream>`, and `stream_<stream>` (what the matrix is);
physical parameters; `params` (the sweep values); `command`/`argv`; `nranks`; `sampling`
and `thinning` (see below); `wall_s`, `peak_rss_total_bytes` (all processes), `exit`.
**System (`index.jsonl`)**:
| field | meaning |
|---|---|
| `sys`, `A` | system number; matrix file id |
| `n`, `nnz` | size |
| `b_norm` | ‖b‖₂. For Newton streams b is the nonlinear residual, so this is the current Newton residual (FEniCSx also writes `newton_residual`, `newton_residual_rel`) |
| `context.step`, `context.t`, `context.dt` | time / load / frequency step |
| `context.solve_in_step` | solve index within the step, i.e. the Newton iteration for Newton problems |
| `context.ip_iter`, `mu` | contact: interior-point iteration and barrier parameter |
| `context.k` | Helmholtz wavenumber |
| `iters`, `converged`, `final_norm`, `solve_s`, `rel_tol`, `ksp`, `pc` | the program's own linear solve |
| `vectors` | arrays stored in `sys_*.npz`: `b`, `x`, optionally `x0` (initial guess), `contact_dofs`, `block_id` |
| `rank_row_starts` | first row of each MPI rank's block (MFEM orders vector DoFs byNODES *within* each rank) |
| `pure_neumann` | Navier pressure: singular system (constant null space) |
## Problems
| source / problem | systems | sweep | largest |
|---|---|---|---|
| mfem/ex10p — nonlinear elasticity (Neo-Hookean beam, backward Euler + Newton) | Jacobians, ~7/step | 3 materials (default; nearly incompressible; stiff), order 1-3, 2D/3D; 3D beam-hex stiffness sweep: μ ∈ {0.025, 0.25, 2.5, 25} × K/μ ∈ {2, 20, 200}, orders 1-3 (labels `beam-hex_o*_rs*_mu*_K*`) | 9.9M (2D, order 3); 840k (3D) |
| mfem/ex16p — nonlinear heat conduction | 1 matrix per step, 3 stages | conductivity nonlinearity α ∈ {0.01, 1, 100} | 5.3M |
| mfem/ex23 — wave equation | 1 matrix, 1 RHS per step | wave speed c ∈ {1, 10, 100} | 5.4M |
| mfem/ex31p — anisotropic definite Maxwell (Nédélec) | 1 per run | mass scale σ ∈ {1, 1e-2, 1e-4} | 9.0M |
| mfem/ex40p — Eikonal (proximal Galerkin, RT×L2 saddle point) | Newton systems; `block_id` vector | step size α ∈ {1, 10} | 8.9M |
| mfem/contact — frictionless contact (Tribol mortar, interior point) | reduced IP-Newton systems; `contact_dofs` vector | two-block, ironing, beam-sphere (linear / nonlinear) | 3.0M (3D only) |
| mfem/navier_shear — 2D periodic shear layer | pressure (singular) + velocity per step | viscosity | 7.4M |
| mfem/navier_3dfoc — 3D flow past a cylinder | pressure (singular) + velocity per step | order; viscosity 1e-3, 1e-2 | 895k velocity (3D) |
| fenicsx/poisson | 1 per run | coefficient: uniform, checkerboard contrast 1e3 / 1e6 | 5.9M |
| fenicsx/nonlinear_poisson — q(u) = 1 + βu² | Newton Jacobians (nonsymmetric) | β ∈ {1, 10, 100} | 5.9M |
| fenicsx/hyperelasticity — Neo-Hookean beam, 9 load steps | Newton Jacobians | Poisson ratio ν ∈ {0.3, 0.45, 0.49}; P1 tets and the tutorial's P2 hexes | 6.3M |
| fenicsx/ns_cylinder — DFG 2D-3, IPCS | 3 per step: tentative velocity (new each step), pressure, velocity correction | viscosity (Re 50/100/200) | 5.0M |
| fenicsx/helmholtz — real indefinite −Δu − k²u = f | 1 per wavenumber | wavenumber sweep (20 values, 8 on the largest meshes) | 5.9M |
Parameter sweeps cover runs below 500k DoFs; larger runs use the default parameters, except
the 3D runs added in November 2026 (ex10p beam-hex up to 840k DoFs; ex16p, ex23, ex31p,
navier_3dfoc, nonlinear Poisson and Helmholtz at 0.8-6.4M DoFs), which sweep parameters at
the large sizes too.
3D variants stop at 1-4M DoFs where the next refinement (8x) no longer fits in memory.
## Sampling
Small and medium runs keep every system. When a run would exceed its size budget
(500 MB, or enough for at least 5 matrices on the largest meshes; larger budgets for the
November 2026 3D runs, see `sampling.max_mb` in `meta.json`), systems are thinned
uniformly over the whole run: every k-th step is kept (with all of its Newton
iterations) when that still leaves at least 4 steps; otherwise every k-th system,
which spreads the samples evenly over all steps. `meta.json` records the
thinning factor (`thinning.k`, plus `sampling.step_stride` applied while running);
`index.jsonl` keeps each system's original position (`seen`, `context`).
## Caveats
- `x` is the program's own solution, not an exact reference: inexact Newton steps (ex10p,
Eisenstat-Walker tolerances) leave relative residuals up to ~0.2; most other streams are
solved to 1e-6-1e-12 (see `validation.jsonl`). 3D Helmholtz on the largest meshes stores no x.
- Changes to the programs' own solvers (systems are unaffected): ex10p uses GMRES + BoomerAMG
(instead of MINRES + Jacobi), Eisenstat-Walker tolerance capped at 0.1, up to 50 Newton
iterations, dt = 1 for the stiff/incompressible materials; Navier uses assembled matrices
(not partial assembly); contact uses AMGF with SuperLU_DIST; FEniCSx problems use
AMG-preconditioned Krylov solvers (MUMPS for small hyperelasticity runs and Helmholtz).
- Dirichlet conditions: rows/columns eliminated with a unit diagonal (both libraries).
- Runs that failed (e.g. Newton divergence) keep what they saved and have `exit != 0`.
## Regenerating
Code is in `generators/`: `run_all.py` (all runs; `--list` shows the plan), `mfem/` (patched
MFEM examples and `sa_dump.hpp`), `fenicsx/` (DOLFINx scripts and `sa_fenicsx.py`),
`sa_store.py` (format, packing), `validate.py`. Libraries are built in `external/`.
|