---
pretty_name: "EMVal"
license: cc-by-nc-4.0
task_categories:
  - other
tags:
  - electromagnetics
  - printed-circuit-board
  - surrogate-model
  - scientific-ml
  - physics-foundation-model
  - physics
size_categories:
  - n<1K
configs: []
viewer: false
---

# EMVal

## Motivation

Full-wave simulation gives electronic design its most faithful account of electromagnetic (EM) behavior, but at a cost that compounds with every geometry, material stack, port configuration, and frequency of interest. This scaling makes simulation a persistent bottleneck in design-space exploration. Physics foundation models have the potential to reduce this cost dramatically. Trained on a large and diverse set of simulated designs, they can predict responses for new designs quickly and at low cost.

EMVal is a benchmark suite designed to assess the quality of the predictions from such models. Given the three-dimensional geometry and material composition of a printed circuit board (PCB), together with a specified port excitation and frequency, a model must recover the board's complex time-harmonic response. The suite evaluates that response at two complementary levels: the electric and magnetic near fields, which expose the spatial structure of the solution, and the scattering parameters, which describe how incident waves are reflected and transmitted at the board's ports.

## Composition

The suite has two tracks over the same set of PCB structures:

| Track | Evaluation target |
|---|---|
| `EMVal-NF-v0` | complex electric and magnetic near fields at three-dimensional probe locations; this is the primary foundation-model target |
| `EMVal-SP-v0` | complex S-parameters across frequencies and port pairs; this is a downstream response-prediction task |

A model can enter either track or both tracks. Each metric is first computed for one board and is then averaged across boards with equal weight. [`PROTOCOL.md`](PROTOCOL.md) in this repository gives the exact definition of every metric.

### This release: v0

v0 is a public demonstration release of 500 labeled boards. It contains one split, `public`.

- **Size**: every board has an 8 mm × 8 mm footprint.
- **Stack-up**: three layers: a 35 µm copper signal layer, a 200 µm dielectric core, and a 35 µm copper ground plane. The release contains 219 boards with an FR4-class laminate (\\(ε_r\\) = 4.6, loss tangent = 0.011) and 281 boards with a low-loss RF laminate (\\(ε_r\\) = 3.55, loss tangent = 0.0027). Copper conductivity is 5.96 × 10^7 S/m.
- **Components**: planar copper traces and patches on the signal layer (transmission lines, filters, resonators, antennas); 103 boards have one port and 397 have two; 79 boards have plated vias to the ground plane.
- **Frequencies**: 101 points from 1 GHz to 20 GHz, the same grid for the S-parameters and the near fields.
- **Fields**: 10,000 three-dimensional probe locations per board. The sampling density is higher near metal regions, where fields are usually stronger, and a small fraction of probes lies within conductor volumes. Each probe has complex E and H vectors for every frequency and driven port.

| Split | Boards | Released | Size |
|---|---|---|---|
| `public` | 500 | designs and labels | ~41 GB (near fields), ~7 MB (S-parameters) |

### Evaluation

`EMVal-NF` reports three metric families for each of E and H. Global relative L2 pools all driven ports, frequencies, and probes for a board before normalization, so high-field regions contribute most strongly. Median local error first normalizes the vector error at each probe by the simulated field magnitude and then takes the median, so low- and high-magnitude regions have equal weight. Median local alignment measures agreement in vector direction and complex phase at each probe.

`EMVal-SP` reports real-and-imaginary RMSE in the complex plane, magnitude weighted-MAE in dB, and phase weighted-MAE in radians. The two weighted metrics use a sigmoid weight centered at −20 dB with a 2 dB rolloff. This weighting reduces the contribution of deep nulls, where magnitude and phase errors have limited engineering significance.

Each metric is defined for one board and then averaged across boards. Lower values are better for the error metrics. Higher values are better for median local alignment, where 1 is the optimum. [`PROTOCOL.md`](PROTOCOL.md) gives the formulas and reference-scorer output names.

### Files per board

`v0/public/boards/<design_id>/` contains three files. Everything is SI — meters, Hz, V/m, A/m, S/m — with the unit in the key name (`_m`, `_hz`) or an HDF5 attribute.

| File | For | Contents |
|---|---|---|
| `design.json` | everyone | the geometry and material properties. ~2–5 KB of JSON |
| `near_field.h5` | `EMVal-NF` | probe cloud, frequency grid, and the E/H labels. ~47–93 MB |
| `sparams.h5` | `EMVal-SP` | frequency grid and the S-parameter labels. ~15 KB |

Both HDF5 files contain the exact text of `design.json` in the `design_json` root attribute. Each file is therefore a complete sample for its track. The S-parameter track does not require the near-field files.

