giamip 0.1.0__tar.gz

giamip-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 G-ADOPT Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

giamip-0.1.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: giamip
+Version: 0.1.0
+Summary: Case definitions, reference data and output conventions for the Spada (2011) and Martinec (2018) GIA benchmarks and for GIAMIP.
+Author-email: Siavash Ghelichkhan <siavash.ghelichkhan@anu.edu.au>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/g-adopt/giamip
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.14
+Requires-Dist: h5py>=3.16
+Requires-Dist: h5netcdf>=1.8
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-timeout>=2.3; extra == "test"
+Requires-Dist: ipython>=8; extra == "test"
+Requires-Dist: jupytext>=1.16; extra == "test"
+Requires-Dist: nbclient>=0.10; extra == "test"
+Requires-Dist: ipykernel>=6.29; extra == "test"
+Requires-Dist: matplotlib>=3.8; extra == "test"
+Requires-Dist: netCDF4>=1.7; extra == "test"
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.8; extra == "plot"
+Provides-Extra: docs
+Requires-Dist: jupyter>=1.0; extra == "docs"
+Requires-Dist: matplotlib>=3.8; extra == "docs"
+Dynamic: license-file
+
+# giamip
+
+Case definitions, reference data and output conventions for glacial isostatic
+adjustment (GIA) model comparison.
+
+This repository specifies what to run and holds what to compare against. It
+contains no solver. A solver reads a case with `giamip.case`, produces
+output, and uses this package to check that the output obeys the conventions
+and to score it against the reference data.
+
+Three collections are covered.
+
+| Collection | What it is | Reference answer |
+| --- | --- | --- |
+| Spada et al. (2011) | Ten tests of GIA codes: Love numbers, relaxation spectra, polar motion, and surface deformation for analytic loads | Published, several codes per test |
+| Martinec et al. (2018) | Five cases (A to E) of the sea level equation, from no ocean to a moving coastline | Published, the VEGA solution is the reference |
+| GIAMIP | Twelve experiments with global ice histories and present-day topography | None. This is an open intercomparison |
+
+## Install
+
+```
+pip install giamip
+```
+
+The package holds the code and the small JSON files: the case files, the load
+tables, the earth models, the manifest and the corrections. It holds no data
+file. Each data file is downloaded from data.gadopt.org the first time a
+reader needs it, checked against its SHA-256 sum, and cached. For
+development, install a checkout with `pip install -e ".[test]"`.
+
+## How to run a case
+
+```python
+import giamip
+from giamip.benchmarks.results import BenchmarkResult
+
+case = giamip.case("martinec2018-B")                    # the set-up of benchmark B
+h = case.ice_thickness(colatitude, longitude, t_kyr)     # the load at your points
+b = case.topography(colatitude, longitude)               # the ocean basin
+
+run = BenchmarkResult("B", "my-code")                    # your curves
+for profile in case.profiles:                            # what the case compares
+    for quantity in profile.quantities:
+        run.add_profile(profile.name, quantity, colatitude_deg,
+                        my_curve(profile, quantity))
+run.write("martinec2018-B.nc")                           # netCDF-4, through h5py
+
+rows = case.score(run)                                   # eq. 31, on your own points
+checks = case.envelope_check(run, band_half_width_deg=6.74)   # criterion 2
+```
+
+`giamip.case` gives a `MartinecCase`, a `SpadaCase` or a `GiamipExperiment`.
+`tests/test_doc_examples.py` runs this example. For a solver's own benchmark
+test, with both stages and the per-case list of what a result must hold, read
+the section "Using giamip in a solver's benchmark test" of
+`docs/reference/python-interface.qmd`.
+The reference curves of a Martinec case are VEGA, and
+`docs/protocol/martinec2018.qmd` says how each one is built.
+
+Each case also has a page in `docs/results/`, which gives the full
+specification: the earth model, the load, the time interval, the grid, the
+physical constants, the variables to produce and the data to compare against.
+Start with `docs/reference/solver-requirements.qmd`, which lists what a solver
+must be able to do, and `docs/reference/python-interface.qmd`, which shows the
+classes.
+
+## Data
+
+The data files are not in the package. The third-party originals (341 MB)
+belong to the people who produced them. The converted reference data (10 MB)
+is derived from them and is tracked in this repository under
+`data/converted/`. Both are in the gadopt object store at data.gadopt.org.
+`docs/data/manifest.qmd` records, for every file, its size, its SHA-256 sum,
+where it came from, who supplied it and under what terms.
+
+A reader finds a file with `giamip.data.locate`. It looks in the checkout
+(when it runs from one) and in the download root, and downloads the file into
+the download root when neither has it. The download root is
+`$GIAMIP_DATA_ROOT` when it is set, else `data/` of the checkout, else
+`~/.cache/giamip`. `docs/data/fetching.qmd` gives the details.
+
+Some of the original files contain defects. `docs/data/corrections.qmd` lists
+every one that is known, with the evidence. The readers apply the corrections.
+The original files are never edited.
+
+### On Gadi
+
+Gadi compute nodes have no network, and in a job the Firedrake module points
+`XDG_CACHE_HOME` at storage that is deleted when the job ends. So:
+
+1. The maintainer of the Firedrake module installs giamip with its
+   dependencies h5netcdf and `packaging` (h5py, numpy and scipy are there).
+2. On a login node, fill a directory on `/g/data` once:
+   `GIAMIP_DATA_ROOT=/g/data/<project>/giamip python -m giamip.data --stage converted --collection benchmarks`.
+   For the GIAMIP inputs (317 MB), run the same command with
+   `--collection giamip` and without `--stage converted`: they are originals.
+3. In the job script, set `GIAMIP_DATA_ROOT` to the same directory.
+
+A reader on a compute node that does not find a file raises
+`DataUnavailable`, and the message gives the command of step 2.
+
+## Layout
+
+```
+giamip/            the package: data.py (locate, fetch and verify),
+                    grids.py (the Gauss-Legendre grid), corrections.py
+                    (known defects in the originals), benchmarks/ (Martinec
+                    and Spada case set-up, results, scores and conversion)
+                    and mip/ (GIAMIP input readers). Not written: the GIAMIP
+                    output writer
+giamip/resources/  the JSON files the package carries: cases/ (one file per
+                    case, in benchmarks/ and giamip/), loads/ (the analytic
+                    load tables), models/ (the earth models), the manifest,
+                    the provenance record, the corrections and the column
+                    layouts
+docs/               the Quarto site: one page per collection, per reference
+                    table and per case, plus the data manifest and the list
+                    of corrections. docs/cases/ holds the pages for single
+                    tests as percent-format Python files, which the site
+                    executes and plots
+scripts/            conversion, manifest and upload scripts, run by hand, and
+                    check_installed.py, which checks an installed wheel
+submissions/        one directory per submission: its identity, its
+                    compliance report and its scores. The output fields
+                    themselves stay in outputs/
+tests/              the test suite
+data/               original/ holds third-party files byte for byte and is
+                    gitignored; converted/ holds the netCDF-4 files built
+                    from them and is tracked; versions/ holds downloaded
+                    converted files by SHA-256 and is gitignored
+outputs/            gitignored. The output fields a solver produced for a case
+```
+
+## Correspondence about the GIAMIP inputs
+
+We raised two defects in the GIAMIP inputs with the GIAMIP organisers. The
+correspondence is not in this repository, so this section records the result.
+
+**GLAC3 version names** (correction `glac3-version-naming`). The protocol
+table gives the ice history of Exp03, Exp04 and Exp09 to Exp11 as GLAC3b. The
+delivered files are `iceHistory-GLAC3c_profile1.nc` to
+`iceHistory-GLAC3c_profile3.nc`. On 2026-09-12, Holly Han, the lead of the
+protocol, confirmed that these files are the intended inputs. Each file
+combines GLAC3 versions a, b and c, with different versions for different ice
+sheets. The case files give the ice history as `GLAC3_p1`, `GLAC3_p2` or
+`GLAC3_p3`, with no version letter.
+
+**Topography source attribute** (correction `topography-source-attribute`).
+In `bedtopo_BedMach3ANT_BedMach5GRL_GEBCO_GLQ256.nc`, the `source` attribute
+names BedMachine Greenland twice. The first of the two entries must name
+BedMachine Antarctica v3. We reported this defect to Jan Swierczek-Jereczek on
+2026-09-12. Until a corrected file arrives, only the filename names the
+Antarctic dataset correctly. A corrected file has a new SHA-256 sum, and
+`tests/test_corrections.py` then fails until someone checks the correction
+against the new file.
+
+## Licence
+
+MIT for the code, the case definitions and the documentation. The third-party
+data in `data/original/` keeps the terms of whoever supplied it. See
+`LICENSE-DATA.md`.

