SNI-Data

Created by Bosch Center for Artificial Intelligence (BCAI)
Paper: Operator Learning with Domain Decomposition for Geometry Generalization in PDE Solving (ICLR 2026)

A benchmark of 2D finite-element PDE solutions for training and evaluating neural operators with geometry generalization. Each sample is a complete FEM problem defined on an unstructured triangular mesh—random polygon geometry, boundary conditions (Dirichlet and/or Neumann), and optionally coefficient fields or time-stepping parameters—paired with the solved solution field $u$.

The dataset accompanies the Schwarz Neural Inference (SNI) framework, which combines local operator learning with domain decomposition methods to generalize to unseen complex geometries at inference time.

Dataset Summary

Property	Value
Domain	2D Partial Differential Equations (FEM)
Number of PDE types	5
Training samples	200,000
Test samples (simple domains)	26,500
Test samples (evaluation domains)	1,330
Total samples	~227,830
File format	Pickle (.pkl)
Mesh type	Unstructured triangular (gmsh)
Solver	FEniCSx (dolfinx)

PDE Types

PDE	Equation	Boundary Conditions	Type
laplace2d	$-\nabla^2 u = 0$	Dirichlet	Stationary
laplace2d_mixed	$-\nabla^2 u = 0$	Mixed Dirichlet / Neumann	Stationary
darcy2d	$-\nabla \cdot (a(x)\nabla u) = f(x)$	Dirichlet	Stationary
heat2d	$\partial u / \partial t - \alpha \nabla^2 u = 0$	Time-dependent Dirichlet	Transient
nonlinear_poisson2d	$-\nabla \cdot (q(u)\nabla u) = 0$, $q(u) = 1 + u^2$	Dirichlet	Stationary (nonlinear)

PDE Details

Laplace (Dirichlet): The classical Laplace equation on random polygonal domains with randomized Dirichlet boundary values at each boundary node.

Laplace (Mixed): Same equation, but the boundary is split into contiguous Dirichlet and Neumann segments. With probability 0.2 the entire boundary is Dirichlet; otherwise a random contiguous portion is assigned Neumann conditions.

Darcy Flow: A variable-coefficient elliptic PDE. The coefficient field $a(x)$ and source term $f(x)$ are independently randomized per node ($a \in [0, 1]$, $f \in [-5, 0]$). Boundary values are scaled by a random factor in $[0.3, 1.0]$.

Heat Equation: Time-dependent diffusion solved with implicit Euler. Training uses 10 time steps ($T = 0.1$, $\Delta t = 0.01$) with random thermal diffusivity $\alpha \in [0.1, 1.0]$. Evaluation uses 50 time steps ($T = 0.5$) with fixed $\alpha = 1.0$.

Nonlinear Poisson: A nonlinear PDE with solution-dependent diffusivity $q(u) = 1 + u^2$, solved via Newton's method with GMRES and BoomerAMG preconditioning.

Training Data

Training data is generated on random simple polygons with varying numbers of vertices, triangulated using gmsh.

Subset	Samples	Polygons × Batch	Vertices	Mesh Size
laplace2d_simple	20,000	2000 × 10	3–12	0.1
laplace2d_mixed_simple	40,000	2000 × 20	3–12	0.1
darcy2d_simple	40,000	2500 × 10	3–16	0.1
heat2d_simple	80,000	1600 × 50	3–12	0.1
nonlinear_poisson2d_simple	20,000	2000 × 10	3–12	0.1

Note: Each random polygon is reused for multiple samples (the "Batch" count) with different boundary conditions and/or coefficient fields. Coordinates are shifted by $[0.5, 0.5]$ to center domains around the origin.

Test Data

Simple Domain Test Sets

Test data on random polygons (same generation process as training, different samples):

Subset	Samples
laplace2d_simple	2,500
laplace2d_mixed_simple	4,000
darcy2d_simple	2,500
heat2d_simple	12,500
nonlinear_poisson2d_simple	2,500

Evaluation Domain Test Sets

Test data on pre-defined complex geometries (fixed meshes), used to evaluate geometry generalization:

Domain	Mesh File	Description
A (Schwarz)	A-schwarz.msh	Overlapping disk and rectangle
B (Holes)	B-holes.msh	Square with two interior holes
C (Bosch)	C-bosch.msh	Disk with complex shape removed

Each PDE is evaluated on each domain with 100 samples (10 for heat2d):

Subset	Domain A	Domain B	Domain C
laplace2d	100	100	100
laplace2d_mixed	100	100	100
darcy2d	100	100	100
heat2d	10	10	10
nonlinear_poisson2d	100	100	100

Additional evaluation meshes (D-dolphin.msh, E-disk.msh, F-triangle.msh) are available for extended evaluation.

Data Format

All data is stored in Python pickle files (.pkl). Each file contains a list of samples. The format varies by PDE type:

Laplace2d / Laplace2d Mixed / Nonlinear Poisson2d

Each sample is a tuple: (sol, [bc])

Array	Shape	Description
sol	(N, 3)	Solution field: [x, y, u] at each mesh node
bc	(M, 4)	Boundary conditions: [x, y, value, type] at each boundary node