`design.json` keys:

| Key | What it is |
|---|---|
| `size_m` | board extent `[x, y]` in meters |
| `layers` | the stack-up, listed top to bottom: per layer its `index`, `type` (`metal`/`dielectric`), `subtype` (`signal`/`ground`/`core`), `thickness_m`, `material` (name, conductivity in S/m for metals; ε_r, loss tangent for dielectrics), and `shape`. The copper signal trace is a list of rectangles/polygons/circles in board coordinates |
| `ports` | one entry per port: `name`, a `signal` pin, and a list of `grounds` pins, each pin a `position`, `layer` and `width_m`. See "Ports and excitation" |
| `vias` | plated vias: position, `diameter_m` (these are cylinders), spanned layers |
| `solder_balls` | truncated-sphere solder balls (BGA boards; empty list in v0) |

The release provides geometric primitives rather than a voxel grid, raster, or padded array. A model can therefore select its own geometry representation.

`near_field.h5` (flat file, no groups):

| Dataset | Shape | Unit | Notes |
|---|---|---|---|
| `probes_m` | `[N, 3]` float32 | m | probe locations; `N` = 10,000 |
| `frequencies_hz` | `[F]` float64 | Hz | `F` = 101, 1–20 GHz |
| `E_real`, `E_imag` | `[P, F, N, 3]` float32 | V/m | `P` = number of ports |
| `H_real`, `H_imag` | `[P, F, N, 3]` float32 | A/m | |

Root attributes: `layout = "[excited_port, frequency, probe, xyz]"`, `E_units`, `H_units`, `coordinate_units`, `z_origin`, `design_id`, `design_json`, `labels_included`.

The probes form a three-dimensional point cloud rather than a plane. They extend beyond the board in x and y and occur below, within, and above the stack. One driven-port and frequency pair defines one field snapshot. A two-port board therefore contains 202 snapshots, each with 10,000 complex E and H vectors.

`sparams.h5` (flat file):

| Dataset | Shape | Unit | Notes |
|---|---|---|---|
| `frequencies_hz` | `[F]` float64 | Hz | the same grid as the near fields |
| `real`, `imag` | `[P, P, F]` float32 | — | layout `[port_out, port_in, frequency]` |

Root attributes: `layout`, `reference_impedance_ohm = 50.0`, `interpolated = false`, plus the same identity attributes as above.

`index.parquet` lists every board with `design_id`, `n_ports`, `n_frequencies`, `n_probes`, `labels`; `checksums.json` carries a SHA-256 per published file; `export_meta.json` records the export's provenance.

### What the data looks like

Every example in the dataset is procedurally generated from a design template. The following is one example of a split-ring resonator from the `public` split (`design_id: 534a8fe5...`). The geometry view below shows the signal copper, dielectric, ground plane, and the signal and ground pins of both ports:

![rotating board geometry](assets/board.gif)

The near-field view below shows E for the same board at 10.5 GHz with port 1 driven. The plot displays arrows at all 10,000 probes. Arrow direction follows the real field vector at zero phase. Arrow length follows the magnitude of that instantaneous vector, while the logarithmic color scale follows the complex-envelope magnitude |E|:

![rotating near field](assets/near_field.gif)

The S-parameter view below shows magnitude and unwrapped phase in radians for S11, S21, and S22 across the simulated frequency range. The transmission response has a notch near 13.4 GHz, where |S21| reaches approximately −33 dB.

![S-parameters](assets/sparams.png)

Reading actual values from this board, at the resonance (frequency index 65, 13.35 GHz):

```python
>>> S = sparams["real"][:] + 1j * sparams["imag"][:]      # (2, 2, 101)

>>> S[0, 0, 65], S[1, 0, 65]                              # S11, S21: response at port i with port j driven
((-0.820-0.452j), (0.021-0.010j))                         # |S11| = 0.94 (-0.6 dB), |S21| = 0.023 (-32.8 dB)

>>> E = nf["E_real"][:] + 1j * nf["E_imag"][:]            # (2, 101, 10000, 3)

>>> E[0, 65, 7230]                                        # port 1 driven, probe 7230 at (-0.68, -2.94, 0.23) mm
array([ 0.7-3.1j, 1656-6613j, 969-3862j])                 # (Ex, Ey, Ez) in V/m, |E| ≈ 7,900 V/m
```

Relevant physical and numerical properties include:

