PyBaMM-GEM 0.2.0__tar.gz → 0.2.2__tar.gz

pybamm_gem-0.2.2/.github/workflows/ci.yml

@@ -0,0 +1,63 @@
+# Runs on every push and pull request, and every Monday against the newest PyBaMM and the newest
+# PyBaMM model zoo (pybamm-model-zoo): ruff, GEM's tests and the zoo's contract checks.
+# Weekly runs only: if a check fails, ONE issue is opened (or commented on) and @mohammedasher is
+# mentioned, so GitHub emails him. When the weekly run passes again, the issue is closed.
+# It never changes any code.
+name: CI
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: "17 6 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  issues: write
+
+jobs:
+  test:
+    name: Newest PyBaMM and model zoo
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install
+        run: |
+          pip install --upgrade pip
+          pip install --upgrade pybamm pybamm-model-zoo
+          pip install -e ".[dev]"
+          python -c "import pybamm, pybamm_model_zoo; print('PyBaMM', pybamm.__version__, ' zoo', pybamm_model_zoo.__version__)"
+      - name: Lint
+        run: ruff check src tests scripts
+      - name: Test (GEM's tests and the zoo's contract checks)
+        run: pytest
+
+  report:
+    name: Weekly report
+    needs: [test]
+    if: ${{ always() && github.event_name == 'schedule' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open, update or close the "Weekly check failed" issue
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          RESULT: ${{ needs.test.result }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          TITLE="Weekly check failed"
+          NUMBER=$(gh issue list --repo "$REPO" --state open --search "$TITLE in:title" --json number --jq '.[0].number')
+          if [ "$RESULT" = "success" ]; then
+            if [ -n "$NUMBER" ]; then
+              gh issue comment "$NUMBER" --repo "$REPO" --body "Passing again with the newest PyBaMM and model zoo: $RUN_URL"
+              gh issue close "$NUMBER" --repo "$REPO"
+            fi
+          elif [ -z "$NUMBER" ]; then
+            gh issue create --repo "$REPO" --title "$TITLE" --body "@mohammedasher the weekly check against the newest PyBaMM and model zoo failed: $RUN_URL"
+          else
+            gh issue comment "$NUMBER" --repo "$REPO" --body "@mohammedasher failed again: $RUN_URL"
+          fi

pybamm_gem-0.2.2/.github/workflows/monthly-report.yml

@@ -0,0 +1,63 @@
+# On the 1st of every month: installs PyBaMM-GEM from PyPI (what users get) with the newest
+# PyBaMM and model zoo, runs the tests and scripts/health_report.py, and posts the result as a
+# comment on the pinned "Monthly health report" issue, mentioning the people below so GitHub
+# emails them. It never changes any code.
+name: Monthly health report
+
+on:
+  schedule:
+    - cron: "0 7 1 * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  issues: write
+  actions: read
+
+jobs:
+  report:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install PyBaMM-GEM from PyPI with the newest PyBaMM and model zoo
+        run: |
+          pip install --upgrade pip
+          pip install --upgrade pybamm-gem pybamm pybamm-model-zoo pytest
+      - name: Run the tests and the health report
+        run: |
+          cd /tmp
+          pytest --import-mode=importlib --pyargs pybamm_gem -q > tests.txt 2>&1 || true
+          python "$GITHUB_WORKSPACE/scripts/health_report.py" report.md
+      - name: Post the report
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          PEOPLE: "@gjo97 @MonicaMarinescu @mohammedasher"
+        run: |
+          cd /tmp
+          WEEKLY=$(gh run list --repo "$REPO" --workflow ci.yml --event schedule --limit 4 --json conclusion --jq '[.[].conclusion] | join(", ")')
+          {
+            echo "## PyBaMM-GEM health report, $(date -u +%Y-%m)"
+            echo
+            echo "$PEOPLE: the monthly check of PyBaMM-GEM (as installed from PyPI) with the newest PyBaMM and PyBaMM model zoo."
+            echo
+            cat report.md
+            echo
+            echo "**Model tests:** $(tail -n 1 tests.txt)"
+            echo
+            echo "**Last weekly checks (newest first):** ${WEEKLY:-none yet}"
+            echo
+            echo "Details: $RUN_URL"
+          } > body.md
+          TITLE="Monthly health report"
+          NUMBER=$(gh issue list --repo "$REPO" --state open --search "$TITLE in:title" --json number --jq '.[0].number')
+          if [ -z "$NUMBER" ]; then
+            URL=$(gh issue create --repo "$REPO" --title "$TITLE" --body "A health report of PyBaMM-GEM is added here as a comment on the 1st of every month.")
+            NUMBER=${URL##*/}
+            gh issue pin "$NUMBER" --repo "$REPO" || true
+          fi
+          gh issue comment "$NUMBER" --repo "$REPO" --body-file body.md

pybamm_gem-0.2.2/.github/workflows/release.yml

@@ -0,0 +1,103 @@
+# Publishes PyBaMM-GEM when a GitHub release is published (tag "v" + the version in pyproject.toml).
+#   1. Build the package and run its tests.
+#   2. Upload to TestPyPI, install it from there and run the tests again.
+#   3. Upload to PyPI. This step waits until a maintainer approves it (GitHub environment "pypi").
+# No tokens are stored anywhere: PyPI and TestPyPI trust this workflow ("trusted publishing").
+# Running it by hand (Actions -> Release -> Run workflow) only does steps 1 and 2, as a test.
+name: Release
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build and test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Check that the release tag matches the version
+        if: github.event_name == 'release'
+        run: |
+          VERSION=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+          if [ "v$VERSION" != "$GITHUB_REF_NAME" ]; then
+            echo "The tag is $GITHUB_REF_NAME but pyproject.toml says version $VERSION"
+            exit 1
+          fi
+      - name: Build
+        run: |
+          pip install build twine
+          python -m build
+          twine check dist/*
+      - name: Test the built package
+        run: |
+          pip install dist/*.whl pytest
+          cd /tmp
+          pytest --import-mode=importlib --pyargs pybamm_gem
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  testpypi:
+    name: Upload to TestPyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment: testpypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          skip-existing: true
+
+  check-testpypi:
+    name: Install from TestPyPI and test
+    needs: testpypi
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install and test
+        run: |
+          VERSION=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+          pip install "pybamm[cite]>=26.9" pytest
+          # A new upload can take up to 15 minutes to appear on TestPyPI
+          for attempt in $(seq 1 30); do
+            if pip install --no-cache-dir --no-deps --index-url https://test.pypi.org/simple/ "pybamm-gem==$VERSION"; then
+              break
+            fi
+            sleep 30
+          done
+          cd /tmp
+          python -c "import pybamm_gem; print(pybamm_gem.__version__, pybamm_gem.list_models())"
+          pytest --import-mode=importlib --pyargs pybamm_gem
+
+  pypi:
+    name: Upload to PyPI (needs approval)
+    needs: check-testpypi
+    if: github.event_name == 'release'
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

pybamm_gem-0.2.2/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## 0.2.2
+
+- README: the models first, then installation and usage, then a description of PyBaMM-GEM.
+- Tests: the PyBaMM model zoo's contract checks run on every GEM model
+  (`pybamm-model-zoo` added to the `dev` extra).
+- CI: weekly checks against the newest PyBaMM and PyBaMM model zoo, and a monthly health report.
+- Release workflow: waits up to 15 minutes for TestPyPI to list a new upload.
+
+## 0.2.1
+
+- `pybamm_gem` now has the same commands as the PyBaMM model zoo: `require()` is new, and
+  `info()`, `load()`, `require()` and `register_citation()` accept the class name (for example
+  `"BasicSPM2D"`) as well as the slug (`"spm_2d"`).
+- `info()` fields can be read as `info.title` as well as `info["title"]`.
+
+## 0.2.0
+
+- Rebuilt in the PyBaMM model-zoo layout: one folder per model, each with a `model.toml`
+  manifest, `CITATION.bib`, `README.md`, tests and an example.
+- Models: `spm_2d` (`BasicSPM2D`), `spm_3d` (`BasicSPM3D`), `dfn_2d` (`DFN2D`) and `dfn_3d` (`DFN3D`).
+- Registry: `pybamm_gem.list_models()`, `pybamm_gem.info()` and `pybamm_gem.load()`.
+- Example notebook: `examples/higher_dimensional_models.ipynb`.
+- Needs PyBaMM 26.9 or newer.
+- The previous code is kept on the branch `legacy-2026-11`.

pybamm_gem-0.2.2/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.5
+Name: PyBaMM-GEM
+Version: 0.2.2
+Summary: Spatially resolved (2D and 3D) battery models for PyBaMM
+Author: Mohammed Asheruddin N
+License-Expression: BSD-3-Clause
+License-File: LICENSE.txt
+License-File: LICENSES-bundled.txt
+Keywords: battery,electrochemistry,lithium-ion,modelling,pybamm,simulation
+Requires-Python: >=3.10
+Requires-Dist: pybamm[cite]>=26.9
+Requires-Dist: tomli>=2.0.1; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: pybamm-model-zoo; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# PyBaMM-GEM
+
+An open-source extension package for PyBaMM providing advanced battery models, degradation
+models, and simulation tools.
+
+## Models
+
+```python
+import pybamm_gem as gem
+
+print(gem.list_models())
+# ['dfn_2d', 'dfn_3d', 'spm_2d', 'spm_3d']
+```
+
+| Model | Class | What it is |
+|---|---|---|
+| `dfn_2d` | `DFN2D` | Doyle-Fuller-Newman model resolved in x and z |
+| `dfn_3d` | `DFN3D` | The same, resolved in x, y and z |
+| `spm_2d` | `BasicSPM2D` | Single Particle Model with a pair of particles at every height z |
+| `spm_3d` | `BasicSPM3D` | The same, over a y-z grid of points |
+
+## Installation
+
+```
+pip install pybamm-gem
+```
+
+PyBaMM 26.9 or newer is needed. To get the newest code from GitHub instead:
+`pip install git+https://github.com/ImperialCollegeLondon/PyBaMM-GEM`
+
+## Usage
+
+```python
+import pybamm
+import pybamm_gem as gem
+
+print(gem.list_models())
+model = gem.load("spm_2d")()
+simulation = pybamm.Simulation(model)
+solution = simulation.solve([0, 3000])
+print(solution["Voltage [V]"](1500))
+```
+
+The classes are also available directly, for example `gem.lithium_ion.BasicSPM2D` or
+`gem.lithium_ion.DFN2D`.
+
+The commands are the same as in the PyBaMM model zoo (`pybamm_model_zoo`): `list_models()`,
+`info()`, `load()`, `require()` and `register_citation()`. `info()`, `load()`, `require()` and
+`register_citation()` take either the slug (`"spm_2d"`) or the class name (`"BasicSPM2D"`);
+`list_models()` returns the slugs. With `pybamm-model-zoo` installed, the GEM models are also
+listed by `pybamm_model_zoo.list_models()`.
+
+The notebook `examples/higher_dimensional_models.ipynb` runs all four models, compares them with
+the stock PyBaMM models and shows a temperature that changes with height.
+
+## About PyBaMM-GEM
+
+PyBaMM-GEM is an open, collaborative home for battery models that extend
+[PyBaMM](https://pybamm.org). Many new models are experimental, specialised or still under active
+research, which makes them unsuitable for the core PyBaMM project in their early stages. GEM is
+where they can be developed, validated, compared and shared, while staying close to PyBaMM. Some
+GEM models may later move into PyBaMM; others stay in GEM because they answer specialised
+questions. Both outcomes count as success.
+
+**Stay close to PyBaMM. Explore beyond it.** GEM models follow PyBaMM's design, options and user
+experience, so PyBaMM users feel at home. Where a GEM model differs scientifically from a PyBaMM
+model, it is a separate, explicitly named model. Every release states the PyBaMM versions it
+supports.
+
+GEM stands for **General Enough Model** and **Good Enough Model**: the fewest physical processes
+needed to explain the behaviour of interest. The name also honours Professor John B. Goodenough.
+
+The models are laid out like the PyBaMM model zoo: one folder per model, each with a `model.toml`
+manifest, a `CITATION.bib`, a README, tests and an example.
+
+## Automatic checks
+
+- **Every push and pull request, and every Monday:** ruff, GEM's tests and the PyBaMM model zoo's
+  contract checks, against the newest PyBaMM and `pybamm-model-zoo`. If the Monday run fails, an
+  issue "Weekly check failed" is opened; it is closed when the check passes again.
+- **1st of every month:** a health report of the released package (installed from PyPI) with the
+  newest PyBaMM and model zoo, posted on the pinned issue "Monthly health report". It can also be
+  run by hand with `python scripts/health_report.py`.
+
+## Releasing a new version
+
+1. In a pull request, raise `version` in `pyproject.toml` (for example `0.2.2`) and add a
+   `CHANGELOG.md` entry. Merge it.
+2. On GitHub, go to Releases, then "Draft a new release". Create the tag `v0.2.2` (a "v" and
+   the version), add a title and notes, and publish.
+3. The Release workflow builds and tests the package, uploads it to TestPyPI and tests it again.
+   It then waits for a maintainer to approve the upload to PyPI (GitHub sends an email).
+
+## Licence
+
+BSD 3-Clause, see `LICENSE.txt`. Copyright (c) 2026, Imperial College London.
+Some of the model code is adapted from PyBaMM; see `LICENSES-bundled.txt`.

pybamm_gem-0.2.2/README.md

@@ -0,0 +1,97 @@
+# PyBaMM-GEM
+
+An open-source extension package for PyBaMM providing advanced battery models, degradation
+models, and simulation tools.
+
+## Models
+
+```python
+import pybamm_gem as gem
+
+print(gem.list_models())
+# ['dfn_2d', 'dfn_3d', 'spm_2d', 'spm_3d']
+```
+
+| Model | Class | What it is |
+|---|---|---|
+| `dfn_2d` | `DFN2D` | Doyle-Fuller-Newman model resolved in x and z |
+| `dfn_3d` | `DFN3D` | The same, resolved in x, y and z |
+| `spm_2d` | `BasicSPM2D` | Single Particle Model with a pair of particles at every height z |
+| `spm_3d` | `BasicSPM3D` | The same, over a y-z grid of points |
+
+## Installation
+
+```
+pip install pybamm-gem
+```
+
+PyBaMM 26.9 or newer is needed. To get the newest code from GitHub instead:
+`pip install git+https://github.com/ImperialCollegeLondon/PyBaMM-GEM`
+
+## Usage
+
+```python
+import pybamm
+import pybamm_gem as gem
+
+print(gem.list_models())
+model = gem.load("spm_2d")()
+simulation = pybamm.Simulation(model)
+solution = simulation.solve([0, 3000])
+print(solution["Voltage [V]"](1500))
+```
+
+The classes are also available directly, for example `gem.lithium_ion.BasicSPM2D` or
+`gem.lithium_ion.DFN2D`.
+
+The commands are the same as in the PyBaMM model zoo (`pybamm_model_zoo`): `list_models()`,
+`info()`, `load()`, `require()` and `register_citation()`. `info()`, `load()`, `require()` and
+`register_citation()` take either the slug (`"spm_2d"`) or the class name (`"BasicSPM2D"`);
+`list_models()` returns the slugs. With `pybamm-model-zoo` installed, the GEM models are also
+listed by `pybamm_model_zoo.list_models()`.
+
+The notebook `examples/higher_dimensional_models.ipynb` runs all four models, compares them with
+the stock PyBaMM models and shows a temperature that changes with height.
+
+## About PyBaMM-GEM
+
+PyBaMM-GEM is an open, collaborative home for battery models that extend
+[PyBaMM](https://pybamm.org). Many new models are experimental, specialised or still under active
+research, which makes them unsuitable for the core PyBaMM project in their early stages. GEM is
+where they can be developed, validated, compared and shared, while staying close to PyBaMM. Some
+GEM models may later move into PyBaMM; others stay in GEM because they answer specialised
+questions. Both outcomes count as success.
+
+**Stay close to PyBaMM. Explore beyond it.** GEM models follow PyBaMM's design, options and user
+experience, so PyBaMM users feel at home. Where a GEM model differs scientifically from a PyBaMM
+model, it is a separate, explicitly named model. Every release states the PyBaMM versions it
+supports.
+
+GEM stands for **General Enough Model** and **Good Enough Model**: the fewest physical processes
+needed to explain the behaviour of interest. The name also honours Professor John B. Goodenough.
+
+The models are laid out like the PyBaMM model zoo: one folder per model, each with a `model.toml`
+manifest, a `CITATION.bib`, a README, tests and an example.
+
+## Automatic checks
+
+- **Every push and pull request, and every Monday:** ruff, GEM's tests and the PyBaMM model zoo's
+  contract checks, against the newest PyBaMM and `pybamm-model-zoo`. If the Monday run fails, an
+  issue "Weekly check failed" is opened; it is closed when the check passes again.
+- **1st of every month:** a health report of the released package (installed from PyPI) with the
+  newest PyBaMM and model zoo, posted on the pinned issue "Monthly health report". It can also be
+  run by hand with `python scripts/health_report.py`.
+
+## Releasing a new version
+
+1. In a pull request, raise `version` in `pyproject.toml` (for example `0.2.2`) and add a
+   `CHANGELOG.md` entry. Merge it.
+2. On GitHub, go to Releases, then "Draft a new release". Create the tag `v0.2.2` (a "v" and
+   the version), add a title and notes, and publish.
+3. The Release workflow builds and tests the package, uploads it to TestPyPI and tests it again.
+   It then waits for a maintainer to approve the upload to PyPI (GitHub sends an email).
+
+## Licence
+
+BSD 3-Clause, see `LICENSE.txt`. Copyright (c) 2026, Imperial College London.
+Some of the model code is adapted from PyBaMM; see `LICENSES-bundled.txt`.

{pybamm_gem-0.2.0 → pybamm_gem-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "PyBaMM-GEM"
-version = "0.2.0"
+version = "0.2.2"
 license = "BSD-3-Clause"
 license-files = ["LICENSE.txt", "LICENSES-bundled.txt"]
 description = "Spatially resolved (2D and 3D) battery models for PyBaMM"
@@ -18,7 +18,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dev = ["pytest", "ruff"]
+dev = ["pytest", "ruff", "pybamm-model-zoo"]
 
 # Lets the PyBaMM model zoo list these models too, if the zoo is installed.
 [project.entry-points."pybamm_zoo_models"]

pybamm_gem-0.2.2/scripts/health_report.py

@@ -0,0 +1,135 @@
+# Monthly health report for PyBaMM-GEM (simple Python).
+#
+# It starts with the models from gem.list_models(). Then, for every GEM model, it checks:
+#   1. the PyBaMM model zoo finds it and its contract checks pass,
+#   2. it solves a 1C discharge, and how long that takes,
+#   3. how far its voltage is from the matching stock PyBaMM model.
+# It writes the result as Markdown to the file named on the command line (default report.md).
+#
+# How to use it:
+#   python scripts/health_report.py report.md
+
+import sys
+import time
+import warnings
+
+import numpy as np
+import pybamm
+import pybamm_model_zoo as zoo
+from pybamm_model_zoo.testing import contract
+
+import pybamm_gem as gem
+
+OUTPUT = "report.md"
+if len(sys.argv) > 1:
+    OUTPUT = sys.argv[1]
+
+END_TIME = 3000  # seconds of a 1C discharge
+POINTS = 3  # cells in each extra direction, kept small so the report runs quickly
+TOLERANCE = 1e-3  # volts, the same as the model tests
+
+warnings.simplefilter("ignore")
+
+
+def stock_model(slug):
+    if slug.startswith("spm"):
+        return pybamm.lithium_ion.SPM()
+    return pybamm.lithium_ion.DFN()
+
+
+def solve_gem_model(slug):
+    model_class = gem.load(slug)
+    if slug == "spm_3d":
+        model = model_class(points_y=POINTS, points_z=POINTS)
+        return pybamm.Simulation(model).solve([0, END_TIME])
+    if slug.startswith("spm"):
+        return pybamm.Simulation(model_class()).solve([0, END_TIME])
+    var_pts = dict(pybamm.lithium_ion.DFN().default_var_pts)
+    var_pts["z"] = POINTS
+    if slug == "dfn_3d":
+        var_pts["y"] = POINTS
+    return pybamm.Simulation(model_class(), var_pts=var_pts).solve([0, END_TIME])
+
+
+lines = []
+
+# The models, from gem.list_models() and each model's model.toml
+lines.append("### Models in GEM")
+lines.append("")
+lines.append("`gem.list_models()` = `" + str(gem.list_models()) + "`")
+lines.append("")
+lines.append("| Model | Class | What it is |")
+lines.append("|---|---|---|")
+for slug in gem.list_models():
+    manifest = gem.info(slug)
+    lines.append("| `" + slug + "` | `" + manifest["name"] + "` | " + manifest["summary"] + " |")
+lines.append("")
+
+lines.append("### Health")
+lines.append("")
+lines.append("| | Version |")
+lines.append("|---|---|")
+lines.append("| PyBaMM-GEM | " + gem.__version__ + " |")
+lines.append("| PyBaMM | " + pybamm.__version__ + " |")
+lines.append("| pybamm-model-zoo | " + zoo.__version__ + " |")
+lines.append("| Python | " + sys.version.split()[0] + " |")
+lines.append("")
+lines.append("| Model | Zoo checks | Solves | Solve time [s] | Voltage vs stock PyBaMM [mV] | Health |")
+lines.append("|---|---|---|---|---|---|")
+
+all_healthy = True
+check_names = [check.name for check in contract.checks_in_scope(contract.MODEL)]
+times = np.linspace(100, END_TIME - 100, 30)
+
+for slug in gem.list_models():
+    class_name = gem.info(slug)["name"]
+
+    # 1. The zoo contract checks
+    failed_checks = []
+    if class_name not in zoo.list_models():
+        failed_checks.append("not found by the zoo")
+    else:
+        entry = zoo.info(class_name)
+        for name in check_names:
+            try:
+                contract.CHECKS[name].run(entry)
+            except Exception:  # noqa: BLE001 (any failure is reported in the table)
+                failed_checks.append(name)
+    if failed_checks:
+        zoo_result = "failed: " + ", ".join(failed_checks)
+    else:
+        zoo_result = str(len(check_names)) + "/" + str(len(check_names)) + " pass"
+
+    # 2. and 3. Solve and compare with the stock model
+    solves = "yes"
+    solve_time = "-"
+    difference = "-"
+    healthy = len(failed_checks) == 0
+    try:
+        began = time.time()
+        solution = solve_gem_model(slug)
+        solve_time = str(round(time.time() - began, 1))
+        stock_solution = pybamm.Simulation(stock_model(slug)).solve([0, END_TIME])
+        largest = np.max(np.abs(solution["Voltage [V]"](times) - stock_solution["Voltage [V]"](times)))
+        difference = str(round(1000 * largest, 3))
+        if largest > TOLERANCE:
+            healthy = False
+    except Exception as error:  # noqa: BLE001 (any failure is reported in the table)
+        solves = "no (" + type(error).__name__ + ")"
+        healthy = False
+
+    if not healthy:
+        all_healthy = False
+    health = "OK" if healthy else "PROBLEM"
+    lines.append("| " + slug + " (" + class_name + ") | " + zoo_result + " | " + solves + " | "
+                 + solve_time + " | " + difference + " | " + health + " |")
+
+lines.append("")
+if all_healthy:
+    lines.append("**All models healthy.**")
+else:
+    lines.append("**At least one model has a problem; see the table.**")
+
+with open(OUTPUT, "w", encoding="utf-8") as file:
+    file.write("\n".join(lines) + "\n")
+print("\n".join(lines))

{pybamm_gem-0.2.0 → pybamm_gem-0.2.2}/src/pybamm_gem/__init__.py

@@ -3,7 +3,7 @@
 from importlib.metadata import version
 
 from pybamm_gem import lithium_ion
-from pybamm_gem._registry import info, list_models, load, register_citation
+from pybamm_gem._registry import info, list_models, load, register_citation, require
 
 __version__ = version("PyBaMM-GEM")
 
@@ -14,4 +14,5 @@ __all__ = [
     "lithium_ion",
     "load",
     "register_citation",
+    "require",
 ]

{pybamm_gem-0.2.0 → pybamm_gem-0.2.2}/src/pybamm_gem/_registry.py

@@ -26,26 +26,45 @@ def _manifests() -> dict:
     return manifests
 
 
+class ModelInfo(dict):
+    """The manifest of one model. Read a field as ``info["title"]`` or ``info.title``."""
+
+    def __getattr__(self, field):
+        if field in self:
+            return self[field]
+        raise AttributeError(field)
+
+
 def list_models() -> list[str]:
     """Return the slug of every model in the package."""
     return sorted(_manifests())
 
 
-def info(slug: str) -> dict:
-    """Return the manifest of one model as a dictionary."""
+def info(name: str) -> ModelInfo:
+    """Return the manifest of one model, found by its slug ("spm_2d") or class name ("BasicSPM2D")."""
     manifests = _manifests()
-    if slug not in manifests:
-        raise KeyError(f"No model '{slug}'. Available: {sorted(manifests)}")
-    return manifests[slug]
+    for slug in manifests:
+        if name == slug or name == manifests[slug]["name"]:
+            return ModelInfo(manifests[slug])
+    raise KeyError(f"No model '{name}'. Available: {sorted(manifests)}")
 
 
-def load(slug: str) -> type:
-    """Return the model class for a slug. Call it to get a model, e.g. ``load("spm_2d")()``."""
-    module_path, class_name = info(slug)["class"].split(":")
+def load(name: str) -> type:
+    """Return the model class, e.g. ``load("spm_2d")()`` or ``load("BasicSPM2D")()``."""
+    module_path, class_name = info(name)["class"].split(":")
     module = importlib.import_module(module_path)
     return getattr(module, class_name)
 
 
+def require(name: str) -> None:
+    """Check that a model exists (raises KeyError if not).
+
+    The same command as in the PyBaMM model zoo. GEM models need no optional
+    packages, so there is nothing else to check.
+    """
+    info(name)
+
+
 def _read_bibtex(path: Path) -> dict:
     # Split a BibTeX file into {key: entry text} by matching braces.
     text = path.read_text(encoding="utf-8")
@@ -69,9 +88,9 @@ def _read_bibtex(path: Path) -> dict:
     return entries
 
 
-def register_citation(slug: str) -> None:
+def register_citation(name: str) -> None:
     """Make ``pybamm.print_citations()`` credit the model's key from its ``CITATION.bib``."""
-    manifest = info(slug)
+    manifest = info(name)
     entries = _read_bibtex(manifest["path"] / "CITATION.bib")
     key = manifest["citation"]["key"]
     pybamm.citations.register(entries[key])

{pybamm_gem-0.2.0 → pybamm_gem-0.2.2}/tests/test_registry.py

@@ -35,3 +35,38 @@ def test_every_model_folder_has_the_zoo_files():
             assert (folder / name).is_file(), f"{slug}: missing {name}"
         assert any((folder / "tests").glob("*.py")), f"{slug}: no tests"
         assert any((folder / "examples").glob("*.py")), f"{slug}: no examples"
+
+
+# The same commands as the PyBaMM model zoo (pybamm_model_zoo)
+
+
+def test_load_by_slug_or_class_name_gives_the_same_class():
+    for slug in gem.list_models():
+        class_name = gem.info(slug)["name"]
+        assert gem.load(class_name) is gem.load(slug)
+
+
+def test_info_by_class_name():
+    assert gem.info("BasicSPM2D")["slug"] == "spm_2d"
+    assert gem.info("DFN3D")["slug"] == "dfn_3d"
+
+
+def test_info_fields_as_attributes_or_items():
+    manifest = gem.info("spm_2d")
+    assert manifest.title == manifest["title"]
+    assert manifest.license == "BSD-3-Clause"
+    with pytest.raises(AttributeError):
+        print(manifest.no_such_field)
+
+
+def test_require():
+    for slug in gem.list_models():
+        gem.require(slug)
+    gem.require("BasicSPM3D")
+    with pytest.raises(KeyError):
+        gem.require("no_such_model")
+
+
+def test_register_citation_by_slug_or_class_name():
+    gem.register_citation("spm_2d")
+    gem.register_citation("DFN2D")

pybamm_gem-0.2.2/tests/test_zoo_contract.py

@@ -0,0 +1,30 @@
+"""The PyBaMM model zoo's own checks (pybamm_model_zoo.testing.contract) on every GEM model.
+
+These are the portable checks the zoo applies to models from other packages: manifest,
+layout, import, citation, well_posed, build and solve. Skipped if pybamm-model-zoo is
+not installed.
+"""
+
+import pytest
+
+pytest.importorskip("pybamm_model_zoo")
+
+import pybamm_model_zoo as zoo
+from pybamm_model_zoo.testing import contract
+
+import pybamm_gem as gem
+
+CHECK_NAMES = [check.name for check in contract.checks_in_scope(contract.MODEL)]
+
+
+def test_the_zoo_finds_every_gem_model():
+    for slug in gem.list_models():
+        class_name = gem.info(slug)["name"]
+        assert class_name in zoo.list_models()
+
+
+@pytest.mark.parametrize("slug", gem.list_models())
+@pytest.mark.parametrize("check_name", CHECK_NAMES)
+def test_zoo_contract(slug, check_name):
+    entry = zoo.info(gem.info(slug)["name"])
+    contract.CHECKS[check_name].run(entry)

pybamm_gem-0.2.0/.github/workflows/ci.yml

@@ -1,53 +0,0 @@
-# Runs the tests on every push and pull request, and every Monday, against the latest
-# PyBaMM release. A failing scheduled run opens ONE issue (or adds a comment to the open
-# one). It never changes any code.
-name: CI
-
-on:
-  push:
-  pull_request:
-  schedule:
-    - cron: "17 6 * * 1"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  issues: write
-
-jobs:
-  release:
-    name: PyBaMM release
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - name: Install
-        run: |
-          pip install --upgrade pip
-          pip install -e ".[dev]"
-      - name: Lint
-        run: ruff check src tests
-      - name: Test
-        run: pytest
-
-  report:
-    name: Report a failure
-    needs: [release]
-    if: ${{ always() && github.event_name == 'schedule' && needs.release.result == 'failure' }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Open an issue, or comment on the open one
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
-        run: |
-          TITLE="Weekly check failed"
-          NUMBER=$(gh issue list --repo "$REPO" --state open --search "$TITLE in:title" --json number --jq '.[0].number')
-          if [ -z "$NUMBER" ]; then
-            gh issue create --repo "$REPO" --title "$TITLE" --body "The weekly check failed. See $RUN_URL"
-          else
-            gh issue comment "$NUMBER" --repo "$REPO" --body "Failed again. See $RUN_URL"
-          fi

pybamm_gem-0.2.0/CHANGELOG.md

@@ -1,11 +0,0 @@
-# Changelog
-
-## 0.2.0
-
-- Rebuilt in the PyBaMM model-zoo layout: one folder per model, each with a `model.toml`
-  manifest, `CITATION.bib`, `README.md`, tests and an example.
-- Models: `spm_2d` (`BasicSPM2D`), `spm_3d` (`BasicSPM3D`), `dfn_2d` (`DFN2D`) and `dfn_3d` (`DFN3D`).
-- Registry: `pybamm_gem.list_models()`, `pybamm_gem.info()` and `pybamm_gem.load()`.
-- Example notebook: `examples/higher_dimensional_models.ipynb`.
-- Needs PyBaMM 26.9 or newer.
-- The previous code is kept on the branch `legacy-2026-11`.

pybamm_gem-0.2.0/PKG-INFO

@@ -1,63 +0,0 @@
-Metadata-Version: 2.5
-Name: PyBaMM-GEM
-Version: 0.2.0
-Summary: Spatially resolved (2D and 3D) battery models for PyBaMM
-Author: Mohammed Asheruddin N
-License-Expression: BSD-3-Clause
-License-File: LICENSE.txt
-License-File: LICENSES-bundled.txt
-Keywords: battery,electrochemistry,lithium-ion,modelling,pybamm,simulation
-Requires-Python: >=3.10
-Requires-Dist: pybamm[cite]>=26.9
-Requires-Dist: tomli>=2.0.1; python_version < '3.11'
-Provides-Extra: dev
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# PyBaMM-GEM
-
-Spatially resolved (2D and 3D) battery models built on [PyBaMM](https://pybamm.org), laid out
-like the PyBaMM model zoo: one folder per model, each with a `model.toml` manifest, a
-`CITATION.bib`, a README, tests and an example.
-
-## Models
-
-| Slug | Class | What it is |
-|---|---|---|
-| `spm_2d` | `BasicSPM2D` | Single Particle Model with a pair of particles at every height z |
-| `spm_3d` | `BasicSPM3D` | The same, over a y-z grid of points |
-| `dfn_2d` | `DFN2D` | Doyle-Fuller-Newman model resolved in x and z |
-| `dfn_3d` | `DFN3D` | The same, resolved in x, y and z |
-
-## Installation
-
-```
-pip install git+https://github.com/ImperialCollegeLondon/PyBaMM-GEM
-```
-
-PyBaMM 26.9 or newer is needed.
-
-## Usage
-
-```python
-import pybamm
-import pybamm_gem as gem
-
-print(gem.list_models())
-model = gem.load("spm_2d")()
-simulation = pybamm.Simulation(model)
-solution = simulation.solve([0, 3000])
-print(solution["Voltage [V]"](1500))
-```
-
-The classes are also available directly, for example `gem.lithium_ion.BasicSPM2D` or
-`gem.lithium_ion.DFN2D`.
-
-The notebook `examples/higher_dimensional_models.ipynb` runs all four models, compares them with
-the stock PyBaMM models and shows a temperature that changes with height.
-
-## Licence
-
-BSD 3-Clause, see `LICENSE.txt`. Copyright (c) 2026, Imperial College London.
-Some of the model code is adapted from PyBaMM; see `LICENSES-bundled.txt`.

pybamm_gem-0.2.0/README.md

@@ -1,46 +0,0 @@
-# PyBaMM-GEM
-
-Spatially resolved (2D and 3D) battery models built on [PyBaMM](https://pybamm.org), laid out
-like the PyBaMM model zoo: one folder per model, each with a `model.toml` manifest, a
-`CITATION.bib`, a README, tests and an example.
-
-## Models
-
-| Slug | Class | What it is |
-|---|---|---|
-| `spm_2d` | `BasicSPM2D` | Single Particle Model with a pair of particles at every height z |
-| `spm_3d` | `BasicSPM3D` | The same, over a y-z grid of points |
-| `dfn_2d` | `DFN2D` | Doyle-Fuller-Newman model resolved in x and z |
-| `dfn_3d` | `DFN3D` | The same, resolved in x, y and z |
-
-## Installation
-
-```
-pip install git+https://github.com/ImperialCollegeLondon/PyBaMM-GEM
-```
-
-PyBaMM 26.9 or newer is needed.
-
-## Usage
-
-```python
-import pybamm
-import pybamm_gem as gem
-
-print(gem.list_models())
-model = gem.load("spm_2d")()
-simulation = pybamm.Simulation(model)
-solution = simulation.solve([0, 3000])
-print(solution["Voltage [V]"](1500))
-```
-
-The classes are also available directly, for example `gem.lithium_ion.BasicSPM2D` or
-`gem.lithium_ion.DFN2D`.
-
-The notebook `examples/higher_dimensional_models.ipynb` runs all four models, compares them with
-the stock PyBaMM models and shows a temperature that changes with height.
-
-## Licence
-
-BSD 3-Clause, see `LICENSE.txt`. Copyright (c) 2026, Imperial College London.
-Some of the model code is adapted from PyBaMM; see `LICENSES-bundled.txt`.