giamip-0.1.0/README.md

@@ -0,0 +1,161 @@
+# giamip
+
+Case definitions, reference data and output conventions for glacial isostatic
+adjustment (GIA) model comparison.
+
+This repository specifies what to run and holds what to compare against. It
+contains no solver. A solver reads a case with `giamip.case`, produces
+output, and uses this package to check that the output obeys the conventions
+and to score it against the reference data.
+
+Three collections are covered.
+
+| Collection | What it is | Reference answer |
+| --- | --- | --- |
+| Spada et al. (2011) | Ten tests of GIA codes: Love numbers, relaxation spectra, polar motion, and surface deformation for analytic loads | Published, several codes per test |
+| Martinec et al. (2018) | Five cases (A to E) of the sea level equation, from no ocean to a moving coastline | Published, the VEGA solution is the reference |
+| GIAMIP | Twelve experiments with global ice histories and present-day topography | None. This is an open intercomparison |
+
+## Install
+
+```
+pip install giamip
+```
+
+The package holds the code and the small JSON files: the case files, the load
+tables, the earth models, the manifest and the corrections. It holds no data
+file. Each data file is downloaded from data.gadopt.org the first time a
+reader needs it, checked against its SHA-256 sum, and cached. For
+development, install a checkout with `pip install -e ".[test]"`.
+
+## How to run a case
+
+```python
+import giamip
+from giamip.benchmarks.results import BenchmarkResult
+
+case = giamip.case("martinec2018-B")                    # the set-up of benchmark B
+h = case.ice_thickness(colatitude, longitude, t_kyr)     # the load at your points
+b = case.topography(colatitude, longitude)               # the ocean basin
+
+run = BenchmarkResult("B", "my-code")                    # your curves
+for profile in case.profiles:                            # what the case compares
+    for quantity in profile.quantities:
+        run.add_profile(profile.name, quantity, colatitude_deg,
+                        my_curve(profile, quantity))
+run.write("martinec2018-B.nc")                           # netCDF-4, through h5py
+
+rows = case.score(run)                                   # eq. 31, on your own points
+checks = case.envelope_check(run, band_half_width_deg=6.74)   # criterion 2
+```
+
+`giamip.case` gives a `MartinecCase`, a `SpadaCase` or a `GiamipExperiment`.
+`tests/test_doc_examples.py` runs this example. For a solver's own benchmark
+test, with both stages and the per-case list of what a result must hold, read
+the section "Using giamip in a solver's benchmark test" of
+`docs/reference/python-interface.qmd`.
+The reference curves of a Martinec case are VEGA, and
+`docs/protocol/martinec2018.qmd` says how each one is built.
+
+Each case also has a page in `docs/results/`, which gives the full
+specification: the earth model, the load, the time interval, the grid, the
+physical constants, the variables to produce and the data to compare against.
+Start with `docs/reference/solver-requirements.qmd`, which lists what a solver
+must be able to do, and `docs/reference/python-interface.qmd`, which shows the
+classes.
+
+## Data
+
+The data files are not in the package. The third-party originals (341 MB)
+belong to the people who produced them. The converted reference data (10 MB)
+is derived from them and is tracked in this repository under
+`data/converted/`. Both are in the gadopt object store at data.gadopt.org.
+`docs/data/manifest.qmd` records, for every file, its size, its SHA-256 sum,
+where it came from, who supplied it and under what terms.
+
+A reader finds a file with `giamip.data.locate`. It looks in the checkout
+(when it runs from one) and in the download root, and downloads the file into
+the download root when neither has it. The download root is
+`$GIAMIP_DATA_ROOT` when it is set, else `data/` of the checkout, else
+`~/.cache/giamip`. `docs/data/fetching.qmd` gives the details.
+
+Some of the original files contain defects. `docs/data/corrections.qmd` lists
+every one that is known, with the evidence. The readers apply the corrections.
+The original files are never edited.
+
+### On Gadi
+
+Gadi compute nodes have no network, and in a job the Firedrake module points
+`XDG_CACHE_HOME` at storage that is deleted when the job ends. So:
+
+1. The maintainer of the Firedrake module installs giamip with its
+   dependencies h5netcdf and `packaging` (h5py, numpy and scipy are there).
+2. On a login node, fill a directory on `/g/data` once:
+   `GIAMIP_DATA_ROOT=/g/data/<project>/giamip python -m giamip.data --stage converted --collection benchmarks`.
+   For the GIAMIP inputs (317 MB), run the same command with
+   `--collection giamip` and without `--stage converted`: they are originals.
+3. In the job script, set `GIAMIP_DATA_ROOT` to the same directory.
+
+A reader on a compute node that does not find a file raises
+`DataUnavailable`, and the message gives the command of step 2.
+
+## Layout
+
+```
+giamip/            the package: data.py (locate, fetch and verify),
+                    grids.py (the Gauss-Legendre grid), corrections.py
+                    (known defects in the originals), benchmarks/ (Martinec
+                    and Spada case set-up, results, scores and conversion)
+                    and mip/ (GIAMIP input readers). Not written: the GIAMIP
+                    output writer
+giamip/resources/  the JSON files the package carries: cases/ (one file per
+                    case, in benchmarks/ and giamip/), loads/ (the analytic
+                    load tables), models/ (the earth models), the manifest,
+                    the provenance record, the corrections and the column
+                    layouts
+docs/               the Quarto site: one page per collection, per reference
+                    table and per case, plus the data manifest and the list
+                    of corrections. docs/cases/ holds the pages for single
+                    tests as percent-format Python files, which the site
+                    executes and plots
+scripts/            conversion, manifest and upload scripts, run by hand, and
+                    check_installed.py, which checks an installed wheel
+submissions/        one directory per submission: its identity, its
+                    compliance report and its scores. The output fields
+                    themselves stay in outputs/
+tests/              the test suite
+data/               original/ holds third-party files byte for byte and is
+                    gitignored; converted/ holds the netCDF-4 files built
+                    from them and is tracked; versions/ holds downloaded
+                    converted files by SHA-256 and is gitignored
+outputs/            gitignored. The output fields a solver produced for a case
+```
+
+## Correspondence about the GIAMIP inputs
+
+We raised two defects in the GIAMIP inputs with the GIAMIP organisers. The
+correspondence is not in this repository, so this section records the result.
+
+**GLAC3 version names** (correction `glac3-version-naming`). The protocol
+table gives the ice history of Exp03, Exp04 and Exp09 to Exp11 as GLAC3b. The
+delivered files are `iceHistory-GLAC3c_profile1.nc` to
+`iceHistory-GLAC3c_profile3.nc`. On 2026-09-12, Holly Han, the lead of the
+protocol, confirmed that these files are the intended inputs. Each file
+combines GLAC3 versions a, b and c, with different versions for different ice
+sheets. The case files give the ice history as `GLAC3_p1`, `GLAC3_p2` or
+`GLAC3_p3`, with no version letter.
+
+**Topography source attribute** (correction `topography-source-attribute`).
+In `bedtopo_BedMach3ANT_BedMach5GRL_GEBCO_GLQ256.nc`, the `source` attribute
+names BedMachine Greenland twice. The first of the two entries must name
+BedMachine Antarctica v3. We reported this defect to Jan Swierczek-Jereczek on
+2026-09-12. Until a corrected file arrives, only the filename names the
+Antarctic dataset correctly. A corrected file has a new SHA-256 sum, and
+`tests/test_corrections.py` then fails until someone checks the correction
+against the new file.
+
+## Licence
+
+MIT for the code, the case definitions and the documentation. The third-party
+data in `data/original/` keeps the terms of whoever supplied it. See
+`LICENSE-DATA.md`.