- The S-parameter matrix is reciprocal: `S[0, 1, f] == S[1, 0, f]` for every board. A model can enforce this constraint when it predicts the full `[P, P, F]` array.
- These values describe near fields, not plane waves. At probe 7230, |E| / |H| is approximately 1.8 kΩ. This ratio varies across the probe cloud.
- Field magnitude can span several orders of magnitude in one snapshot. The evaluation protocol reports a global relative L2 error, which emphasizes high-field regions, and a median local relative error, which gives equal weight to each probe after local normalization.

### Coordinate system

One right-handed frame is shared by the geometry and the field queries:

- x, y: origin at the board center; an 8 mm board spans −4 mm to +4 mm. Copper shapes in `design.json` and probe x/y in `near_field.h5` use the same axes.
- z: `z = 0` at the bottom face of the bottom-most layer, +z upward — stated per file by the `z_origin = "bottom_of_stack"` attribute. `layers` in `design.json` are listed top to bottom, so the last-listed layer touches z = 0 and layer z-extents are recovered by stacking `thickness_m` upward from the bottom of the list.
- A probe value is the total field at that location for the specified driven port and excitation frequency.

## Ports and excitation

The port definition includes both its geometry and excitation convention. Every port in `design.json` uses the same schema, whether the reference conductor is the plane below the signal pin or one or more adjacent pads:

```json
{
  "name": "P1",
  "signal": {
    "position": {"x": 0.000899, "y": 0.001186},
    "layer": 0,
    "width_m": 0.00045
  },
  "grounds": [
    {
      "position": {"x": 0.000899, "y": 0.001186},
      "layer": 2,
      "width_m": 0.00045
    }
  ]
}
```

- A port is a lumped port between its `signal` pin and its `grounds` pins. The excitation is applied from the ground pin (or pins) to the signal pin. A pin is a point on a conductor and has a `position`, `layer`, and `width_m`.
- In v0, every port is a vertical launch: the ground pin sits on the ground plane directly beneath the signal pin, so the excitation spans the dielectric between layer 0 and layer 2. Coplanar ports (ground pads on the same layer beside the signal) use the same schema with `grounds` on the signal's layer.
- Reference impedance is 50 Ω (also an attribute on `sparams.h5`).
- One port is driven at a time, and each other port is terminated in the reference impedance. The driven-port index is the leading axis of each field array: `E[j]` is the electric field with port `j + 1` driven. For S-parameters, `S[i, j, f]` is the response at receiving port `i + 1` with port `j + 1` driven at frequency index `f`.
- Ports are numbered by their order in `ports`; `name` (`P1`, `P2`, ...) matches that order.

A simulation must use this port convention to reproduce the released values.

## Loading

The Hugging Face dataset viewer and `load_dataset()` do not read this HDF5 layout. The viewer is therefore disabled; you can download the files and use an HDF5 library to read them. Each track requires only its corresponding files:

```python
from huggingface_hub import snapshot_download
import h5py, json, pandas as pd

# EMVal-SP: a few MB for the whole split
root = snapshot_download(
    repo_id="ArenaPhysica/EMVal",
    repo_type="dataset",
    allow_patterns=["v0/public/boards/*/sparams.h5", "v0/public/index.parquet"],
)
index = pd.read_parquet(f"{root}/v0/public/index.parquet")   # design_id, n_ports, n_frequencies, n_probes
design_id = index.design_id[0]
with h5py.File(f"{root}/v0/public/boards/{design_id}/sparams.h5") as f:
    design = json.loads(f.attrs["design_json"])
    S = f["real"][:] + 1j * f["imag"][:]          # (P, P, F), 50 ohm reference
    freqs = f["frequencies_hz"][:]                # (F,) Hz

# EMVal-NF: ~41 GB for the public split; narrow the pattern to a board id to fetch just one
root = snapshot_download(
    repo_id="ArenaPhysica/EMVal",
    repo_type="dataset",
    allow_patterns=["v0/public/boards/*/near_field.h5", "v0/public/index.parquet"],
)
with h5py.File(f"{root}/v0/public/boards/{design_id}/near_field.h5") as f:
    design = json.loads(f.attrs["design_json"])
    probes = f["probes_m"][:]                     # (N, 3) meters
    E = f["E_real"][:] + 1j * f["E_imag"][:]      # (P, F, N, 3) V/m
```

Every file's SHA-256 is in `v0/public/checksums.json`, keyed by path relative to `v0/public/`.

## Uses

EMVal is intended for evaluation of near-field and S-parameter predictors. The labels are full-wave simulation outputs (not measurements).

EMVal boards should NOT be used for model training. Published results must disclose any use of the evaluation geometries or labels during model development.

## Distribution and maintenance

A release version never mutates; changes ship as a new version with a changelog. Maintained by [Arena Physica](https://www.arenaphysica.com/). Licensed under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/): use and redistribution with attribution, no commercial use.