PyBaMM-GEM 0.2.1__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.1 → pybamm_gem-0.2.2}/.github/workflows/release.yml

@@ -76,9 +76,9 @@ jobs:
         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 a few minutes to appear on TestPyPI
-          for attempt in 1 2 3 4 5 6 7 8 9 10; do
-            if pip install --no-deps --index-url https://test.pypi.org/simple/ "pybamm-gem==$VERSION"; then
+          # 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

{pybamm_gem-0.2.1 → pybamm_gem-0.2.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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

{pybamm_gem-0.2.1 → pybamm_gem-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyBaMM-GEM
-Version: 0.2.1
+Version: 0.2.2
 Summary: Spatially resolved (2D and 3D) battery models for PyBaMM
 Author: Mohammed Asheruddin N
 License-Expression: BSD-3-Clause
@@ -11,32 +11,40 @@ 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
 
-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.
+An open-source extension package for PyBaMM providing advanced battery models, degradation
+models, and simulation tools.
 
 ## Models
 
-| Slug | Class | What it is |
+```python
+import pybamm_gem as gem
+
+print(gem.list_models())
+# ['dfn_2d', 'dfn_3d', 'spm_2d', 'spm_3d']
+```
+
+| Model | 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 |
+| `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 git+https://github.com/ImperialCollegeLondon/PyBaMM-GEM
+pip install pybamm-gem
 ```
 
-PyBaMM 26.9 or newer is needed.
+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
 
@@ -63,16 +71,45 @@ 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.
 
-## Licence
+## About PyBaMM-GEM
 
-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 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.1`) and add a
+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.1` (a "v" and
+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.1 → pybamm_gem-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "PyBaMM-GEM"
-version = "0.2.1"
+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.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.1/.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.1/README.md

@@ -1,61 +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 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.
-
-## 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`.
-
-## Releasing a new version
-
-1. In a pull request, raise `version` in `pyproject.toml` (for example `0.2.1`) and add a
-   `CHANGELOG.md` entry. Merge it.
-2. On GitHub, go to Releases, then "Draft a new release". Create the tag `v0.2.1` (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).