giamip-0.1.0/giamip/__init__.py

@@ -0,0 +1,70 @@
+"""Case definitions, reference data and output conventions for GIA model comparison.
+
+This package describes and checks work. It never performs it. Nothing here
+imports a solver, and nothing here computes a viscoelastic response. A solver
+reads a case with `case`, for example ``giamip.case("martinec2018-B")``,
+produces output, and uses this package to check
+that the output obeys the conventions and to score it against the published
+reference data.
+
+Three collections are covered, and they are different in kind:
+
+* Spada et al. (2011), Geophys. J. Int. 185, 106-132, doi:10.1111/j.1365-246X.2011.04952.x
+  Ten tests of GIA codes on analytic loads. Published answers from several codes.
+* Martinec et al. (2018), Geophys. J. Int. 215, 389-414, doi:10.1093/gji/ggy280
+  Five cases of the sea level equation. The VEGA solution is the reference.
+* GIAMIP, an open intercomparison with twelve experiments and no reference answer.
+
+Submodules
+----------
+data
+    Fetch the original files from the object store and verify them by SHA-256.
+    Imports only the standard library, so it runs before anything is installed.
+grids
+    The Gauss-Legendre quadrature grid that GIAMIP prescribes, and a validator
+    that checks a file's axes against it.
+corrections
+    Known defects in the original files, applied when a file is read. The
+    original files themselves are never edited.
+cases
+    Look up a case, an earth model or a load table.
+benchmarks
+    Martinec (2018) and Spada (2011) case set-up, results, scores and
+    conversion to NetCDF.
+mip
+    GIAMIP input readers. The output writer and compliance wrapper are not
+    written.
+
+Figures are drawn inline in the pages of ``docs/``, so the package holds no
+plotting code.
+"""
+
+__version__ = "0.1.0"
+
+
+def case(case_id: str):
+    """One case as an object, by id: the entry point for a solver.
+
+    ``martinec2018-*`` gives a `giamip.benchmarks.inputs.MartinecCase`,
+    ``spada2011-*`` a `giamip.benchmarks.inputs.SpadaCase` and ``giamip-*`` a
+    `giamip.mip.inputs.GiamipExperiment`. The classes are imported here and
+    not at the top, so that ``import giamip`` stays light.
+
+        >>> import giamip
+        >>> giamip.case("martinec2018-B").terminal_time_kyr
+        10.0
+
+    Raises KeyError for an id that is not a case of the package.
+    """
+    from giamip import cases
+    if case_id not in cases.ids():
+        raise KeyError(f"no case with id {case_id!r}. Known ids: {', '.join(cases.ids())}")
+    collection = case_id.split("-", 1)[0]
+    if collection == "martinec2018":
+        from giamip.benchmarks.inputs import MartinecCase
+        return MartinecCase(case_id)
+    if collection == "spada2011":
+        from giamip.benchmarks.inputs import SpadaCase
+        return SpadaCase(case_id)
+    from giamip.mip.inputs import GiamipExperiment
+    return GiamipExperiment(case_id)

