CoilStellaration

CoilStellaration is a dataset of optimized stellarator coilsets for 14,496 plasma boundaries from ConStellaration, together with a benchmark for models that design coils.

Each sample pairs a plasma boundary with a randomly sampled set of engineering requirements, such as how far the coils must stay from each other and from the plasma. For every sample we designed a coilset with REGCOIL and, for two thirds of them, refined it with DESC. We then measured how accurately each coilset reproduces the plasma's magnetic field and how buildable it is.

Dataset Details

The plasma of a stellarator is shaped by the magnetic field of external coils. Once a plasma boundary is chosen, the coils have to reproduce its field accurately while staying buildable: spaced apart, clear of the plasma, and without sharp bends. Finding such coils takes an expensive optimization for every new design. This dataset lets optimization and machine learning researchers learn that step, for example to propose coils for a new plasma boundary in one shot or to warm-start a coil optimizer.

Plasma boundaries	14,496, with 2 to 5 field periods
Samples	266,549: 253,250 train, 13,299 eval, with no plasma boundary in both
DESC-optimized coilsets	177,341
REGCOIL coilsets	266,549
Coils per half-period	4 to 8

• Curated by: Proxima Fusion
• License: MIT
• Code: https://github.com/proximafusion/coilstellaration
• Paper: https://arxiv.org/abs/2611.12689
• Plasma boundaries and equilibria: https://huggingface.co/datasets/proxima-fusion/constellaration
• Benchmark leaderboard:: https://huggingface.co/spaces/proxima-fusion/coilstellaration-bench

Coilset metrics

Four metrics describe a coilset throughout the dataset and the benchmark:

Metric	Meaning	Better
Field error	|B·n| / |B| on the plasma boundary: how much the coils' field crosses the boundary instead of running along it	Lower
Coil-coil distance	Smallest gap between any two coils	Higher
Coil-plasma distance	Smallest gap between any coil and the plasma	Higher
Curvature	Sharpest bend of any coil	Lower

Distances and curvatures are normalized by the plasma's minor radius (normalized_*), so devices of different sizes compare directly.

Dataset Structure

Subset	Rows	Size	Contents
results (default)	266,549	0.3 GB	One row per sample: its requirements, summaries of its metrics, benchmark labels, and the IDs of its full objects in the other subsets. Start here.
coilsets	443,890	2.3 GB	Coil shapes and currents, REGCOIL and DESC
requirements	266,549	0.08 GB	The sampled requirements
metrics	343,272	213 GB	Full metrics of each coilset: values along every coil and over the plasma boundary

coilsets, requirements and metrics each hold an id and a json column. The plasma boundaries are not copied here: constellaration_boundary_id is the plasma_config_id of a boundary in ConStellaration.

The main columns of results:

