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

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/.