giamip-0.1.0/giamip/_netcdf.py

@@ -0,0 +1,217 @@
+"""The small NetCDF helpers that every reader and writer of the package shares.
+
+Every NetCDF file in this package is opened through h5netcdf, a netCDF-4
+layer written in Python on top of h5py. Three properties decide this:
+
+* h5netcdf applies no mask, no scale factor and no fill value. It returns the
+  numbers stored in the file. The six GIAMIP ice files declare
+  ``_FillValue = 0.0`` on ``ice_thickness``, and a reader that masks would turn
+  every ice-free cell into a missing value (AGENTS.md, "Every reader in the
+  package opens NetCDF through h5netcdf").
+* It uses the HDF5 library that h5py brings. The Firedrake environment on Gadi
+  has h5py and no netCDF4, and a second HDF5 build in the same process is a
+  known source of conflicts.
+* The files it writes are ordinary netCDF-4 files: netCDF-C, ncdump and xarray
+  read them. tests/test_netcdf_io.py checks this with netCDF4.
+
+Only the core API ``h5netcdf.File`` is used. The ``legacyapi`` module failed
+on nested group access in h5netcdf 1.8.1.
+
+Two details of the format are handled here, so that no reader repeats them:
+
+* A text attribute that netCDF-C wrote comes back from h5py as ``bytes``
+  (``numpy.bytes_``), and one that h5netcdf wrote comes back as ``str``.
+  `attribute` turns both into ``str``.
+* netCDF-C stores a numeric attribute as an array even when it holds one
+  value, so a one-element array is returned as its single value.
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+import numpy as np
+
+
+def open_read(path: pathlib.Path):
+    """Open a NetCDF file for reading with h5netcdf.
+
+    Parameters
+    ----------
+    path
+        The file.
+
+    Returns
+    -------
+    h5netcdf.File
+        The open file. Use it as a context manager.
+    """
+    import h5netcdf
+    return h5netcdf.File(path, "r")
+
+
+def open_write(path: pathlib.Path, append: bool):
+    """Open a NetCDF file for writing with h5netcdf.
+
+    Parameters
+    ----------
+    path
+        The file.
+    append
+        True to add to an existing file, False to create a new one.
+
+    Returns
+    -------
+    h5netcdf.File
+        The open file. Use it as a context manager.
+    """
+    import h5netcdf
+    return h5netcdf.File(path, "a" if append else "w")
+
+
+def attribute(value):
+    """One attribute value as the package uses it.
+
+    Text becomes ``str`` whether netCDF-C (``bytes``) or h5netcdf (``str``)
+    wrote it. A one-element numeric array becomes its single value, a
+    NumPy scalar, which is what netCDF4's ``getncattr`` returned. Anything else
+    is returned unchanged.
+    """
+    if isinstance(value, (bytes, np.bytes_)):
+        return value.decode("utf-8")
+    if isinstance(value, np.ndarray):
+        if value.dtype.kind in "SO" and value.size == 1:
+            item = value.reshape(-1)[0]
+            return item.decode("utf-8") if isinstance(item, (bytes, np.bytes_)) else item
+        if value.size == 1:
+            return value.reshape(-1)[0]
+    return value
+
+
+def attributes(obj, skip=()) -> dict:
+    """The attributes of a file, group or variable as a dict, decoded.
+
+    Parameters
+    ----------
+    obj
+        An h5netcdf file, group or variable.
+    skip
+        Names to leave out.
+
+    Returns
+    -------
+    dict
+        Name to value, each passed through `attribute`. h5netcdf already hides
+        the attributes that HDF5 and netCDF-C use for their own bookkeeping
+        (``DIMENSION_LIST``, ``_Netcdf4Dimid`` and so on), except
+        ``_NCProperties``, which is left out here as well: it records library
+        versions and is not part of the content.
+    """
+    return {k: attribute(v) for k, v in obj.attrs.items()
+            if k not in skip and k != "_NCProperties"}
+
+
+def set_attributes(obj, values: dict) -> None:
+    """Write attributes, skipping None.
+
+    A Python ``bool`` is written as an 8-bit integer, because netCDF has no
+    boolean type.
+    """
+    for key, value in values.items():
+        if value is None:
+            continue
+        if isinstance(value, (bool, np.bool_)):
+            value = np.int8(value)
+        obj.attrs[key] = value
+
+
+def has_group(root, group_path: str) -> bool:
+    """Whether a slash-separated group path exists below an open file or group."""
+    group = root
+    for part in group_path.split("/"):
+        if part not in group.groups:
+            return False
+        group = group.groups[part]
+    return True
+
+
+def group_at(root, group_path: str):
+    """The group at a slash-separated path below an open file or group."""
+    group = root
+    for part in group_path.split("/"):
+        group = group.groups[part]
+    return group
+
+
+def create_group(root, group_path: str):
+    """Create the group at a slash-separated path, and any missing parents.
+
+    The last part must not exist yet, so that a second writer never adds to a
+    group another writer made (the callers check this first and raise with the
+    file name).
+    """
+    parts = group_path.split("/")
+    group = root
+    for part in parts[:-1]:
+        group = group.groups[part] if part in group.groups else group.create_group(part)
+    return group.create_group(parts[-1])
+
+
+def axis_of(group, variable) -> np.ndarray:
+    """The values of the coordinate variable of a variable's first dimension.
+
+    Every curve in this package's files is a 1-D variable whose dimension has a
+    coordinate variable of the same name in the same group.
+
+    Parameters
+    ----------
+    group
+        The group that holds the variable.
+    variable
+        The variable.
+    """
+    return np.asarray(group.variables[variable.dimensions[0]][...])
+
+
+def data_variables(group):
+    """The variables of a group that are not coordinate variables, by name."""
+    return {name: var for name, var in group.variables.items() if name not in group.dimensions}
+
+
+def write_curves(group, curves, *, axis_name: str, coordinate_attributes: dict,
+                 compress: bool = True) -> None:
+    """Write 1-D curves into one group, sharing an axis wherever two are equal.
+
+    The first distinct axis is called ``axis_name``, the next
+    ``axis_name_2``, and so on, so a group whose curves are sampled alike has
+    one axis. The curves are written in the order given.
+
+    Parameters
+    ----------
+    group
+        An open h5netcdf group.
+    curves
+        A sequence of ``(name, axis, values, attributes)``.
+    axis_name
+        The name of the first axis.
+    coordinate_attributes
+        The attributes of every axis variable, for example the units.
+    compress
+        Store the values with gzip. For curves of a few hundred points the
+        uncompressed form is smaller: compression needs chunked storage, whose
+        index costs more than it saves on short arrays.
+    """
+    axes: list[tuple[str, np.ndarray]] = []
+    for name, axis, values, attrs in curves:
+        axis = np.asarray(axis, dtype=float)
+        dim = next((d for d, a in axes if a.shape == axis.shape and np.array_equal(a, axis)), None)
+        if dim is None:
+            dim = axis_name if not axes else f"{axis_name}_{len(axes) + 1}"
+            axes.append((dim, axis))
+            group.dimensions[dim] = axis.size
+            coordinate = group.create_variable(dim, (dim,), "f8", data=axis)
+            set_attributes(coordinate, coordinate_attributes)
+        variable = group.create_variable(name, (dim,), "f8",
+                                         data=np.asarray(values, dtype=float),
+                                         compression="gzip" if compress else None)
+        set_attributes(variable, attrs)