Datasets:

mp6569
/

solve-anywhere-data

---
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 | 9.9M (2D, order 3) |
| 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.8M (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 | ~1.4M (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.
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), 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/`.

	---
	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 \| 9.9M (2D, order 3) \|
	\| 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.8M (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 \| ~1.4M (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.
	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), 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/`.