--- tags: - physics - simulation - FEM - PDE - neural-operator - scientific-computing - domain-decomposition size_categories: - 100K Bosch Logo

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 ```python 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]}") ``` ```python # 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,) ``` ```python # 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](https://fenicsproject.org/) (dolfinx) for the FEM solver and [gmsh](https://gmsh.info/) for mesh generation: ```bash # 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](https://arxiv.org/abs/2504.00510) 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: ```bibtex @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} } ```