Column	Contents
constellaration_boundary_id	The plasma boundary, in ConStellaration
regcoil_coilset_id, desc_coilset_id	The coilsets, in coilsets. desc_coilset_id is null if the sample has no DESC coilset
regcoil_metrics_id, desc_metrics_id	Their full metrics, in metrics. Null where the metrics were not evaluated
reqs/*	The sampled requirements
desc_metrics/*, regcoil_metrics/*	Summaries of each metric over the coils or the plasma boundary, e.g. desc_metrics/normalized_field_error/mean or desc_metrics/normalized_coil_to_coil_min_distances/min
boundary.n_field_periods	Number of field periods
benchmark/*	Benchmark track and stratum, see Benchmark
baseline_labels/*	Labels for selecting ML-baseline training data, e.g. the relative deviation of the DESC coilset from its requirements

A coilset stores only its unique coils: the others are rotated and mirrored copies. Each coil is a closed curve given by Fourier coefficients of its x, y and z coordinates (coil_x_n, coil_y_n, coil_z_n, in meters) in the layout of DESC's FourierXYZCoil, with one current per coil (currents, in amperes). The example below expands a coilset into all its coils.

Uses

Quick start

Install Hugging Face Datasets with pip install datasets, then load the results of one benchmark subset with the metrics of their DESC coilsets:

import datasets

ds = datasets.load_dataset(
    "proxima-fusion/coilstellaration",
    split="train",
    num_proc=4,
)
ds = ds.filter(
    lambda fixed_shape, stratum: fixed_shape and stratum == "tight",
    input_columns=["benchmark/fixed_shape_track", "benchmark/stratification"],
    num_proc=4,
)
df = ds.select_columns([
    "constellaration_boundary_id",
    "desc_coilset_id",
    "reqs/n_coils_per_half_period",
    "desc_metrics/normalized_coil_to_coil_min_distances/min",
    "desc_metrics/normalized_coil_to_plasma_min_distances/min",
    "desc_metrics/normalized_coil_curvatures/max",
    "desc_metrics/normalized_field_error/mean",
]).to_pandas()
print(len(df))
print(df.iloc[0])

Output

17665
constellaration_boundary_id                                 DMeu2cxMJsjMofBTp87cHvw
desc_coilset_id                                             DFt6uA9VbfQNVkoDpkLwUE8
reqs/n_coils_per_half_period                                                      5
desc_metrics/normalized_coil_to_coil_min_distances/min                     0.637426
desc_metrics/normalized_coil_to_plasma_min_distances/min                   0.845493
desc_metrics/normalized_coil_curvatures/max                                4.016498
desc_metrics/normalized_field_error/mean                                   0.001814
Name: 0, dtype: object

Fetch a coilset

coilsets and metrics are large, so fetch single objects by ID. Each subset has an id_to_file_map.parquet that says which file holds an ID:

import json

import pandas as pd

repo = "hf://datasets/proxima-fusion/coilstellaration"


def load_json_by_id(subset: str, object_id: str) -> dict:
    id_to_file = pd.read_parquet(
        f"{repo}/{subset}/id_to_file_map.parquet", filters=[("id", "==", object_id)]
    )
    path = id_to_file["path"].iloc[0]
    row = pd.read_parquet(f"{repo}/{path}", filters=[("id", "==", object_id)]).iloc[0]
    return json.loads(row["json"])


coilset = load_json_by_id("coilsets", df["desc_coilset_id"].iloc[0])

Turn it into points along every coil of the device:

import numpy as np


def coil_curves(coilset: dict, n_points: int = 128) -> np.ndarray:
    """Points along every coil of the device, in meters."""
    xyz_n = np.stack([coilset["coil_x_n"], coilset["coil_y_n"], coilset["coil_z_n"]])
    order = (xyz_n.shape[-1] - 1) // 2
    s = np.linspace(0, 2 * np.pi, n_points, endpoint=False)
    n = np.arange(-order, order + 1)[:, None]
    # Columns are ordered [sin(N s), ..., sin(s), 1, cos(s), ..., cos(N s)]
    basis = np.where(n < 0, np.sin(-n * s), np.cos(n * s))
    coils = np.einsum("dcm,ms->csd", xyz_n, basis)  # [unique coil, point, xyz]
    if coilset["is_stellarator_symmetric"]:
        coils = np.concatenate([coils, coils * [1, -1, -1]])
    nfp = coilset["n_field_periods"]
    rotations = [
        np.array([[np.cos(a), -np.sin(a), 0], [np.sin(a), np.cos(a), 0], [0, 0, 1]])
        for a in 2 * np.pi * np.arange(nfp) / nfp
    ]
    return np.concatenate([coils @ r.T for r in rotations])


curves = coil_curves(coilset)  # (30, 128, 3): 5 unique coils x 2 mirror halves x 3 field periods

load_json_by_id("metrics", ...) works the same way. Its large arrays are stored as base64-encoded .npy files, e.g. np.load(io.BytesIO(base64.b64decode(metrics["normalized_field_error"]["content"]))).

Get the plasma boundaries

Join the boundaries from ConStellaration; its dataset card shows how to plot them and load their equilibria:

boundaries = (
    datasets.load_dataset(
        "proxima-fusion/constellaration",
        columns=["plasma_config_id", "boundary.json"],
        split="train",
        num_proc=4,
    )
    .to_pandas()
    .set_index("plasma_config_id")
)
df = df.join(boundaries, on="constellaration_boundary_id")

With the coilstellaration library

The coilstellaration library loads typed objects, plots coilsets, evaluates metrics and runs the benchmark. It needs a few system packages (NetCDF, gfortran, CMake), listed in its README along with a ready-made devcontainer:

git clone https://github.com/proximafusion/coilstellaration
cd coilstellaration
pipx install hatch
hatch env create

from coilstellaration import coilset_utils, data_utils, desc_utils, metrics_utils_v2, plot_utils

# Benchmark instances: plasma boundary, reference coilset, targets and DESC equilibrium
eval_data = data_utils.load_benchmark_dataset(
    track="fixed_shape", stratum="tight", split="eval", n=4
)
sample = eval_data[0]

# Plot the coilset around the plasma
figure = plot_utils.plot_surface(sample.boundary)
figure = plot_utils.plot_coilset(sample.true_coilset, figure=figure)
figure.show()

# Evaluate a coilset's metrics the way the benchmark does
metrics = metrics_utils_v2.evaluate_coilset_metrics(
    eq=desc_utils.desc_equilibrium_to_desc_object(sample.desc_equilibrium),
    coilset=coilset_utils.coilstellaration_to_desc(sample.true_coilset),
)
data_utils.metrics_to_requirement_metrics(metrics)  # == sample.requirement_metrics

Benchmark

Task: given a plasma boundary, a number of coils and four targets, output a coilset that meets all four targets: at least the target coil-coil and coil-plasma distances, and at most the target curvature and maximum field error. The targets are the metrics the dataset's own DESC coilset achieves, so every instance has a known solution.

There are two tracks, scored separately:

• fixed_shape: 3 field periods and 5 coils per half-period. 53,206 train and 2,771 eval instances.
• variable_shape: 2 to 5 field periods and 4 to 8 coils per half-period. 155,850 train and 8,058 eval instances. There are no instances with 3 field periods and 7 or 8 coils, or 5 field periods and 8 coils.

Instances are split into thirds, called strata, by the mean field error of the reference coilset: tight (below 0.31%), medium, and loose (above 1.25%).

Each target scores between 0 and 1 depending on how far the prediction misses it, and the four scores are combined by their geometric mean. The leaderboard ranks models by the fraction of instances where they meet every target to within 0.1%, then by mean score. The coilstellaration README explains the scoring in full and how to submit a model.

Dataset Creation

Curation Rationale

Learning to design coils needs many coilsets, across many plasma boundaries and requirements, all computed and evaluated the same way. CoilStellaration provides them, with the code to evaluate new coilsets on the same footing.

Data Collection and Processing

For each sample, we:

1. Sampled requirements for one ConStellaration plasma boundary, from the ranges below. 3 field periods with 5 coils per half-period, the fixed_shape combination, has about 56,600 samples; every other combination has 6,000 to 14,000.
2. Ran REGCOIL, which computes a smooth current distribution on a surface around the plasma and cuts it into discrete coils. It is fast, but controls the engineering requirements only indirectly.
3. Optimized with DESC, starting from the REGCOIL coilset: lower the field error and the coil length, subject to the distance and curvature requirements.

After steps 2 and 3, the coil currents were scaled to an on-axis field of about 1 T, and the metrics were evaluated on the plasma boundary's DESC equilibrium from ConStellaration.

Requirement	Meaning	Range
normalized_min_coil_to_coil_distance	Minimum coil-coil distance	0.1 to 0.7
normalized_min_coil_plasma_distance	Minimum coil-plasma distance	0.5 to 1.0
normalized_max_coil_curvature	Maximum curvature	1.5 to 5.0
n_coils_per_half_period	Number of unique coils	4 to 8
regcoil_winding_surface_plasma_distance	Distance from the plasma to the surface REGCOIL places currents on	0.5 to 1.0
regcoil_target_option, regcoil_maximum_normalized_field_error	Whether REGCOIL aims for the coil-coil distance or for this field error	0.001 to 0.1
coil_fourier_order	Number of Fourier modes per DESC coil	7
desc_objective_lambda_log10	Weight of coil length against field error in DESC, log10	−3 to −1
desc_x_scale_mode	Variable scaling of the DESC optimizer	auto, ess_1, ess_2 or ess_inf

Distances are in minor radii, curvature in inverse minor radii.

Personal and Sensitive Information

The dataset contains no personally identifiable information.

Citation

BibTeX:

@inproceedings{ewers2026coilstellaration,
  title         = {{CoilStellaration}: A Dataset and Benchmark for Engineering-Aware Stellarator Coilset Generation},
  author        = {Ewers, Jan-Hendrik and Cadena, Santiago A. and Foppiani, Nicol{\`o} and Merlo, Andrea},
  booktitle     = {40th Conference on Neural Information Processing Systems (NeurIPS 2026), Track on Evaluations and Datasets},
  year          = {2026},
  doi           = {10.48550/arXiv.2611.12689},
  eprint        = {2611.12689},
  archivePrefix = {arXiv},
  url           = {https://arxiv.org/abs/2611.12689}
}

The plasma boundaries and equilibria come from ConStellaration:

@inproceedings{cadena2025constellaration,
  title         = {{ConStellaration}: A dataset of {QI}-like stellarator plasma boundaries and optimization benchmarks},
  author        = {Cadena, Santiago A. and Merlo, Andrea and Laude, Emanuel and Bauer, Alexander and Agrawal, Atul and Pascu, Maria and Savtchouk, Marija and Bonauer, Lukas and Guiraud, Enrico and Hudson, Stuart R. and Kaiser, Markus},
  booktitle     = {The Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track},
  year          = {2025},
  eprint        = {2506.19583},
  archivePrefix = {arXiv},
  url           = {https://openreview.net/forum?id=NQSbGKlCpx}
}

Glossary

Term	Meaning
Field period	A stellarator repeats its shape several times around the torus; each repeat is a field period
Half-period, stellarator symmetry	Each field period consists of two halves that map onto each other by a 180° flip, so only the coils of one half-period need to be stored
Minor radius	The average radius of the plasma cross-section, used to normalize lengths
QI	Quasi-isodynamic: the stellarator type of the ConStellaration boundaries
REGCOIL	Regularized current-potential coil design code
DESC	Stellarator equilibrium and optimization code, used here to optimize coils
ESS	Exponential spectral scaling, a variable-scaling option of DESC's optimizer

Dataset Card Authors

Jan-Hendrik Ewers

Dataset Card Contact

jhewers@proximafusion.com