• type = 0 → Dirichlet boundary condition ($u = \text{value}$)
• type = 1 → Neumann boundary condition ($\partial u / \partial n = \text{value}$)
• For laplace2d and nonlinear_poisson2d, all boundaries are Dirichlet (type = 0)

Darcy2d

Each sample is a tuple: (sol, [qf, bc])

Array	Shape	Description
sol	(N, 3)	Solution field: [x, y, u]
qf	(N, 4)	Coefficient and source: [x, y, a, f] at each mesh node
bc	(M, 4)	Boundary conditions: [x, y, u_D, 0]

Heat2d

Each sample is a tuple: (sol, alpha, [bc])

Array	Shape	Description
sol	(N, 2 + T)	Solution trajectory: [x, y, u_0, u_1, ..., u_{T-1}]
alpha	scalar	Thermal diffusivity
bc	(M, 2 + T + 1)	Boundary trajectory: [x, y, bc_0, ..., bc_{T-1}, 0]

• Training: $T = 10$ time steps ($\Delta t = 0.01$)
• Evaluation: $T = 50$ time steps ($\Delta t = 0.01$)

Directory Structure

data/
├── 2d/
│   ├── laplace2d_simple_20000_train.pkl
│   ├── laplace2d_simple_2500_test.pkl
│   ├── laplace2d_schwarz_100_test.pkl
│   ├── laplace2d_holes_100_test.pkl
│   ├── laplace2d_bosch_100_test.pkl
│   ├── laplace2d_mixed_simple_40000_train.pkl
│   ├── laplace2d_mixed_schwarz_100_test.pkl
│   ├── laplace2d_mixed_holes_100_test.pkl
│   ├── laplace2d_mixed_bosch_100_test.pkl
│   ├── darcy2d_simple_40000_train.pkl
│   ├── darcy2d_simple_2500_test.pkl
│   ├── darcy2d_schwarz_100_test.pkl
│   ├── darcy2d_holes_100_test.pkl
│   ├── darcy2d_bosch_100_test.pkl
│   ├── heat2d_simple_100000_train.pkl
│   ├── heat2d_simple_12500_test.pkl
│   ├── heat2d_schwarz_10_test.pkl
│   ├── heat2d_holes_10_test.pkl
│   ├── heat2d_bosch_10_test.pkl
│   ├── nonlinear_poisson2d_simple_20000_train.pkl
│   ├── nonlinear_poisson2d_simple_2500_test.pkl
│   ├── nonlinear_poisson2d_schwarz_100_test.pkl
│   ├── nonlinear_poisson2d_holes_100_test.pkl
└── └── nonlinear_poisson2d_bosch_100_test.pkl

Quick Start

import pickle

# Load training data
with open("data/2d/laplace2d_simple_20000_train.pkl", "rb") as f:
    datalist = pickle.load(f)

# Each sample is a tuple
sol, (bc,) = datalist[0]

# Solution field
x, y, u = sol[:, 0], sol[:, 1], sol[:, 2]  # (N,) each

# Boundary conditions
bx, by, bc_val, bc_type = bc[:, 0], bc[:, 1], bc[:, 2], bc[:, 3]

print(f"Number of samples: {len(datalist)}")
print(f"Mesh nodes: {sol.shape[0]}, Boundary nodes: {bc.shape[0]}")

# Load Darcy flow data (includes coefficient field)
with open("data/2d/darcy2d_simple_40000_train.pkl", "rb") as f:
    datalist = pickle.load(f)

sol, (qf, bc) = datalist[0]

# Coefficient field a(x) and source f(x)
a_coeff = qf[:, 2]  # (N,)
f_source = qf[:, 3]  # (N,)

# Load Heat equation data (time-dependent)
with open("data/2d/heat2d_simple_80000_train.pkl", "rb") as f:
    datalist = pickle.load(f)

sol, alpha, (bc,) = datalist[0]

# Solution at each time step
x, y = sol[:, 0], sol[:, 1]
u_timesteps = sol[:, 2:]  # (N, 10) — solution at 10 time steps
print(f"Thermal diffusivity: {alpha}")

Data Generation

Data is generated using FEniCSx (dolfinx) for the FEM solver and gmsh for mesh generation:

# Generate training data (parallelized across processes)
bash scripts/generate_data.sh laplace2d train 8

# Generate evaluation data on pre-defined domains
python data_generation/generate_eval.py --pde all --domain all

See the project repository for the full training and inference pipeline.

Intended Use

SNI-Dataset is designed to:

• Train and benchmark neural operators for PDE solving on irregular geometries.
• Evaluate geometry generalization — training on simple random polygons, testing on complex unseen domains.
• Support research on domain decomposition methods combined with learned operators.
• Provide a diverse set of PDE types (elliptic, parabolic, nonlinear) with varying boundary condition types.

Citation

If you use SNI-Dataset in your work, please cite:

@inproceedings{
  title={Operator Learning with Domain Decomposition for Geometry Generalization in PDE Solving},
  booktitle={International Conference on Learning Representations (ICLR)},
  year={2026},
  url={https://arxiv.org/abs/2504.00510}
}