[DOCS/FIX] First draft of Objective No. 5: TO FACILITATE MAINTENANCE AND UPDATES FOR CG STAFF. (No more hard-coded settings, libraries updated, instructions added to the README)

README.md

@@ -4,7 +4,7 @@ emoji: 🌍
 colorFrom: green
 colorTo: blue
 sdk: streamlit
-sdk_version: "1.45.1"
+sdk_version: "1.58.0"
 app_file: app.py
 pinned: false
 ---
@@ -12,3 +12,596 @@ pinned: false
 # Carbon Dioxide Removal Optimizer
 
 A Streamlit app for optimizing carbon removal portfolios across different methods and constraints.
+
+---
+
+## Data Maintenance Guide
+
+This guide is for Carbon Gap staff who need to update the tool's data — **no coding experience required** for most tasks.
+
+---
+
+### How it works (overview)
+
+All the data the tool uses (CDR methods, resources, coefficients) comes from a single file:
+
+```
+data/inputs_aggregated.csv
+```
+
+Every time the app starts, it computes a fingerprint (hash) of the CSV and compares it to the last known value. If they differ — meaning the CSV has been modified — it regenerates all data files automatically before loading. You do not need to run anything manually.
+
+There are two ways to update the data, depending on whether you are working directly on Hugging Face or on a local copy of the project.
+
+---
+
+### Option 1 — Edit directly on Hugging Face (no local setup needed)
+
+This is the simplest option for non-coders with admin access to the Hugging Face Space.
+
+**Steps:**
+
+1. Go to the Hugging Face Space → click the **Files** tab
+2. Open `data/inputs_aggregated.csv` and click **Edit** (pencil icon), or upload a new version of the file
+3. Commit the change directly on Hugging Face — the Space will restart automatically
+4. **Check the logs** to confirm the update ran:
+   - In the Space, click **⋮ (three dots)** → **Logs**
+   - You should see:
+     ```
+     inputs_aggregated.csv has changed — running data/update.py ...
+     [... update details ...]
+     Data files updated successfully.
+     ```
+5. If the logs show this message, the app is running with the new data. If not, something went wrong — contact the developer.
+
+> **Note:** with this option, only `inputs_aggregated.csv` needs to be uploaded. The app handles the rest automatically on restart.
+
+---
+
+### Option 2 — Work locally and push (recommended for larger changes)
+
+Use this option when making bigger changes (new methods, new resources, reordering) where you want to preview the result before publishing.
+
+**Step 1 — Get the project on your machine**
+
+If you do not already have it:
+- Install [GitHub Desktop](https://desktop.github.com) (free, no command line needed)
+- Open GitHub Desktop → **File** → **Clone repository** → enter the repository URL → choose a local folder → click **Clone**
+
+**Step 2 — Edit the CSV**
+
+Open `data/inputs_aggregated.csv` in Excel or any spreadsheet editor. Make your changes and save.
+
+**Step 3 — Open a terminal in the project folder**
+
+- Mac: right-click the project folder → **New Terminal at Folder**
+- Windows: open the folder, click in the address bar, type `cmd`, press Enter
+
+Activate the Python environment:
+```
+source venv/bin/activate    # Mac / Linux
+venv\Scripts\activate       # Windows
+```
+
+**Step 4 — Run the update script**
+
+```
+python data/update.py
+```
+
+This regenerates all data files and updates the internal fingerprint. Check the output — it should end with `All files updated successfully.`
+
+**Step 5 — Commit and push**
+
+In GitHub Desktop:
+- You will see all modified files listed on the left
+- Write a short description in the **Summary** field (e.g. "Update coefficients for Afforestation")
+- Click **Commit to main**
+- Click **Push origin**
+
+Hugging Face will detect the push and rebuild the Space automatically.
+
+---
+
+### Quick reference — where is each parameter?
+
+| I want to change… | File | Where exactly |
+|---|---|---|
+| A coefficient value (min / median / max) | `data/inputs_aggregated.csv` | Columns `min`, `median`, `max` — find the row by `Implementation` + `Resource` |
+| The name of a CDR method | `data/inputs_aggregated.csv` | Column `Implementation` — use Find & Replace |
+| Which group a CDR method belongs to | `data/inputs_aggregated.csv` | Column `Method group` |
+| The name of a resource | `data/inputs_aggregated.csv` | Column `Resource` — use Find & Replace |
+| Which group a resource belongs to | `data/inputs_aggregated.csv` | Column `Resource group` |
+| The unit of a resource group | `data/inputs_aggregated.csv` | Column `Unit` — must be consistent across all rows for that group |
+| Whether a resource is optional for a method | `data/inputs_aggregated.csv` | Column `Is secondary` — `TRUE` = optional, `FALSE` = always active |
+| The display order of methods or resources | `data/inputs_aggregated.csv` | Row order — move rows up/down |
+| The app's colours | `config/config.py` | `CRRA_COLORS` dictionary |
+| The app's font | `config/config.py` | `CRRA_FONT` variable |
+| The tooltip text on a method name | `data/tooltips.xlsx` | Sheet **Methods** — column `Tooltip` |
+| The tooltip text on a resource name | `data/tooltips.xlsx` | Sheet **Resources** — column `Tooltip` |
+| UI spacing, font sizes, button styles | `assets/styles.css` | Standard CSS — search for the element name |
+| Python library versions | `requirements.txt` | One line per library — see Library Maintenance Guide below |
+
+> After any change to `inputs_aggregated.csv`, run `python data/update.py`. After changes to `config/config.py` or `assets/styles.css`, simply restart the app.
+
+---
+
+### Before you start
+
+**Open a terminal** in the project folder. On Mac: right-click the folder → "New Terminal at Folder". On Windows: open the folder, then type `cmd` in the address bar.
+
+**Activate the Python environment** (only needed once per session):
+
+- Mac / Linux: `source venv/bin/activate`
+- Windows: `venv\Scripts\activate`
+
+You should now see `(venv)` at the start of your terminal line.
+
+---
+
+### File structure (what each file does)
+
+| File | What it is | Do you edit it? |
+|------|-----------|-----------------|
+| `data/inputs_aggregated.csv` | **Main data file** — all methods, resources and coefficients | ✅ Yes |
+| `data/update.py` | Script that regenerates everything from the CSV | ❌ No |
+| `data/cost_sliders.json` | Auto-generated — coefficients used by the app | ❌ No (auto) |
+| `data/method_groups.json` | Auto-generated — CDR method categories | ❌ No (auto) |
+| `data/secondary_resources.json` | Auto-generated — optional resource assignments | ❌ No (auto) |
+| `data/inputs_template.xlsx` | Auto-generated — Excel template for users | ❌ No (auto) |
+| `data/resource_template.xlsx` | Auto-generated — Excel template for resources | ❌ No (auto) |
+| `data/tooltips.xlsx` | Tooltip texts shown on hover in the app | ✅ Yes — edit directly |
+
+> ⚠️ **Never edit the auto-generated files directly** — your changes will be overwritten the next time `update.py` is run.
+
+---
+
+### Understanding `inputs_aggregated.csv`
+
+Each row represents **one resource used by one CDR method**, with the following columns:
+
+| Column | Description | Example |
+|--------|-------------|---------|
+| `Implementation` | Name of the CDR method | `Afforestation` |
+| `Method group` | Category the method belongs to | `Forestry` |
+| `Resource` | Name of the resource used | `Unspecified land` |
+| `Resource group` | Category the resource belongs to | `Land` |
+| `Type` | Physical type of the resource | `Physical` |
+| `Unit` | Unit of the coefficient (per MtCO₂) | `Mha/MtCO2` |
+| `min` | Minimum coefficient value | `0.002` |
+| `median` | Default (median) coefficient value | `0.094927` |
+| `max` | Maximum coefficient value | `0.384615` |
+| `Is secondary` | Whether this resource is optional for this method | `FALSE` |
+
+> **Primary resources** (`Is secondary = FALSE`) are always active in the model.
+> **Secondary resources** (`Is secondary = TRUE`) are optional — users can toggle them on in the app.
+
+---
+
+## Case 1 — Modify existing coefficient values
+
+**When to use:** The literature has been updated and you want to change the min/median/max values for an existing method-resource pair.
+
+**Steps:**
+
+1. Open `data/inputs_aggregated.csv` in Excel or a text editor.
+2. Find the row with the correct `Implementation` and `Resource`.
+3. Edit the `min`, `median`, and/or `max` columns.
+4. Save the file.
+5. In the terminal, run:
+   ```
+   python data/update.py
+   ```
+
+---
+
+## Case 2 — Add a new resource to an existing method
+
+**When to use:** A CDR method now uses a resource that wasn't tracked before (e.g., adding water consumption to Afforestation).
+
+**Steps:**
+
+1. Open `data/inputs_aggregated.csv`.
+2. Add a **new row** at the end (or anywhere in the file — order of rows determines display order in the app):
+
+   | Column | What to enter |
+   |--------|--------------|
+   | `Implementation` | Exact name of the existing method (copy it from another row to avoid typos) |
+   | `Method group` | Same group as the other rows for that method |
+   | `Resource` | Name of the resource (must match an existing resource exactly, or see Case 4 to add a new one) |
+   | `Resource group` | Same group as the other rows for that resource |
+   | `Type` | `Physical` or `Energy` |
+   | `Unit` | Must match the unit already used for that resource (e.g., `Mha/MtCO2`) |
+   | `min` | Minimum coefficient |
+   | `median` | Median coefficient |
+   | `max` | Maximum coefficient |
+   | `Is secondary` | `TRUE` if optional, `FALSE` if always required |
+
+3. Save the file.
+4. Run `python data/update.py`.
+
+---
+
+## Case 3 — Add a new CDR method
+
+**When to use:** A new carbon removal approach needs to be added to the tool.
+
+**Steps:**
+
+1. Open `data/inputs_aggregated.csv`.
+2. Add **one row per resource** used by the new method. For example, if your new method uses land and water, add 2 rows.
+
+   For each row, fill in all columns. Use an **existing Method group** (e.g., `Forestry`) or create a new one (the name you write here becomes the category name in the app).
+
+3. Save the file.
+4. Run `python data/update.py`.
+
+> **Note on display order:** The new method will appear in the app in the same position it appears in the CSV. If you want it between two existing methods, insert the rows between those methods' rows.
+
+> ⚠️ **Special case — derived methods:** see Case 3b below.
+
+---
+
+## Case 3b — Add a derived CDR method (variant of an existing method)
+
+**What is a derived method?**
+Some methods in the tool are not standalone entries in the CSV — they are automatically generated as **variants** of a base method. For example:
+- `Bio-char` in the CSV → generates 3 variants in the app: `Bio-char - Forest biomass`, `Bio-char - Non-forest biomass`, `Bio-char - Unspecified biomass`
+- `Enhanced weathering` in the CSV → generates 4 variants: one per mineral type
+
+Each variant is identical to the base method **except** it only keeps the resource relevant to that variant (e.g. `Bio-char - Forest biomass` removes the non-forest and unspecified biomass resources).
+
+**When to use:** You want to add a new variant of an existing method (e.g. a new mineral type for Enhanced weathering, or a new biomass type for Bio-char).
+
+**Steps:**
+
+1. Open `data/inputs_aggregated.csv` and make sure the base method has a row for the new resource (e.g. add a row for `Enhanced weathering` with the new mineral).
+
+2. Open `data/generate_model_data.py`. Find the two structures at the top of the file:
+
+   **`REPLACED_BY_DERIVED`** — lists base methods that are fully replaced by their variants (the base name disappears from the app):
+   ```
+   REPLACED_BY_DERIVED = {"Bio-char", "Enhanced weathering"}
+   ```
+   If your new base method should disappear from the app once variants exist, add its name here.
+
+   **`DERIVED_FROM`** — maps each base method to its list of variant names (in display order):
+   ```
+   DERIVED_FROM = {
+       "Bio-char": ["Bio-char - Forest biomass", ...],
+       "Enhanced weathering": ["Enhanced weathering - Basalt mineral", ...],
+       ...
+   }
+   ```
+   Add the new variant name to the relevant list here.
+
+3. Further down in `create_sliders_inputs()`, add the derivation logic for your new variant — copy the pattern already used for Bio-char or Enhanced weathering: copy the base method's coefficients, then remove the resources that don't apply to this variant.
+
+4. Save `generate_model_data.py` and run:
+   ```
+   python data/update.py
+   ```
+
+> ⚠️ This case requires editing Python code. If you are not comfortable with this, contact the developer — provide the name of the new variant and which resource it should keep, and they can add the 5–10 lines needed.
+
+---
+
+## Case 4 — Add a new resource
+
+**When to use:** A resource that doesn't exist yet needs to be tracked (e.g., a new type of mineral or energy).
+
+**Steps:**
+
+1. Decide which **Resource group** the new resource belongs to (e.g., `Minerals`, `Energy`, `Land`). If it belongs to an existing group, use the exact same group name. If it needs its own group, invent a new name.
+
+2. Open `data/inputs_aggregated.csv` and add one row per method that uses this resource (same as Case 2).
+
+3. **Check the unit:** the unit for all resources in a group must be the same (e.g., all `Land` resources use `Mha/MtCO2`). If your new resource has a different unit, it needs its own Resource group.
+
+4. Save the file and run `python data/update.py`.
+
+---
+
+## Case 5 — Add a new resource group (new category)
+
+**When to use:** Your new resource doesn't fit any existing category.
+
+**Steps:**
+
+Same as Case 4, but in the `Resource group` column, write a **new group name** that has never been used before. The app will automatically create a new section for it in the Resource Inputs tab.
+
+The new group will appear in the app **in the position of its first row in the CSV**. Move the rows up or down to control where it appears.
+
+---
+
+## Case 6 — Change whether a resource is optional (secondary) for a method
+
+**When to use:** You want to make a resource optional (user can enable/disable it) or make it always required.
+
+**Steps:**
+
+1. Open `data/inputs_aggregated.csv`.
+2. Find the row with the correct `Implementation` and `Resource`.
+3. Change the `Is secondary` column to `TRUE` (optional) or `FALSE` (always active).
+4. Save and run `python data/update.py`.
+
+---
+
+## Case 7 — Rename a method or resource
+
+**When to use:** Correcting a spelling mistake or updating nomenclature.
+
+**Steps:**
+
+1. Open `data/inputs_aggregated.csv`.
+2. Use **Find & Replace** (Ctrl+H / Cmd+H) to replace the old name with the new name everywhere in the file. Make sure to replace it in both the `Implementation` column (for methods) or `Resource` column (for resources), and also in the `Method group` / `Resource group` columns if the group name changed.
+3. Save and run `python data/update.py`.
+
+> ⚠️ If users have saved scenario files (`.xlsx` or `.zip`) that reference the old name, those files will no longer load correctly after the rename.
+
+---
+
+## Case 8 — Edit tooltip texts (hover descriptions)
+
+**When to use:** You want to add, update, or remove the short description that appears when a user hovers over a resource or method name in the app.
+
+**Steps:**
+
+1. Open `data/tooltips.xlsx`.
+2. Go to the relevant sheet:
+   - **Resources** — for the hover text on resource names (Tab 1 "Resource Inputs")
+   - **Methods** — for the hover text on method names (Tab 2 "Method Constraints")
+3. Find the row with the name you want to edit. All resource and method names are already listed — you only need to fill in or change the `Tooltip` column.
+4. To **add** a tooltip: type the text in the `Tooltip` cell for that row.
+5. To **remove** a tooltip: leave the `Tooltip` cell empty.
+6. Save the file.
+7. Restart the app (no need to run `update.py`).
+
+> ⚠️ The name in column `Resource` or `Method` must match **exactly** the name used in `inputs_aggregated.csv` (same spelling, same capitalisation). If you rename a method or resource in the CSV, remember to update the name in `tooltips.xlsx` too.
+
+---
+
+## Case 10 — Change the display order of methods or resources
+
+**When to use:** You want a method or resource group to appear earlier or later in the app.
+
+**Steps:**
+
+1. Open `data/inputs_aggregated.csv`.
+2. Move the relevant rows up or down. The app displays methods and resource groups **in the same order as they appear in the CSV**.
+3. Save and run `python data/update.py`.
+
+---
+
+## After any change — checklist
+
+**Option 1 (Hugging Face direct):**
+- [ ] Edited and committed `inputs_aggregated.csv` on Hugging Face
+- [ ] Checked the Space logs — confirmed `Data files updated successfully.`
+- [ ] Verified the change appears correctly in the app
+
+**Option 2 (local):**
+- [ ] Saved `inputs_aggregated.csv`
+- [ ] Ran `python data/update.py` with no errors
+- [ ] Committed all modified files (CSV, JSON files, templates) and pushed
+- [ ] Verified the change appears correctly in the app after the Space rebuilt
+
+---
+
+## Common mistakes
+
+| Mistake | What happens | Fix |
+|---------|-------------|-----|
+| Typo in `Method group` or `Resource group` | A new accidental group is created in the app | Fix the typo and re-run `update.py` |
+| Wrong unit (e.g., `MWh/MtCO2` instead of `Mha/MtCO2`) | The resource appears in the wrong group or breaks the unit display | Correct the `Unit` column |
+| Edited a JSON file directly | Changes are overwritten next time `update.py` runs | Always edit the CSV, never the JSON |
+| Forgot to run `update.py` | The app still shows the old data | Run `python data/update.py` |
+| `min` value equals `max` value | The model automatically halves the `min` to create a range | Intentional for fixed-value resources like Geologic storage — leave as is |
+
+---
+
+## Library Maintenance Guide
+
+This section explains how to keep the tool's software dependencies up to date — safely and without breaking anything.
+
+---
+
+### What is a library (dependency)?
+
+The tool is built on top of external software packages ("libraries") that handle things like displaying the interface, reading Excel files, or running the optimization. These libraries are listed in `requirements.txt` with their exact version numbers (e.g., `streamlit==1.45.1`).
+
+Libraries sometimes release updates — fixing bugs, patching security holes, or adding new features. The risk is that an update can also change how a library behaves and break the tool.
+
+---
+
+### The key libraries and what they do
+
+These are the libraries that matter most for this tool:
+
+| Library | Role | Risk if updated |
+|---------|------|----------------|
+| **streamlit** | Powers the entire web interface (tabs, sliders, buttons, charts) — currently 1.58.0 | 🔴 High — UI layout and widget behavior can change |
+| **streamlit-option-menu** | The navigation sidebar menu | 🟡 Medium — must stay compatible with streamlit version |
+| **pandas** | Reads and processes CSV and Excel files | 🟡 Medium — occasional API changes |
+| **numpy** | Numerical operations (arrays, math) | 🟡 Medium — used by scipy and pandas |
+| **scipy** | Runs the LP optimization (`linprog`) | 🟡 Medium — optimization results could change |
+| **plotly** | All charts and interactive graphs | 🟡 Medium — chart API evolves |
+| **openpyxl** | Reads and writes Excel files (.xlsx) | 🟢 Low — stable API |
+| **pillow** | Image handling (indirect use) | 🟢 Low |
+| **requests / urllib3 / certifi** | Network and security | 🟢 Low — update freely for security patches |
+
+---
+
+### Dependency chain (what depends on what)
+
+Some libraries require specific versions of others to work. Updating one can force updates to others:
+
+```
+streamlit ──────────────► tornado (web server)
+            ├───────────► altair (charts)
+            ├───────────► pyarrow (data performance)
+            ├───────────► narwhals (data compatibility)
+            ├───────────► protobuf
+            └───────────► cachetools, blinker, click, toml
+
+pandas ─────────────────► numpy
+        ├───────────────► pyarrow
+        └───────────────► python-dateutil, pytz, tzdata
+
+scipy ──────────────────► numpy
+
+plotly ─────────────────► narwhals
+
+openpyxl ──────────────► pillow
+```
+
+**Practical implication:** if you update `streamlit`, you may also need to update `tornado`, `altair`, `pyarrow`, etc. If you update `pandas`, you may need to update `numpy`. These cascading updates are handled automatically by pip (see below), but they can introduce unexpected changes.
+
+---
+
+### When to update
+
+#### ✅ Update immediately
+- **Security vulnerabilities** in `requests`, `urllib3`, `certifi`, or `pillow` — these are reported publicly and should be patched fast.
+- Check https://pypi.org/project/[library-name] or subscribe to GitHub security alerts.
+
+#### ✅ Update when needed
+- **Streamlit** — when a new feature in the app requires it, or when a critical bug in the current version is causing problems.
+- **pandas / numpy / scipy** — when a bug in the current version is causing incorrect data processing or optimization results.
+- **openpyxl** — when Excel import/export breaks with newer `.xlsx` files.
+
+#### ❌ Do NOT update just because a newer version exists
+- "Latest is always better" is not true for production tools. An update that works fine in isolation can break interactions between libraries.
+- The tool has been tested with the versions in `requirements.txt`. Changing them without testing is risky.
+
+---
+
+### How to safely update a library
+
+**Never update all libraries at once.** Update one at a time, test the tool after each one.
+
+**Step 1 — Back up the current working state**
+
+```
+cp requirements.txt requirements.txt.backup
+```
+
+**Step 2 — Simulate first (dry run)**
+
+Before applying anything, check whether the update would cause conflicts:
+```
+pip install --upgrade streamlit --dry-run
+```
+If pip reports conflicts, investigate before proceeding.
+
+**Step 3 — Update the library**
+
+```
+pip install --upgrade streamlit
+```
+
+Or to a specific version:
+```
+pip install streamlit==1.58.0
+```
+
+**Step 4 — Verify no dependencies are broken**
+
+```
+pip check
+```
+This confirms that all installed packages are mutually compatible. If it reports any conflict, do not proceed to the next step — restore the backup instead (see Step 6).
+
+**Step 5 — Freeze the new versions to requirements.txt**
+
+```
+pip freeze > requirements.txt
+```
+
+**Step 6 — Test the tool**
+
+- Start the app: `streamlit run app.py`
+- Go through every tab
+- Import and export an Excel file
+- Run an optimization
+- Check that charts display correctly
+
+**Step 7 — If something breaks**
+
+Restore the backup:
+```
+pip install -r requirements.txt.backup
+cp requirements.txt.backup requirements.txt
+```
+
+---
+
+### How to install all libraries on a new machine
+
+```
+python -m venv venv
+source venv/bin/activate        # Mac/Linux
+# or: venv\Scripts\activate     # Windows
+pip install -r requirements.txt
+```
+
+---
+
+### Checking for outdated libraries
+
+To see which installed libraries have newer versions available:
+
+```
+pip list --outdated
+```
+
+This shows a list with current and latest versions. Use this to **identify** what could be updated — but don't update everything at once.
+
+---
+
+### Checking for known security vulnerabilities
+
+Install the security scanner:
+```
+pip install pip-audit
+```
+
+Run it:
+```
+pip-audit
+```
+
+This will flag any library with a known security issue and suggest a fix. These should be addressed promptly.
+
+> **Recommended frequency:** run `pip-audit` at least once a year, even if the tool appears stable. Security vulnerabilities are discovered independently of whether the library has changed — a version that was safe last year may be flagged today.
+
+---
+
+### Using an AI assistant to handle updates
+
+Library updates sometimes require code changes alongside the pip update — for example, a deprecated function that was renamed, or a new argument that became required. Doing this manually requires reading changelogs, finding every affected line, and testing the result.
+
+An AI coding assistant such as **Claude Code** (available at [claude.ai/code](https://claude.ai/code)) can handle this end-to-end:
+
+- Run `pip-audit` or `pip list --outdated` and paste the output into Claude Code
+- Describe the update you want to make (e.g., "update pandas and fix any deprecation warnings")
+- Claude Code will update the library, search the codebase for affected code, apply the necessary fixes, and update `requirements.txt`
+
+This is especially useful when:
+- A deprecation warning points to a function that is used in multiple places across the codebase
+- A major version bump changes how a library behaves (e.g., pandas 3.x changing its default string backend)
+- You are not comfortable navigating the code yourself
+
+> The AI handles the mechanical parts; you remain responsible for testing the result with `streamlit run app.py` before committing and pushing.
+
+---
+
+### Summary: update strategy
+
+```
+Security fix needed?  ──► Update immediately (requests, urllib3, certifi, pillow)
+Something is broken?  ──► Update only the relevant library, test thoroughly
+Nothing is broken?    ──► Do not update
+```
+
+---

app.py

@@ -1,99 +1,128 @@
-import streamlit as st
-from streamlit_option_menu import option_menu
-
-from tabs import (tab0_welcome, tab1_inputs, tab2_constraints,
-                  tab3_coefficients, tab4_optimization, tab5_sensitivity,
-                  tab6_scenarios)
-from utils.data_utils import load_slider_data, strip_unit_suffix
-from config.config import method_order, secondary_resources
-import pathlib
-
-st.set_page_config("Carbon Portfolio Optimizer", layout="wide")
-
-# Function to load CSS from the 'assets' folder
-def load_css(file_path):
-    with open(file_path) as f:
-        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
-
-# Load the external CSS
-css_path = pathlib.Path("assets/styles.css")
-load_css(css_path)
-
-st.markdown('<h1 class="custom-title">CRRA <span class="crra-hl">Toolkit</span>: CDR Portfolio Optimization</h1>', unsafe_allow_html=True)
-
-with st.sidebar:
-    selected = option_menu(
-        "Navigation",
-        options=[
-            "Welcome",
-            "Resource inputs",
-            "Method constraints",
-            "Resource coefficients",
-            "Portfolio generation",
-            "Sensitivity analysis",
-            "Scenario comparison",
-        ],
-        icons=["house", "upload", "gear", "sliders", "graph-up-arrow", "card-checklist", "search"],
-        default_index=0,
-        orientation="vertical",
-        key="crra-menu",
-        styles={
-            "container":{
-                "border-radius":"0px",
-            },
-            "menu-title":{
-                "font-family": "Segoe UI, sans-serif",
-                "font-weight":"bold",
-                "color": "#ff5f4d",
-                "text-transform": "uppercase",
-                "font-style": "italic",
-            },
-            "nav-link": {
-                "font-family": "Segoe UI, sans-serif",
-                "margin": "4px 0",
-                "--hover-color": "#F5F5F5",
-                "text-transform": "uppercase",
-                "font-weight":"600",
-                "font-style": "italic",
-            },
-            "nav-link-selected": {
-                "background-color": "#eae9d8",
-                "color": "#298231",
-                "font-weight": "900",
-            },
-        }
-    )
-
-# Initialize data to default values
-# Initialize constraints state
-if "constraints" not in st.session_state:
-    st.session_state.constraints = {}
-for m in method_order:
-    if m not in st.session_state.constraints:
-        st.session_state.constraints[m] = {"active": True, "cap_type": "percent", "cap_value": 100}
-
-# Initialize cost_sliders
-cost_sliders = load_slider_data()
-if "costs" not in st.session_state or st.session_state.costs == {}:
-    st.session_state.costs = {
-        m: {
-            strip_unit_suffix(r): (0.0 if (m, strip_unit_suffix(r)) in secondary_resources else cost_sliders[m][r]["median"])
-            for r in cost_sliders[m]
-        }
-        for m in cost_sliders
-    }
-
-if selected == "Welcome":
-    tab0_welcome.render_tab()
-elif selected == "Resource inputs":
-    tab1_inputs.render_tab(cost_sliders)
-elif selected == "Method constraints":
-    tab2_constraints.render_tab()
-elif selected == "Resource coefficients":
-    tab3_coefficients.render_tab(cost_sliders)
-elif selected == "Portfolio generation":
-    tab4_optimization.render_tab()
-elif selected == "Sensitivity analysis":
-    tab5_sensitivity.render_tab()
-elif selected == "Scenario comparison":
+import hashlib
+import os
+import sys
+import subprocess
+import pathlib
+
+import streamlit as st
+from streamlit_option_menu import option_menu
+
+# ── Auto-update: regenerate JSON files if inputs_aggregated.csv has changed ───
+# Uses a hash file to detect changes — works both locally and on Hugging Face.
+# Must run before importing config/tabs, which read the generated JSON files.
+_csv = "data/inputs_aggregated.csv"
+_hash_file = "data/.csv_hash"
+_generated = [
+    "data/cost_sliders.json",
+    "data/method_groups.json",
+    "data/secondary_resources.json",
+]
+
+def _md5(path):
+    hasher = hashlib.md5()
+    with open(path, "rb") as f:
+        hasher.update(f.read())
+    return hasher.hexdigest()
+
+if os.path.exists(_csv):
+    _current_hash = _md5(_csv)
+    _stored_hash = open(_hash_file).read().strip() if os.path.exists(_hash_file) else ""
+    _missing = any(not os.path.exists(f) for f in _generated)
+
+    if _current_hash != _stored_hash or _missing:
+        print("inputs_aggregated.csv has changed — running data/update.py ...")
+        subprocess.run([sys.executable, "data/update.py"], check=True)
+        with open(_hash_file, "w") as _f:
+            _f.write(_current_hash)
+        print("Data files updated successfully.")
+
+from tabs import (tab0_welcome, tab1_inputs, tab2_constraints,
+                  tab3_coefficients, tab4_optimization, tab5_sensitivity,
+                  tab6_scenarios)
+from utils.data_utils import load_slider_data, strip_unit_suffix
+from config.config import method_order, secondary_resources
+
+st.set_page_config("Carbon Portfolio Optimizer", layout="wide")
+
+def load_css(file_path):
+    with open(file_path) as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+css_path = pathlib.Path("assets/styles.css")
+load_css(css_path)
+
+st.markdown('<h1 class="custom-title">CRRA <span class="crra-hl">Toolkit</span>: CDR Portfolio Optimization</h1>', unsafe_allow_html=True)
+
+with st.sidebar:
+    selected = option_menu(
+        "Navigation",
+        options=[
+            "Welcome",
+            "Resource inputs",
+            "Method constraints",
+            "Resource coefficients",
+            "Portfolio generation",
+            "Sensitivity analysis",
+            "Scenario comparison",
+        ],
+        icons=["house", "upload", "gear", "sliders", "graph-up-arrow", "card-checklist", "search"],
+        default_index=0,
+        orientation="vertical",
+        key="crra-menu",
+        styles={
+            "container":{
+                "border-radius":"0px",
+            },
+            "menu-title":{
+                "font-family": "Segoe UI, sans-serif",
+                "font-weight":"bold",
+                "color": "#ff5f4d",
+                "text-transform": "uppercase",
+                "font-style": "italic",
+            },
+            "nav-link": {
+                "font-family": "Segoe UI, sans-serif",
+                "margin": "4px 0",
+                "--hover-color": "#F5F5F5",
+                "text-transform": "uppercase",
+                "font-weight":"600",
+                "font-style": "italic",
+            },
+            "nav-link-selected": {
+                "background-color": "#eae9d8",
+                "color": "#298231",
+                "font-weight": "900",
+            },
+        }
+    )
+
+if "constraints" not in st.session_state:
+    st.session_state.constraints = {}
+for m in method_order:
+    if m not in st.session_state.constraints:
+        st.session_state.constraints[m] = {"active": True, "cap_type": "percent", "cap_value": 100}
+
+cost_sliders = load_slider_data()
+if "costs" not in st.session_state or st.session_state.costs == {}:
+    st.session_state.costs = {
+        m: {
+            strip_unit_suffix(r): (0.0 if (m, strip_unit_suffix(r)) in secondary_resources else cost_sliders[m][r]["median"])
+            for r in cost_sliders[m]
+        }
+        for m in cost_sliders
+    }
+
+if selected == "Welcome":
+    tab0_welcome.render_tab()
+elif selected == "Resource inputs":
+    tab1_inputs.render_tab(cost_sliders)
+elif selected == "Method constraints":
+    tab2_constraints.render_tab()
+elif selected == "Resource coefficients":
+    tab3_coefficients.render_tab(cost_sliders)
+elif selected == "Portfolio generation":
+    tab4_optimization.render_tab()
+elif selected == "Sensitivity analysis":
+    tab5_sensitivity.render_tab()
+elif selected == "Scenario comparison":
     tab6_scenarios.render_tab()

assets/styles.css

@@ -182,7 +182,8 @@ h1.custom-title {
 [data-testid="stAlert"] > div,
 [data-testid="stAlert"] > div > div {
     border-radius: 0px !important;
-    clip-path: polygon(1% 0, 100% 0, 99% 100%, 0 100%);
+    /* clip-path: polygon(1% 0, 100% 0, 99% 100%, 0 100%); */
+    clip-path: polygon(16px 0, 100% 0, calc(100% - 16px) 100%, 0 100%)
 }
 
 [data-testid="stAlert"] p {
@@ -190,7 +191,7 @@ h1.custom-title {
     font-size: 0.95rem;
     line-height: 1.5;
     letter-spacing: 0.01em;
-    padding-left: 1%;
+    padding-left: 1rem;
 }
 
 /* Special warning box (tab1) */
@@ -206,8 +207,8 @@ h1.custom-title {
 
 .st-key-warning_resources span,
 [data-testid="stAlert"] span {
-    font-style: italic;
-    padding-left: 1%;
+    /* font-style: italic; */
+    padding-left: 1rem;
 }
 
 /* ── 8. Metrics ────────────────────────────────────────────── */
@@ -393,20 +394,8 @@ h1.custom-title {
 }
 
 /* Text & number input fields */
-[data-testid="stTextInput"] input,
-[data-testid="stNumberInput"] input {
-    border-radius: 0px !important;
-    border-top: none !important;
-    border-left: none !important;
-    border-right: none !important;
-    background: transparent !important;
-    box-shadow: none !important;
-    transition: border-color 0.2s ease;
-}
-[data-testid="stTextInput"] input:focus,
-[data-testid="stNumberInput"] input:focus {
-    border-bottom-color: var(--green-dark) !important;
-    box-shadow: none !important;
+[data-testid="stNumberInputContainer"] {
+    background-color: var(--off-white);
 }
 
 /* Text area */
@@ -476,13 +465,6 @@ section[data-testid="stExpander"] summary p {
 }
 
 /* ── 12. File uploaders ─────────────────────────────────────── */
-[class*="resource_uploader_"],
-[class*="inputs_loader_"],
-[class*="scenario_loader_"],
-.st-key-comparison_loader {
-    font-family: var(--font);
-}
-
 [class*="resource_uploader_"] p,
 [class*="inputs_loader_"] p,
 [class*="scenario_loader_"] p,
@@ -491,35 +473,30 @@ section[data-testid="stExpander"] summary p {
     font-style: italic;
 }
 
-[class*="resource_uploader_"] [data-testid="stFileUploaderDropzone"],
-[class*="inputs_loader_"] [data-testid="stFileUploaderDropzone"],
-[class*="scenario_loader_"] [data-testid="stFileUploaderDropzone"],
-.st-key-comparison_loader [data-testid="stFileUploaderDropzone"] {
-    background-color: var(--off-white);
-    color: var(--green-dark);
-    font-weight: 700;
-    letter-spacing: 0.094444em;
-    text-transform: uppercase;
-    font-size: 0.875rem;
-    border-radius: 0px !important;
-    width: stretch;
-}
-
-[class*="resource_uploader_"] [data-testid="stFileUploaderDropzone"] span svg,
-[class*="inputs_loader_"] [data-testid="stFileUploaderDropzone"] span svg,
-[class*="scenario_loader_"] [data-testid="stFileUploaderDropzone"] span svg,
-.st-key-comparison_loader [data-testid="stFileUploaderDropzone"] span svg {
-    color: var(--green-dark);
+[data-testid="stFileUploaderDropzone"]{
+    align-items: center;
+    flex-direction: row-reverse;
 }
 
 [class*="resource_uploader_"] [data-testid="stBaseButton-secondary"],
 [class*="inputs_loader_"] [data-testid="stBaseButton-secondary"],
 [class*="scenario_loader_"] [data-testid="stBaseButton-secondary"] {
-    color: var(--off-white) !important;
+    color: var(--green-dark) !important;
+    border: none !important;
+    border-radius: 0.5rem;
+}
+[class*="resource_uploader_"] [data-testid="stBaseButton-secondary"]:hover,
+[class*="inputs_loader_"] [data-testid="stBaseButton-secondary"]:hover,
+[class*="scenario_loader_"] [data-testid="stBaseButton-secondary"]:hover {
+    background-color: var(--green-light);
+}
+[class*="resource_uploader_"] [data-testid="stBaseButton-secondary"] p,
+[class*="inputs_loader_"] [data-testid="stBaseButton-secondary"] p ,
+[class*="scenario_loader_"] [data-testid="stBaseButton-secondary"] p {
+    color: var(--green-dark) !important;
     font-weight: 700 !important;
     text-transform: uppercase;
-    font-style: italic;
-    background-color: var(--green-dark) !important;
+    font-style: normal;
     border: none !important;
 }
 
@@ -594,10 +571,11 @@ section[data-testid="stExpander"] summary p {
     gap: 1.125%;
 }
 
-.st-key-container-btn-new {
+[class*="st-key-container-button"] {
     display: flex;
     flex-direction: row-reverse;
     gap: 1.125%;
+    justify-content: flex-start;
 }
 
 /* ── 17. Scrollbar ──────────────────────────────────────────── */

config/config.py

@@ -1,157 +1,86 @@
-import pandas as pd
-import plotly.express as px
-
-CO2_UNIT = "MtCO₂"
-
-method_groups = {
-    "Forestry": [
-        "Afforestation", "Reforestation", "Forest management", "Agroforestry"],
-    "Soil carbon sequestration (crop, grasslands)": [
-        "Cropland management", "Pasture management"],
-    "Blue carbon": [
-        "Coastal revegetation (mangrove, seaweeds, etc.)"],
-    "Durable biobased products": [
-        "Durable biobased products"],
-    "Bio-char": [
-        "Bio-char - Forest biomass", "Bio-char - Non-forest biomass", "Bio-char - Unspecified biomass"
-    ],
-    "Bio-CCS": [
-        "BioCCS with combustion", "BioCCS with combustion & growing biomass", "BioCCS with anaerobic digestion/fermentation", "BioCCS with anaerobic digestion/fermentation & growing biomass"
-    ],
-    "Enhanced weathering": [
-        "Enhanced weathering - Basalt mineral", "Enhanced weathering - Olivine mineral", "Enhanced weathering - Wollastonite mineral", "Enhanced weathering - Unspecified mineral"
-    ],
-    "Ocean alkalinity enhancement": [
-        "Mineral OAE / Ocean liming", "Electrochemical OAE"
-    ],
-    "Direct air carbon capture and storage (DACCS)": [
-        "Electrochemical DACCS", "Low-temp DACCS (solid-sorbent/liquid-solvent)",
-        "High-temp DACCS (solid-sorbent/liquid-solvent)", "Mineral looping DACCS",
-        "Moisture swing DACCS"
-    ],
-    "Direct ocean carbon captureand storage (DOCCS)": ["pH swing"],
-    "Mineralization": ["Mineralization ex-situ"]
-}
-
-resource_groups = {
-    "Minerals": ["Basalt mineral", "Olivine mineral", "Wollastonite mineral", "Unspecified mineral"],
-    "Biomass": ["Forest biomass", "Non-forest biomass", "Unspecified biomass"],
-    "Land": ["Arable land", "Non-arable land", "Unspecified land"],
-    "Chemicals": ["Unspecified chemical"],
-    "Energy": ["Electrical energy", "Thermal energy unspecified grade", "Thermal energy low grade", "Thermal energy high grade"],
-    "Water": ["Salt water", "Unspecified water"],
-    "Shoreline": ["Shoreline"],
-    "Storage": ["Geologic storage"]
-}
-
-resource_unit_map = {
-    "Land": "Mha",
-    "Energy": "MWh",
-    "Biomass": "Mt",
-    "Minerals": "Mt",
-    "Chemicals": "Mt",
-    "Shoreline": "km",
-    "Water": "bcm",
-    "Storage": "Mt"
-}
-
-resource_units = {
-    f"{resource_unit_map[cat]}/MtCO2": resources
-    for cat, resources in resource_groups.items()
-}
-
-resource_order = sum(resource_groups.values(), [])
-method_order = sum(method_groups.values(), [])
-
-# secondary resources
-secondary_df = pd.read_csv("data/secondary_resources.csv")
-secondary_resources = set(zip(
-    secondary_df["method"].str.strip(),
-    secondary_df["resource"].str.strip(),
-))
-
-# tooltips
-resource_tooltips = {
-    # "Arable land": "Land used for growing crops.",
-    # "Non-arable land": "Land not suitable for crop production, e.g., pastures.",
-    # "Unspecified land": "General land use not specified.",
-    # "Electrical energy ": "Electricity consumption per ton of CO2 captured.",
-    # "Thermal energy unspecified grade": "Heat energy consumption per ton of CO2 captured.",
-    # "Thermal energy low grade": "Heat energy consumption per ton of CO2 captured.",
-    # "Thermal energy high grade": "Heat energy consumption per ton of CO2 captured.",
-    "Forest biomass": "Dry quantities of biomass sourced from forests.",
-    "Non-forest biomass": "Dry quantities of biomass sourced from non-forest areas.",
-    "Unspecified biomass": "Dry quantities of general biomass, not specified.",
-    # "Basalt mineral": "Basalt mineral used in enhanced weathering.",
-    # "Olivine mineral": "Olivine mineral used in enhanced weathering.",
-    # "Wollastonite mineral": "Wollastonite mineral used in enhanced weathering.",
-    # "Unspecified mineral": "General mineral not specified for enhanced weathering.",
-    # "Unspecified chemical": "General chemical resource not specified.",
-    # "Salt water": "Salt water used in ocean-based methods.",
-    # "Unspecified water": "General water resource not specified.",
-    # "Shoreline": "Length of shoreline affected by coastal methods."
-}
-
-method_tooltips = {
-    "Afforestation": "Methods related to afforestation practices.",
-    "Reforestation": "Methods related to reforestation practices.",
-    "Forest management": "Sustainable management of forest resources.",
-    "Agroforestry": "Integration of trees and shrubs into agricultural systems.",
-    "Cropland management": "Practices to enhance carbon storage in croplands.",
-    "Pasture management": "Sustainable practices for managing pastures.",
-    "Coastal revegetation (mangrove, seaweeds)": "Restoration of coastal ecosystems using mangroves and seaweeds.",
-    "Durable biobased products": "Production of long-lasting biobased materials.",
-    "Bio-char - Forest biomass": "Production of bio-char from forest biomass.",
-    "Bio-char - Non-forest biomass": "Production of bio-char from non-forest biomass.",
-    "Bio-char - Unspecified biomass": "Production of bio-char from unspecified biomass sources.",
-    "BioCCS with combustion": "Bioenergy with carbon capture and storage using combustion.",
-    "BioCCS with combustion & growing biomass": "Bioenergy with carbon capture and storage using combustion and growing biomass.",
-    "BioCCS with anaerobic digestion/fermentation": "Bioenergy with carbon capture and storage using anaerobic digestion or fermentation.",
-    "BioCCS with anaerobic digestion/fermentation & growing biomass": "Bioenergy with carbon capture and storage using anaerobic digestion or fermentation and growing biomass.",
-    "Enhanced weathering - Basalt mineral": "Use of basalt mineral for enhanced weathering.",
-    "Enhanced weathering - Olivine mineral": "Use of olivine mineral for enhanced weathering.",
-    "Enhanced weathering - Wollastonite mineral": "Use of wollastonite mineral for enhanced weathering.",
-    "Enhanced weathering - Unspecified mineral": "Use of unspecified mineral for enhanced weathering.",
-    "Mineral OAE / Ocean liming": "Ocean alkalinity enhancement using mineral or ocean liming.",
-    "Electrochemical OAE": "Ocean alkalinity enhancement using electrochemical methods.",
-    "Electrochemical DACCS": "Direct air carbon capture and storage using electrochemical methods.",
-    "Low-temp DACCS (solid-sorbent/liquid-solvent)": "Direct air carbon capture and storage using low-temperature solid sorbents or liquid solvents.",
-    "High-temp DACCS (solid-sorbent/liquid-solvent)": "Direct air carbon capture and storage using high-temperature solid sorbents or liquid solvents.",
-    "Mineral looping DACCS": "Direct air carbon capture and storage using mineral looping.",
-    "Moisture swing DACCS": "Direct air carbon capture and storage using moisture swing methods.",
-    "pH swing": "Direct ocean carbon capture and storage using pH swing methods.",
-    "Mineralization ex-situ": "Ex-situ mineralization methods for carbon capture."
-}
-
-CRRA_COLORS = {
-    "off_white": "#eae9d8",
-    "red": "#ff5f4d",
-    "green_dark": "#298231",
-    "green": "#55c95b",
-    "green_light": "#92ef9b",
-    "yellow": "#d9e210",
-    "white": "#ffffff",
-    "brown_grey": "#665d5b",
-    "grey": "#a0a0a0",
-    "black": "#000000",
-}
-
-CRRA_FONT = "Segoe UI, sans-serif"
-
-PLOTLY_COLOR_SEQUENCE = [
-    CRRA_COLORS["red"],
-    CRRA_COLORS["green"],
-    CRRA_COLORS["yellow"],
-    CRRA_COLORS["green_dark"],
-    CRRA_COLORS["brown_grey"],
-    CRRA_COLORS["green_light"],
-    CRRA_COLORS["grey"],
-]
-
-PLOTLY_HEATMAP_SCALE = [
-    [0.0, CRRA_COLORS["white"]],
-    [0.5, CRRA_COLORS["green_light"]],
-    [1.0, CRRA_COLORS["green_dark"]],
-]
-
-PLOTLY_TEMPLATE = "plotly_white"
+import json
+import pandas as pd
+import plotly.express as px
+
+CO2_UNIT = "MtCO₂"
+
+with open("data/method_groups.json") as _f:
+    method_groups: dict[str, list[str]] = json.load(_f)
+
+_csv = pd.read_csv("data/inputs_aggregated.csv")
+
+# resource_groups: group → [resources], order follows first appearance in CSV
+resource_groups: dict[str, list[str]] = {}
+for _, _row in _csv.drop_duplicates(subset=["Resource group", "Resource"]).iterrows():
+    _g, _r = _row["Resource group"], _row["Resource"]
+    resource_groups.setdefault(_g, [])
+    if _r not in resource_groups[_g]:
+        resource_groups[_g].append(_r)
+
+# resource_unit_map: group → base unit (e.g. "Mha/MtCO2" → "Mha")
+resource_unit_map: dict[str, str] = {}
+for _, _row in _csv.drop_duplicates(subset=["Resource group"]).iterrows():
+    resource_unit_map[_row["Resource group"]] = str(_row["Unit"]).split("/")[0]
+
+resource_order = sum(resource_groups.values(), [])
+method_order = sum(method_groups.values(), [])
+
+try:
+    with open("data/secondary_resources.json") as _f:
+        secondary_resources: set[tuple[str, str]] = {tuple(p) for p in json.load(_f)}
+except FileNotFoundError:
+    secondary_resources: set[tuple[str, str]] = set()
+
+# Tooltips are loaded from data/tooltips.xlsx (two sheets: "Resources" and "Methods").
+# To add or edit a tooltip, open that file — no code change needed.
+# If the file is missing, tooltips are silently disabled (no hover text shown).
+try:
+    _tooltips_xl = pd.read_excel("data/tooltips.xlsx", sheet_name=None)
+    _df_res = _tooltips_xl.get("Resources", pd.DataFrame(columns=["Resource", "Tooltip"]))
+    _df_met = _tooltips_xl.get("Methods",   pd.DataFrame(columns=["Method",   "Tooltip"]))
+    resource_tooltips: dict[str, str] = {
+        row["Resource"]: row["Tooltip"]
+        for _, row in _df_res.iterrows()
+        if pd.notna(row.get("Tooltip")) and str(row.get("Tooltip", "")).strip()
+    }
+    method_tooltips: dict[str, str] = {
+        row["Method"]: row["Tooltip"]
+        for _, row in _df_met.iterrows()
+        if pd.notna(row.get("Tooltip")) and str(row.get("Tooltip", "")).strip()
+    }
+except FileNotFoundError:
+    resource_tooltips: dict[str, str] = {}
+    method_tooltips:   dict[str, str] = {}
+
+CRRA_COLORS = {
+    "off_white": "#eae9d8",
+    "red": "#ff5f4d",
+    "green_dark": "#298231",
+    "green": "#55c95b",
+    "green_light": "#92ef9b",
+    "yellow": "#d9e210",
+    "white": "#ffffff",
+    "brown_grey": "#665d5b",
+    "grey": "#a0a0a0",
+    "black": "#000000",
+}
+
+CRRA_FONT = "Segoe UI, sans-serif"
+
+PLOTLY_COLOR_SEQUENCE = [
+    CRRA_COLORS["red"],
+    CRRA_COLORS["green"],
+    CRRA_COLORS["yellow"],
+    CRRA_COLORS["green_dark"],
+    CRRA_COLORS["brown_grey"],
+    CRRA_COLORS["green_light"],
+    CRRA_COLORS["grey"],
+]
+
+PLOTLY_HEATMAP_SCALE = [
+    [0.0, CRRA_COLORS["white"]],
+    [0.5, CRRA_COLORS["green_light"]],
+    [1.0, CRRA_COLORS["green_dark"]],
+]
+
+PLOTLY_TEMPLATE = "plotly_white"

data/.csv_hash

@@ -0,0 +1 @@
+ae18d57252350286638943fd58c0300c

data/generate_input_template.py

@@ -14,8 +14,8 @@ from utils.data_utils import strip_unit_suffix
 with open("data/cost_sliders.json") as f:
     cost_sliders = json.load(f)
 
-secondary_df = pd.read_csv("data/secondary_resources.csv")
-secondary_resources = set(zip(secondary_df["method"], secondary_df["resource"]))
+with open("data/secondary_resources.json") as _f:
+    secondary_resources = {tuple(p) for p in json.load(_f)}
 
 wb = openpyxl.Workbook()
 

data/{generate_cost_matrix.py → generate_model_data.py}

@@ -14,24 +14,83 @@ def pop_by_name(d: dict, name: str):
     if key:
         d.pop(key)
 
+# Which base methods are replaced by derived variants.
+# Methods listed here must have derived entries added in create_sliders_inputs().
+REPLACED_BY_DERIVED = {"Bio-char", "Enhanced weathering"}
+
+# Which derived methods follow each base method (in order).
+DERIVED_FROM = {
+    "Bio-char": [
+        "Bio-char - Forest biomass",
+        "Bio-char - Non-forest biomass",
+        "Bio-char - Unspecified biomass",
+    ],
+    "Enhanced weathering": [
+        "Enhanced weathering - Basalt mineral",
+        "Enhanced weathering - Olivine mineral",
+        "Enhanced weathering - Wollastonite mineral",
+        "Enhanced weathering - Unspecified mineral",
+    ],
+    "BioCCS with combustion": ["BioCCS with combustion & growing biomass"],
+    "BioCCS with anaerobic digestion/fermentation": [
+        "BioCCS with anaerobic digestion/fermentation & growing biomass"
+    ],
+}
+
+
+def build_method_groups(df, cost_sliders):
+    """Build the method_groups dict from the CSV Method group column + derivation rules above.
+    Group and method order follows first appearance in inputs_aggregated.csv."""
+    base_methods_per_group = {}
+    for _, row in df.drop_duplicates(subset=["Implementation"]).iterrows():
+        m, g = row["Implementation"], row["Method group"]
+        base_methods_per_group.setdefault(g, [])
+        if m not in base_methods_per_group[g]:
+            base_methods_per_group[g].append(m)
+
+    method_groups = {}
+    for g, base_list in base_methods_per_group.items():
+        methods = []
+        for base in base_list:
+            if base not in REPLACED_BY_DERIVED:
+                methods.append(base)
+            for derived in DERIVED_FROM.get(base, []):
+                if derived in cost_sliders:
+                    methods.append(derived)
+        if methods:
+            method_groups[g] = methods
+    return method_groups
+
+
+def build_secondary_resources(df, cost_sliders):
+    """Build the full set of (method, resource) secondary pairs from the CSV
+    'Is secondary' column, then propagate to derived methods via DERIVED_FROM."""
+    # Base pairs from CSV
+    base_secondary = set()
+    for _, row in df[df["Is secondary"] == True].iterrows():
+        base_secondary.add((row["Implementation"], row["Resource"]))
+
+    # Expand to derived methods: derived methods inherit secondary resources from their base
+    full_secondary = set(base_secondary)
+    for base, deriveds in DERIVED_FROM.items():
+        base_resources_secondary = {r for (m, r) in base_secondary if m == base}
+        for derived in deriveds:
+            if derived in cost_sliders:
+                for r in base_resources_secondary:
+                    full_secondary.add((derived, r))
+
+    return full_secondary
+
+
 def create_sliders_inputs():
     df = pd.read_csv("data/inputs_aggregated.csv")
 
     cost_sliders = {}
 
-    # extract data from inputs and create final dictionary for sliders
+    # Build cost_sliders from CSV: one entry per (method, resource) row.
+    # Bio-char, Enhanced weathering and BioCCS variants are derived below.
     for _, row in df.iterrows():
         method = row["Implementation"]
-        # break bio-char into 3 different cases, based on which biomass is used
-        """
-        For the Implementation "Biochar", we must create three different cases:
-        1. Bio-char - Forest biomass
-        2. Bio-char - Non-forest biomass
-        3. Bio-char - Unspecified biomass
-        Where we have to keep the value for the corresponding resource in:
-            [Forest biomass OR Non-forest biomass OR Unspecified biomass]
-        But set the other two to zero, and keep the values in the other resources intact
-        """
         resource = row["Resource"] + " (" + row["Unit"] + ")"
         if row["min"] == row["max"] and row["Resource"] != "Geologic storage":
             row["min"] = row["min"] * .5
@@ -41,10 +100,9 @@ def create_sliders_inputs():
             "max": float(row["max"])
         }
         cost_sliders.setdefault(method, {})[resource] = entry
-        
-    print(cost_sliders)
-    
-    # create the three cases for bio-char
+
+    # ── Derived methods ───────────────────────────────────────────────────────
+    # Bio-char: split into 3 biomass-specific variants, remove generic base
     cost_sliders["Bio-char - Forest biomass"] = cost_sliders["Bio-char"].copy()
     pop_by_name(cost_sliders["Bio-char - Forest biomass"], "Non-forest biomass")
     pop_by_name(cost_sliders["Bio-char - Forest biomass"], "Unspecified biomass")
@@ -54,11 +112,9 @@ def create_sliders_inputs():
     cost_sliders["Bio-char - Unspecified biomass"] = cost_sliders["Bio-char"].copy()
     pop_by_name(cost_sliders["Bio-char - Unspecified biomass"], "Forest biomass")
     pop_by_name(cost_sliders["Bio-char - Unspecified biomass"], "Non-forest biomass")
-    # remove "Bio-char" from the dictionary
-    if "Bio-char" in cost_sliders:
-        del cost_sliders["Bio-char"]
-        
-    # create all cases for enhanced weathering
+    del cost_sliders["Bio-char"]
+
+    # Enhanced weathering: split into 4 mineral-specific variants, remove generic base
     cost_sliders["Enhanced weathering - Basalt mineral"] = cost_sliders["Enhanced weathering"].copy()
     pop_by_name(cost_sliders["Enhanced weathering - Basalt mineral"], "Olivine mineral")
     pop_by_name(cost_sliders["Enhanced weathering - Basalt mineral"], "Wollastonite mineral")
@@ -75,24 +131,33 @@ def create_sliders_inputs():
     pop_by_name(cost_sliders["Enhanced weathering - Unspecified mineral"], "Basalt mineral")
     pop_by_name(cost_sliders["Enhanced weathering - Unspecified mineral"], "Olivine mineral")
     pop_by_name(cost_sliders["Enhanced weathering - Unspecified mineral"], "Wollastonite mineral")
-    # remove "Enhanced weathering" from the dictionary
-    if "Enhanced weathering" in cost_sliders:
-        del cost_sliders["Enhanced weathering"]    
-    # create case for growing biomass in bioccs
+    del cost_sliders["Enhanced weathering"]
+
+    # BioCCS: add growing-biomass variants alongside their base methods
     cost_sliders["BioCCS with combustion & growing biomass"] = cost_sliders["BioCCS with combustion"].copy()
     pop_by_name(cost_sliders["BioCCS with combustion"], "Arable land")
     pop_by_name(cost_sliders["BioCCS with combustion & growing biomass"], "Forest biomass")
     pop_by_name(cost_sliders["BioCCS with combustion & growing biomass"], "Unspecified biomass")
-    
+
     cost_sliders["BioCCS with anaerobic digestion/fermentation & growing biomass"] = cost_sliders["BioCCS with anaerobic digestion/fermentation"].copy()
     pop_by_name(cost_sliders["BioCCS with anaerobic digestion/fermentation"], "Arable land")
     pop_by_name(cost_sliders["BioCCS with anaerobic digestion/fermentation & growing biomass"], "Non-forest biomass")
     pop_by_name(cost_sliders["BioCCS with anaerobic digestion/fermentation & growing biomass"], "Unspecified biomass")
-    
+
+    # ── Save outputs ──────────────────────────────────────────────────────────
     with open("data/cost_sliders.json", "w") as f:
         json.dump(cost_sliders, f, indent=2)
+    print("Saved cost_sliders.json")
+
+    method_groups = build_method_groups(df, cost_sliders)
+    with open("data/method_groups.json", "w") as f:
+        json.dump(method_groups, f, indent=2)
+    print("Saved method_groups.json")
 
-    print("Saved slider configuration to cost_sliders.json")
+    secondary_resources = build_secondary_resources(df, cost_sliders)
+    with open("data/secondary_resources.json", "w") as f:
+        json.dump(sorted(secondary_resources), f, indent=2)
+    print(f"Saved secondary_resources.json ({len(secondary_resources)} pairs)")
 
 if __name__ == "__main__":
     create_sliders_inputs()

data/inputs_aggregated.csv

@@ -1,84 +1,84 @@
-Implementation,Resource,Type,Unit,count,quantile_25,mean,median,quantile_75,std,min,max
-Afforestation,Unspecified land,Physical,Mha/MtCO2,36,0.024593,0.115652,0.094927,0.197075,0.112368,0.002,0.384615
-Afforestation,Unspecified water,Physical,bcm/MtCO2,2,0.092,0.092,0.092,0.092,0,0.092,0.092
-Agroforestry,Arable land,Physical,Mha/MtCO2,12,0.039953,0.450767,0.064101,0.2141,0.90114,0.0025,3.030303
-Bio-char,Electrical energy,Energy,MWh/MtCO2,6,8.75E+01,1.67E+05,3.50E+02,3.75E+05,2.58E+05,0.00E+00,5.00E+05
-Bio-char,Forest biomass,Physical,Mt/MtCO2,6,0.34,0.472833,0.37,0.55525,0.201624,0.33,0.82
-Bio-char,Non-forest biomass,Physical,Mt/MtCO2,8,1.142,1.291,1.3395,1.4885,0.33202,0.818,1.667
-Bio-char,Unspecified biomass,Physical,Mt/MtCO2,48,0.943396,1.924255,1.209221,2.522177,1.937824,0.5,12.86
-Bio-char,Unspecified land,Physical,Mha/MtCO2,4,0.056402,0.163201,0.163201,0.27,0.123321,0.056402,0.27
-Bio-char,Unspecified water,Physical,bcm/MtCO2,9,0,0.000633,0.0001,0.0005,0.001377,-0.0005,0.003
-BioCCS with anaerobic digestion/fermentation,Arable land,Physical,Mha/MtCO2,16,0.037937,0.100867,0.058844,0.103034,0.113758,0.022803,0.454545
-BioCCS with anaerobic digestion/fermentation,Non-forest biomass,Physical,Mt/MtCO2,6,1.428571,2.689964,1.561743,2.128274,2.62425,1.315,8
-BioCCS with anaerobic digestion/fermentation,Unspecified biomass,Physical,Mt/MtCO2,6,1.03357,1.379365,1.14,1.785,0.484913,0.998094,2
-BioCCS with anaerobic digestion/fermentation,Unspecified water,Physical,bcm/MtCO2,14,0.395455,0.569805,0.565909,0.654546,0.183277,0.368182,0.913636
-BioCCS with combustion,Arable land,Physical,Mha/MtCO2,32,0.038,0.20054,0.0584,0.094595,0.46566,0.022803,1.9451
-BioCCS with combustion,Electrical energy,Energy,MWh/MtCO2,18,27777.78,130975.3,101000,111111.1,162410.3,0,500000
-BioCCS with combustion,Forest biomass,Physical,Mt/MtCO2,8,0.560764,0.675481,0.59375,0.838675,0.144419,0.555556,0.8547
-BioCCS with combustion,Thermal energy unspecified grade,Energy,MWh/MtCO2,22,347222.2,1006242,930611.1,1025000,1052440,0,4000000
-BioCCS with combustion,Unspecified biomass,Physical,Mt/MtCO2,8,0.916667,1.264167,1.14,1.625,0.528225,0.666667,2
-BioCCS with combustion,Unspecified chemical,Physical,Mt/MtCO2,20,0.00027,4.044119,0.00316,0.016,8.287794,0.00013,20.2
-BioCCS with combustion,Unspecified water,Physical,bcm/MtCO2,32,0.006475,0.312937,0.201625,0.542046,0.343155,0.00063,1.296342
-"Coastal revegetation (mangrove, seaweeds, etc.)",Non-arable land,Physical,Mha/MtCO2,11,0.043295,0.132018,0.120566,0.197449,0.117064,0.0078,0.328289
-Cropland management,Arable land,Physical,Mha/MtCO2,14,0.27062,1.277946,0.420635,1.052335,2.329779,0.082645,9
-Durable biobased products,Electrical energy,Energy,MWh/MtCO2,2,4000000,4000000,4000000,4000000,0,4000000,4000000
-Durable biobased products,Non-arable land,Physical,Mha/MtCO2,2,6,6,6,6,0,6,6
-Durable biobased products,Unspecified biomass,Physical,Mt/MtCO2,6,1.267857,2.607143,3.571429,3.892857,1.842663,0,4
-Durable biobased products,Unspecified water,Physical,bcm/MtCO2,2,0.0002,0.0003,0.0003,0.0004,0.000283,0.0001,0.0005
-Electrochemical DACCS,Electrical energy,Energy,MWh/MtCO2,10,333333.3,2032081,784125,2750000,2378833,252556,6222222
-Electrochemical DACCS,Non-arable land,Physical,Mha/MtCO2,14,0.000272,0.002662,0.000324,0.000881,0.005657,0.000223,0.016
-Electrochemical DACCS,Unspecified water,Physical,bcm/MtCO2,6,0.002,0.011,0.005,0.0215,0.012522,0.001,0.027
-Electrochemical OAE,Electrical energy,Energy,MWh/MtCO2,8,1600000,2241250,2150000,2500000,1283594,830000,5000000
-Electrochemical OAE,Non-arable land,Physical,Mha/MtCO2,2,0.00086,0.00101,0.00101,0.00116,0.000424,0.00071,0.00131
-Electrochemical OAE,Shoreline,Physical,km/MtCO2,2,1.20E-02,1.20E-02,1.20E-02,1.20E-02,0.00E+00,1.20E-02,1.20E-02
-Electrochemical OAE,Unspecified mineral,Physical,Mt/MtCO2,4,2.4,2.95,2.95,3.5,0.635085,2.4,3.5
-Enhanced weathering,Arable land,Physical,Mha/MtCO2,28,0.12875,0.548974,0.25,0.5,0.709916,1.00E-06,2.5
-Enhanced weathering,Basalt mineral,Physical,Mt/MtCO2,25,3.33,5.773042,4.3,5.3,4.967901,1,19
-Enhanced weathering,Electrical energy,Energy,MWh/MtCO2,8,92850,593431.3,388750,500000,904565.7,9250,2775000
-Enhanced weathering,Non-arable land,Physical,Mha/MtCO2,12,0.004429,11.43247,0.009065,28.57143,17.2264,0.0009,40
-Enhanced weathering,Olivine mineral,Physical,Mt/MtCO2,26,0.909091,1.429511,1.25,1.58,0.941247,0.27027,3.7
-Enhanced weathering,Unspecified mineral,Physical,Mt/MtCO2,19,1.315789,6.356736,2.5,8.625,7.726415,0.5,25
-Enhanced weathering,Unspecified water,Physical,bcm/MtCO2,5,0.0005,0.010466,0.000866,0.000866,0.022102,0.0001,0.05
-Enhanced weathering,Wollastonite mineral,Physical,Mt/MtCO2,8,1.321429,1.629643,1.564286,1.83,0.742366,0.56,3
-Forest management,Unspecified land,Physical,Mha/MtCO2,2,0.438675,0.76865,0.76865,1.098625,0.93331,0.1087,1.4286
-High-temp DACCS (solid-sorbent/liquid-solvent),Electrical energy,Energy,MWh/MtCO2,32,361111.1,423787.8,462961.1,500000,163178.3,77000,770000
-High-temp DACCS (solid-sorbent/liquid-solvent),Non-arable land,Physical,Mha/MtCO2,23,2.20E-08,0.000229,0.000223,0.000298,0.000299,1.50E-10,0.000991
-High-temp DACCS (solid-sorbent/liquid-solvent),Thermal energy high grade,Energy,MWh/MtCO2,38,1472222,1954835,1750000,2314815,643937.6,1125000,3800000
-High-temp DACCS (solid-sorbent/liquid-solvent),Unspecified water,Physical,bcm/MtCO2,16,0.002502,0.010221,0.0047,0.00818,0.015887,5E-09,0.05
-Low-temp DACCS (solid-sorbent/liquid-solvent),Electrical energy,Energy,MWh/MtCO2,44,218000,895320.2,462961.1,690000,1255695,130000,4611111
-Low-temp DACCS (solid-sorbent/liquid-solvent),Non-arable land,Physical,Mha/MtCO2,23,6.25E-08,0.000238,0.000223,0.000298,0.000294,1.00E-11,0.000991
-Low-temp DACCS (solid-sorbent/liquid-solvent),Thermal energy low grade,Energy,MWh/MtCO2,30,1432500,1678215,1500000,2062500,516794.3,638888.9,2722222
-Low-temp DACCS (solid-sorbent/liquid-solvent),Unspecified water,Physical,bcm/MtCO2,14,7.5E-10,0.003187,0.001008,0.004925,0.005238,-0.002,0.015
-Mineral OAE / Ocean liming,Electrical energy,Energy,MWh/MtCO2,12,323625,1153583,606500,1755000,1286024,27000,4000000
-Mineral OAE / Ocean liming,Non-arable land,Physical,Mha/MtCO2,4,0,0.000505,0.000355,0.00086,0.000632,0,0.00131
-Mineral OAE / Ocean liming,Thermal energy unspecified grade,Energy,MWh/MtCO2,6,1388889,1257630,1458944,1529000,542588.8,160000,1550000
-Mineral OAE / Ocean liming,Unspecified mineral,Physical,Mt/MtCO2,8,1.62,2.489,1.743,2.5895,1.554598,1.4,5
-Mineral OAE / Ocean liming,Unspecified water,Physical,bcm/MtCO2,2,0.000678,0.000678,0.000678,0.000678,0,0.000678,0.000678
-Mineral looping DACCS,Electrical energy,Energy,MWh/MtCO2,8,83333.33,1104167,83333.33,1375000,1793811,0,4000000
-Mineral looping DACCS,Non-arable land,Physical,Mha/MtCO2,12,0.000587,0.001065,0.000639,0.000873,0.001064,0.000223,0.0033
-Mineral looping DACCS,Thermal energy unspecified grade,Energy,MWh/MtCO2,4,1479167,1715278,1819444,2055556,534015.3,1000000,2222222
-Mineral looping DACCS,Unspecified mineral,Physical,Mt/MtCO2,4,0.15,0.225,0.2,0.275,0.206155,0,0.5
-Mineral looping DACCS,Unspecified water,Physical,bcm/MtCO2,6,0.000125,0.006762,0.0002,0.010068,0.011116,0,0.026714
-Mineralization ex-situ,Electrical energy,Energy,MWh/MtCO2,8,500000,1062500,750000,1250000,979704.8,0,3000000
-Mineralization ex-situ,Non-arable land,Physical,Mha/MtCO2,4,0.000298,0.000522,0.000436,0.000659,0.000342,0.000223,0.000991
-Mineralization ex-situ,Olivine mineral,Physical,Mt/MtCO2,2,0.8,0.8,0.8,0.8,0,0.8,0.8
-Mineralization ex-situ,Thermal energy unspecified grade,Energy,MWh/MtCO2,4,400000,575000,450000,625000,287228.1,400000,1000000
-Mineralization ex-situ,Unspecified mineral,Physical,Mt/MtCO2,22,0.4375,3.935,3,7,3.647722,0.04,10
-Mineralization ex-situ,Unspecified water,Physical,bcm/MtCO2,14,0.0002,0.050004,0.00545,0.0145,0.106908,0,0.3
-Moisture swing DACCS,Electrical energy,Energy,MWh/MtCO2,4,316000,324666.7,324666.7,333333.3,10007.4,316000,333333.3
-Moisture swing DACCS,Non-arable land,Physical,Mha/MtCO2,8,0.000169,0.000331,0.000272,0.00038,0.000319,8.00E-06,0.000991
-Moisture swing DACCS,Unspecified water,Physical,bcm/MtCO2,4,-0.00015,0.000427,0.000427,0.001,0.000662,-0.00015,0.001
-Pasture management,Arable land,Physical,Mha/MtCO2,24,0.102253,0.442368,0.252422,0.522974,0.522145,0.071894,2.289744
-Reforestation,Unspecified land,Physical,Mha/MtCO2,34,0.044459,1.564102,0.094927,0.1887,6.825803,0.002,38.8
-Reforestation,Unspecified water,Physical,bcm/MtCO2,2,0.092,0.092,0.092,0.092,0,0.092,0.092
-pH swing,Electrical energy,Energy,MWh/MtCO2,28,980000,2205112,1768000,3302500,1381909,660000,4670000
-pH swing,Salt water,Physical,bcm/MtCO2,4,0.435,4.78,4.78,9.125,5.017174,0.435,9.125
-pH swing,Unspecified water,Physical,bcm/MtCO2,4,0.217391,6.608696,6.608696,13,7.380043,0.217391,13
-BioCCS with combustion,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
-BioCCS with anaerobic digestion/fermentation,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
-Electrochemical DACCS,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
-Low-temp DACCS (solid-sorbent/liquid-solvent),Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
-High-temp DACCS (solid-sorbent/liquid-solvent),Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
-Mineral looping DACCS,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
-Moisture swing DACCS,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
-pH swing,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+Implementation,Method group,Resource,Resource group,Type,Unit,count,quantile_25,mean,median,quantile_75,std,min,max,Is secondary
+Afforestation,Forestry,Unspecified land,Land,Physical,Mha/MtCO2,36,0.024593,0.115652,0.094927,0.197075,0.112368,0.002,0.384615,False
+Afforestation,Forestry,Unspecified water,Water,Physical,bcm/MtCO2,2,0.092,0.092,0.092,0.092,0.0,0.092,0.092,True
+Agroforestry,Forestry,Arable land,Land,Physical,Mha/MtCO2,12,0.039953,0.450767,0.064101,0.2141,0.90114,0.0025,3.030303,False
+Bio-char,Bio-char,Electrical energy,Energy,Energy,MWh/MtCO2,6,87.5,167000.0,350.0,375000.0,258000.0,0.0,500000.0,True
+Bio-char,Bio-char,Forest biomass,Biomass,Physical,Mt/MtCO2,6,0.34,0.472833,0.37,0.55525,0.201624,0.33,0.82,False
+Bio-char,Bio-char,Non-forest biomass,Biomass,Physical,Mt/MtCO2,8,1.142,1.291,1.3395,1.4885,0.33202,0.818,1.667,False
+Bio-char,Bio-char,Unspecified biomass,Biomass,Physical,Mt/MtCO2,48,0.943396,1.924255,1.209221,2.522177,1.937824,0.5,12.86,False
+Bio-char,Bio-char,Unspecified land,Land,Physical,Mha/MtCO2,4,0.056402,0.163201,0.163201,0.27,0.123321,0.056402,0.27,True
+Bio-char,Bio-char,Unspecified water,Water,Physical,bcm/MtCO2,9,0.0,0.000633,0.0001,0.0005,0.001377,-0.0005,0.003,True
+BioCCS with anaerobic digestion/fermentation,Bio-CCS,Arable land,Land,Physical,Mha/MtCO2,16,0.037937,0.100867,0.058844,0.103034,0.113758,0.022803,0.454545,False
+BioCCS with anaerobic digestion/fermentation,Bio-CCS,Non-forest biomass,Biomass,Physical,Mt/MtCO2,6,1.428571,2.689964,1.561743,2.128274,2.62425,1.315,8.0,False
+BioCCS with anaerobic digestion/fermentation,Bio-CCS,Unspecified biomass,Biomass,Physical,Mt/MtCO2,6,1.03357,1.379365,1.14,1.785,0.484913,0.998094,2.0,False
+BioCCS with anaerobic digestion/fermentation,Bio-CCS,Unspecified water,Water,Physical,bcm/MtCO2,14,0.395455,0.569805,0.565909,0.654546,0.183277,0.368182,0.913636,True
+BioCCS with combustion,Bio-CCS,Arable land,Land,Physical,Mha/MtCO2,32,0.038,0.20054,0.0584,0.094595,0.46566,0.022803,1.9451,False
+BioCCS with combustion,Bio-CCS,Electrical energy,Energy,Energy,MWh/MtCO2,18,27777.78,130975.3,101000.0,111111.1,162410.3,0.0,500000.0,True
+BioCCS with combustion,Bio-CCS,Forest biomass,Biomass,Physical,Mt/MtCO2,8,0.560764,0.675481,0.59375,0.838675,0.144419,0.555556,0.8547,False
+BioCCS with combustion,Bio-CCS,Thermal energy unspecified grade,Energy,Energy,MWh/MtCO2,22,347222.2,1006242.0,930611.1,1025000.0,1052440.0,0.0,4000000.0,True
+BioCCS with combustion,Bio-CCS,Unspecified biomass,Biomass,Physical,Mt/MtCO2,8,0.916667,1.264167,1.14,1.625,0.528225,0.666667,2.0,False
+BioCCS with combustion,Bio-CCS,Unspecified chemical,Chemicals,Physical,Mt/MtCO2,20,0.00027,4.044119,0.00316,0.016,8.287794,0.00013,20.2,True
+BioCCS with combustion,Bio-CCS,Unspecified water,Water,Physical,bcm/MtCO2,32,0.006475,0.312937,0.201625,0.542046,0.343155,0.00063,1.296342,True
+"Coastal revegetation (mangrove, seaweeds, etc.)",Blue carbon,Non-arable land,Land,Physical,Mha/MtCO2,11,0.043295,0.132018,0.120566,0.197449,0.117064,0.0078,0.328289,False
+Cropland management,"Soil carbon sequestration (crop, grasslands)",Arable land,Land,Physical,Mha/MtCO2,14,0.27062,1.277946,0.420635,1.052335,2.329779,0.082645,9.0,False
+Durable biobased products,Durable biobased products,Electrical energy,Energy,Energy,MWh/MtCO2,2,4000000.0,4000000.0,4000000.0,4000000.0,0.0,4000000.0,4000000.0,True
+Durable biobased products,Durable biobased products,Non-arable land,Land,Physical,Mha/MtCO2,2,6.0,6.0,6.0,6.0,0.0,6.0,6.0,True
+Durable biobased products,Durable biobased products,Unspecified biomass,Biomass,Physical,Mt/MtCO2,6,1.267857,2.607143,3.571429,3.892857,1.842663,0.0,4.0,False
+Durable biobased products,Durable biobased products,Unspecified water,Water,Physical,bcm/MtCO2,2,0.0002,0.0003,0.0003,0.0004,0.000283,0.0001,0.0005,True
+Electrochemical DACCS,Direct air carbon capture and storage (DACCS),Electrical energy,Energy,Energy,MWh/MtCO2,10,333333.3,2032081.0,784125.0,2750000.0,2378833.0,252556.0,6222222.0,False
+Electrochemical DACCS,Direct air carbon capture and storage (DACCS),Non-arable land,Land,Physical,Mha/MtCO2,14,0.000272,0.002662,0.000324,0.000881,0.005657,0.000223,0.016,True
+Electrochemical DACCS,Direct air carbon capture and storage (DACCS),Unspecified water,Water,Physical,bcm/MtCO2,6,0.002,0.011,0.005,0.0215,0.012522,0.001,0.027,False
+Electrochemical OAE,Ocean alkalinity enhancement,Electrical energy,Energy,Energy,MWh/MtCO2,8,1600000.0,2241250.0,2150000.0,2500000.0,1283594.0,830000.0,5000000.0,False
+Electrochemical OAE,Ocean alkalinity enhancement,Non-arable land,Land,Physical,Mha/MtCO2,2,0.00086,0.00101,0.00101,0.00116,0.000424,0.00071,0.00131,True
+Electrochemical OAE,Ocean alkalinity enhancement,Shoreline,Shoreline,Physical,km/MtCO2,2,0.012,0.012,0.012,0.012,0.0,0.012,0.012,False
+Electrochemical OAE,Ocean alkalinity enhancement,Unspecified mineral,Minerals,Physical,Mt/MtCO2,4,2.4,2.95,2.95,3.5,0.635085,2.4,3.5,False
+Enhanced weathering,Enhanced weathering,Arable land,Land,Physical,Mha/MtCO2,28,0.12875,0.548974,0.25,0.5,0.709916,1e-06,2.5,True
+Enhanced weathering,Enhanced weathering,Basalt mineral,Minerals,Physical,Mt/MtCO2,25,3.33,5.773042,4.3,5.3,4.967901,1.0,19.0,False
+Enhanced weathering,Enhanced weathering,Electrical energy,Energy,Energy,MWh/MtCO2,8,92850.0,593431.3,388750.0,500000.0,904565.7,9250.0,2775000.0,True
+Enhanced weathering,Enhanced weathering,Non-arable land,Land,Physical,Mha/MtCO2,12,0.004429,11.43247,0.009065,28.57143,17.2264,0.0009,40.0,True
+Enhanced weathering,Enhanced weathering,Olivine mineral,Minerals,Physical,Mt/MtCO2,26,0.909091,1.429511,1.25,1.58,0.941247,0.27027,3.7,False
+Enhanced weathering,Enhanced weathering,Unspecified mineral,Minerals,Physical,Mt/MtCO2,19,1.315789,6.356736,2.5,8.625,7.726415,0.5,25.0,False
+Enhanced weathering,Enhanced weathering,Unspecified water,Water,Physical,bcm/MtCO2,5,0.0005,0.010466,0.000866,0.000866,0.022102,0.0001,0.05,True
+Enhanced weathering,Enhanced weathering,Wollastonite mineral,Minerals,Physical,Mt/MtCO2,8,1.321429,1.629643,1.564286,1.83,0.742366,0.56,3.0,False
+Forest management,Forestry,Unspecified land,Land,Physical,Mha/MtCO2,2,0.438675,0.76865,0.76865,1.098625,0.93331,0.1087,1.4286,False
+High-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Electrical energy,Energy,Energy,MWh/MtCO2,32,361111.1,423787.8,462961.1,500000.0,163178.3,77000.0,770000.0,False
+High-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Non-arable land,Land,Physical,Mha/MtCO2,23,2.2e-08,0.000229,0.000223,0.000298,0.000299,1.5e-10,0.000991,False
+High-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Thermal energy high grade,Energy,Energy,MWh/MtCO2,38,1472222.0,1954835.0,1750000.0,2314815.0,643937.6,1125000.0,3800000.0,False
+High-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Unspecified water,Water,Physical,bcm/MtCO2,16,0.002502,0.010221,0.0047,0.00818,0.015887,5e-09,0.05,True
+Low-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Electrical energy,Energy,Energy,MWh/MtCO2,44,218000.0,895320.2,462961.1,690000.0,1255695.0,130000.0,4611111.0,False
+Low-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Non-arable land,Land,Physical,Mha/MtCO2,23,6.25e-08,0.000238,0.000223,0.000298,0.000294,1e-11,0.000991,False
+Low-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Thermal energy low grade,Energy,Energy,MWh/MtCO2,30,1432500.0,1678215.0,1500000.0,2062500.0,516794.3,638888.9,2722222.0,False
+Low-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Unspecified water,Water,Physical,bcm/MtCO2,14,7.5e-10,0.003187,0.001008,0.004925,0.005238,-0.002,0.015,True
+Mineral OAE / Ocean liming,Ocean alkalinity enhancement,Electrical energy,Energy,Energy,MWh/MtCO2,12,323625.0,1153583.0,606500.0,1755000.0,1286024.0,27000.0,4000000.0,True
+Mineral OAE / Ocean liming,Ocean alkalinity enhancement,Non-arable land,Land,Physical,Mha/MtCO2,4,0.0,0.000505,0.000355,0.00086,0.000632,0.0,0.00131,True
+Mineral OAE / Ocean liming,Ocean alkalinity enhancement,Thermal energy unspecified grade,Energy,Energy,MWh/MtCO2,6,1388889.0,1257630.0,1458944.0,1529000.0,542588.8,160000.0,1550000.0,True
+Mineral OAE / Ocean liming,Ocean alkalinity enhancement,Unspecified mineral,Minerals,Physical,Mt/MtCO2,8,1.62,2.489,1.743,2.5895,1.554598,1.4,5.0,False
+Mineral OAE / Ocean liming,Ocean alkalinity enhancement,Unspecified water,Water,Physical,bcm/MtCO2,2,0.000678,0.000678,0.000678,0.000678,0.0,0.000678,0.000678,True
+Mineral looping DACCS,Direct air carbon capture and storage (DACCS),Electrical energy,Energy,Energy,MWh/MtCO2,8,83333.33,1104167.0,83333.33,1375000.0,1793811.0,0.0,4000000.0,False
+Mineral looping DACCS,Direct air carbon capture and storage (DACCS),Non-arable land,Land,Physical,Mha/MtCO2,12,0.000587,0.001065,0.000639,0.000873,0.001064,0.000223,0.0033,False
+Mineral looping DACCS,Direct air carbon capture and storage (DACCS),Thermal energy unspecified grade,Energy,Energy,MWh/MtCO2,4,1479167.0,1715278.0,1819444.0,2055556.0,534015.3,1000000.0,2222222.0,False
+Mineral looping DACCS,Direct air carbon capture and storage (DACCS),Unspecified mineral,Minerals,Physical,Mt/MtCO2,4,0.15,0.225,0.2,0.275,0.206155,0.0,0.5,False
+Mineral looping DACCS,Direct air carbon capture and storage (DACCS),Unspecified water,Water,Physical,bcm/MtCO2,6,0.000125,0.006762,0.0002,0.010068,0.011116,0.0,0.026714,True
+Mineralization ex-situ,Mineralization,Electrical energy,Energy,Energy,MWh/MtCO2,8,500000.0,1062500.0,750000.0,1250000.0,979704.8,0.0,3000000.0,False
+Mineralization ex-situ,Mineralization,Non-arable land,Land,Physical,Mha/MtCO2,4,0.000298,0.000522,0.000436,0.000659,0.000342,0.000223,0.000991,False
+Mineralization ex-situ,Mineralization,Olivine mineral,Minerals,Physical,Mt/MtCO2,2,0.8,0.8,0.8,0.8,0.0,0.8,0.8,False
+Mineralization ex-situ,Mineralization,Thermal energy unspecified grade,Energy,Energy,MWh/MtCO2,4,400000.0,575000.0,450000.0,625000.0,287228.1,400000.0,1000000.0,False
+Mineralization ex-situ,Mineralization,Unspecified mineral,Minerals,Physical,Mt/MtCO2,22,0.4375,3.935,3.0,7.0,3.647722,0.04,10.0,False
+Mineralization ex-situ,Mineralization,Unspecified water,Water,Physical,bcm/MtCO2,14,0.0002,0.050004,0.00545,0.0145,0.106908,0.0,0.3,False
+Moisture swing DACCS,Direct air carbon capture and storage (DACCS),Electrical energy,Energy,Energy,MWh/MtCO2,4,316000.0,324666.7,324666.7,333333.3,10007.4,316000.0,333333.3,False
+Moisture swing DACCS,Direct air carbon capture and storage (DACCS),Non-arable land,Land,Physical,Mha/MtCO2,8,0.000169,0.000331,0.000272,0.00038,0.000319,8e-06,0.000991,False
+Moisture swing DACCS,Direct air carbon capture and storage (DACCS),Unspecified water,Water,Physical,bcm/MtCO2,4,-0.00015,0.000427,0.000427,0.001,0.000662,-0.00015,0.001,False
+Pasture management,"Soil carbon sequestration (crop, grasslands)",Arable land,Land,Physical,Mha/MtCO2,24,0.102253,0.442368,0.252422,0.522974,0.522145,0.071894,2.289744,False
+Reforestation,Forestry,Unspecified land,Land,Physical,Mha/MtCO2,34,0.044459,1.564102,0.094927,0.1887,6.825803,0.002,38.8,False
+Reforestation,Forestry,Unspecified water,Water,Physical,bcm/MtCO2,2,0.092,0.092,0.092,0.092,0.0,0.092,0.092,True
+pH swing,Direct ocean carbon capture and storage (DOCCS),Electrical energy,Energy,Energy,MWh/MtCO2,28,980000.0,2205112.0,1768000.0,3302500.0,1381909.0,660000.0,4670000.0,False
+pH swing,Direct ocean carbon capture and storage (DOCCS),Salt water,Water,Physical,bcm/MtCO2,4,0.435,4.78,4.78,9.125,5.017174,0.435,9.125,False
+pH swing,Direct ocean carbon capture and storage (DOCCS),Unspecified water,Water,Physical,bcm/MtCO2,4,0.217391,6.608696,6.608696,13.0,7.380043,0.217391,13.0,False
+BioCCS with combustion,Bio-CCS,Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False
+BioCCS with anaerobic digestion/fermentation,Bio-CCS,Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False
+Electrochemical DACCS,Direct air carbon capture and storage (DACCS),Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False
+Low-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False
+High-temp DACCS (solid-sorbent/liquid-solvent),Direct air carbon capture and storage (DACCS),Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False
+Mineral looping DACCS,Direct air carbon capture and storage (DACCS),Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False
+Moisture swing DACCS,Direct air carbon capture and storage (DACCS),Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False
+pH swing,Direct ocean carbon capture and storage (DOCCS),Geologic storage,Storage,Physical,Mt/MtCO2,1,1.0,1.0,1.0,1.0,0.0,1.0,1.0,False

data/method_groups.json

@@ -0,0 +1,52 @@
+{
+  "Forestry": [
+    "Afforestation",
+    "Agroforestry",
+    "Forest management",
+    "Reforestation"
+  ],
+  "Bio-char": [
+    "Bio-char - Forest biomass",
+    "Bio-char - Non-forest biomass",
+    "Bio-char - Unspecified biomass"
+  ],
+  "Bio-CCS": [
+    "BioCCS with anaerobic digestion/fermentation",
+    "BioCCS with anaerobic digestion/fermentation & growing biomass",
+    "BioCCS with combustion",
+    "BioCCS with combustion & growing biomass"
+  ],
+  "Blue carbon": [
+    "Coastal revegetation (mangrove, seaweeds, etc.)"
+  ],
+  "Soil carbon sequestration (crop, grasslands)": [
+    "Cropland management",
+    "Pasture management"
+  ],
+  "Durable biobased products": [
+    "Durable biobased products"
+  ],
+  "Direct air carbon capture and storage (DACCS)": [
+    "Electrochemical DACCS",
+    "High-temp DACCS (solid-sorbent/liquid-solvent)",
+    "Low-temp DACCS (solid-sorbent/liquid-solvent)",
+    "Mineral looping DACCS",
+    "Moisture swing DACCS"
+  ],
+  "Ocean alkalinity enhancement": [
+    "Electrochemical OAE",
+    "Mineral OAE / Ocean liming"
+  ],
+  "Enhanced weathering": [
+    "Enhanced weathering - Basalt mineral",
+    "Enhanced weathering - Olivine mineral",
+    "Enhanced weathering - Wollastonite mineral",
+    "Enhanced weathering - Unspecified mineral"
+  ],
+  "Mineralization": [
+    "Mineralization ex-situ"
+  ],
+  "Direct ocean carbon capture and storage (DOCCS)": [
+    "pH swing"
+  ]
+}

data/secondary_resources.csv

@@ -1,50 +0,0 @@
-method,resource
-Afforestation,Unspecified water
-Reforestation,Unspecified water
-Durable biobased products,Non-arable land
-Durable biobased products,Electrical energy
-Durable biobased products,Unspecified water
-Bio-char - Forest biomass,Unspecified land
-Bio-char - Forest biomass,Electrical energy
-Bio-char - Forest biomass,Unspecified water
-Bio-char - Non-forest biomass,Unspecified land 
-Bio-char - Non-forest biomass,Electrical energy
-Bio-char - Non-forest biomass,Unspecified water
-Bio-char - Unspecified biomass,Unspecified land
-Bio-char - Unspecified biomass,Electrical energy
-Bio-char - Unspecified biomass,Unspecified water
-BioCCS with combustion,Unspecified chemical
-BioCCS with combustion,Electrical energy
-BioCCS with combustion,Thermal energy
-BioCCS with combustion,Unspecified water
-BioCCS with combustion & growing biomass,Unspecified chemical
-BioCCS with combustion & growing biomass,Electrical energy
-BioCCS with combustion & growing biomass,Thermal energy
-BioCCS with combustion & growing biomass,Unspecified water
-BioCCS with anaerobic digestion/fermentation,Unspecified water
-BioCCS with anaerobic digestion/fermentation & growing biomass,Unspecified water
-Enhanced weathering - Basalt mineral,Arable land
-Enhanced weathering - Basalt mineral,Non-arable land
-Enhanced weathering - Basalt mineral,Electrical energy
-Enhanced weathering - Basalt mineral,Unspecified water
-Enhanced weathering - Olivine mineral,Arable land
-Enhanced weathering - Olivine mineral,Non-arable land
-Enhanced weathering - Olivine mineral,Electrical energy
-Enhanced weathering - Olivine mineral,Unspecified water
-Enhanced weathering - Wollastonite mineral,Arable land
-Enhanced weathering - Wollastonite mineral,Non-arable land
-Enhanced weathering - Wollastonite mineral,Electrical energy
-Enhanced weathering - Wollastonite mineral,Unspecified water
-Enhanced weathering - Unspecified mineral,Arable land
-Enhanced weathering - Unspecified mineral,Non-arable land
-Enhanced weathering - Unspecified mineral,Electrical energy
-Enhanced weathering - Unspecified mineral,Unspecified water
-Mineral OAE / Ocean liming,Non-arable land
-Mineral OAE / Ocean liming,Electrical energy
-Mineral OAE / Ocean liming,Thermal energy
-Mineral OAE / Ocean liming,Unspecified water
-Electrochemical OAE,Non-arable land
-Electrochemical DACCS,Non-arable land
-Low-temp DACCS (solid-sorbent/liquid-solvent),Unspecified water
-High-temp DACCS (solid-sorbent/liquid-solvent),Unspecified water
-Mineral looping DACCS,Unspecified water

data/secondary_resources.json

@@ -0,0 +1,226 @@
+[
+  [
+    "Afforestation",
+    "Unspecified water"
+  ],
+  [
+    "Bio-char",
+    "Electrical energy"
+  ],
+  [
+    "Bio-char",
+    "Unspecified land"
+  ],
+  [
+    "Bio-char",
+    "Unspecified water"
+  ],
+  [
+    "Bio-char - Forest biomass",
+    "Electrical energy"
+  ],
+  [
+    "Bio-char - Forest biomass",
+    "Unspecified land"
+  ],
+  [
+    "Bio-char - Forest biomass",
+    "Unspecified water"
+  ],
+  [
+    "Bio-char - Non-forest biomass",
+    "Electrical energy"
+  ],
+  [
+    "Bio-char - Non-forest biomass",
+    "Unspecified land"
+  ],
+  [
+    "Bio-char - Non-forest biomass",
+    "Unspecified water"
+  ],
+  [
+    "Bio-char - Unspecified biomass",
+    "Electrical energy"
+  ],
+  [
+    "Bio-char - Unspecified biomass",
+    "Unspecified land"
+  ],
+  [
+    "Bio-char - Unspecified biomass",
+    "Unspecified water"
+  ],
+  [
+    "BioCCS with anaerobic digestion/fermentation",
+    "Unspecified water"
+  ],
+  [
+    "BioCCS with anaerobic digestion/fermentation & growing biomass",
+    "Unspecified water"
+  ],
+  [
+    "BioCCS with combustion",
+    "Electrical energy"
+  ],
+  [
+    "BioCCS with combustion",
+    "Thermal energy unspecified grade"
+  ],
+  [
+    "BioCCS with combustion",
+    "Unspecified chemical"
+  ],
+  [
+    "BioCCS with combustion",
+    "Unspecified water"
+  ],
+  [
+    "BioCCS with combustion & growing biomass",
+    "Electrical energy"
+  ],
+  [
+    "BioCCS with combustion & growing biomass",
+    "Thermal energy unspecified grade"
+  ],
+  [
+    "BioCCS with combustion & growing biomass",
+    "Unspecified chemical"
+  ],
+  [
+    "BioCCS with combustion & growing biomass",
+    "Unspecified water"
+  ],
+  [
+    "Durable biobased products",
+    "Electrical energy"
+  ],
+  [
+    "Durable biobased products",
+    "Non-arable land"
+  ],
+  [
+    "Durable biobased products",
+    "Unspecified water"
+  ],
+  [
+    "Electrochemical DACCS",
+    "Non-arable land"
+  ],
+  [
+    "Electrochemical OAE",
+    "Non-arable land"
+  ],
+  [
+    "Enhanced weathering",
+    "Arable land"
+  ],
+  [
+    "Enhanced weathering",
+    "Electrical energy"
+  ],
+  [
+    "Enhanced weathering",
+    "Non-arable land"
+  ],
+  [
+    "Enhanced weathering",
+    "Unspecified water"
+  ],
+  [
+    "Enhanced weathering - Basalt mineral",
+    "Arable land"
+  ],
+  [
+    "Enhanced weathering - Basalt mineral",
+    "Electrical energy"
+  ],
+  [
+    "Enhanced weathering - Basalt mineral",
+    "Non-arable land"
+  ],
+  [
+    "Enhanced weathering - Basalt mineral",
+    "Unspecified water"
+  ],
+  [
+    "Enhanced weathering - Olivine mineral",
+    "Arable land"
+  ],
+  [
+    "Enhanced weathering - Olivine mineral",
+    "Electrical energy"
+  ],
+  [
+    "Enhanced weathering - Olivine mineral",
+    "Non-arable land"
+  ],
+  [
+    "Enhanced weathering - Olivine mineral",
+    "Unspecified water"
+  ],
+  [
+    "Enhanced weathering - Unspecified mineral",
+    "Arable land"
+  ],
+  [
+    "Enhanced weathering - Unspecified mineral",
+    "Electrical energy"
+  ],
+  [
+    "Enhanced weathering - Unspecified mineral",
+    "Non-arable land"
+  ],
+  [
+    "Enhanced weathering - Unspecified mineral",
+    "Unspecified water"
+  ],
+  [
+    "Enhanced weathering - Wollastonite mineral",
+    "Arable land"
+  ],
+  [
+    "Enhanced weathering - Wollastonite mineral",
+    "Electrical energy"
+  ],
+  [
+    "Enhanced weathering - Wollastonite mineral",
+    "Non-arable land"
+  ],
+  [
+    "Enhanced weathering - Wollastonite mineral",
+    "Unspecified water"
+  ],
+  [
+    "High-temp DACCS (solid-sorbent/liquid-solvent)",
+    "Unspecified water"
+  ],
+  [
+    "Low-temp DACCS (solid-sorbent/liquid-solvent)",
+    "Unspecified water"
+  ],
+  [
+    "Mineral OAE / Ocean liming",
+    "Electrical energy"
+  ],
+  [
+    "Mineral OAE / Ocean liming",
+    "Non-arable land"
+  ],
+  [
+    "Mineral OAE / Ocean liming",
+    "Thermal energy unspecified grade"
+  ],
+  [
+    "Mineral OAE / Ocean liming",
+    "Unspecified water"
+  ],
+  [
+    "Mineral looping DACCS",
+    "Unspecified water"
+  ],
+  [
+    "Reforestation",
+    "Unspecified water"
+  ]
+]

data/update.py

@@ -0,0 +1,51 @@
+"""
+Run this script after any change to inputs_aggregated.csv to update all
+generated data files and Excel templates.
+
+Usage:
+    python data/update.py
+"""
+import hashlib
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).parent.parent
+PYTHON = sys.executable
+
+scripts = [
+    ("Coefficients + method groups + secondary resources", "data/generate_model_data.py"),
+    ("Input template (inputs_template.xlsx)", "data/generate_input_template.py"),
+    ("Resource template (resource_template.xlsx)", "data/generate_resource_template.py"),
+]
+
+print("=" * 60)
+print("CRRA Optimization Tool — data update")
+print("=" * 60)
+
+for label, script in scripts:
+    print(f"\n▶ {label}")
+    result = subprocess.run(
+        [PYTHON, str(ROOT / script)],
+        cwd=str(ROOT),
+        capture_output=True,
+        text=True,
+    )
+    for line in result.stdout.splitlines():
+        print(f"  {line}")
+    if result.returncode != 0:
+        print(f"  ERROR:\n{result.stderr}")
+        sys.exit(result.returncode)
+
+print("\n" + "=" * 60)
+print("All files updated successfully.")
+print("=" * 60)
+
+# Update the hash file so the app knows the CSV is in sync
+csv_path = ROOT / "data/inputs_aggregated.csv"
+hash_path = ROOT / "data/.csv_hash"
+hasher = hashlib.md5()
+with open(csv_path, "rb") as f:
+    hasher.update(f.read())
+with open(hash_path, "w") as f:
+    f.write(hasher.hexdigest())

data/update_cost_sliders_with_priority.py

@@ -1,32 +0,0 @@
-import json
-
-import pandas as pd
-
-# === Load JSON data ===
-with open("cost_sliders.json", "r") as f:
-    cost_sliders = json.load(f)
-
-# === Load resource priority CSV ===
-df_priority = pd.read_csv("resource_priority.csv")
-
-# === Validate columns ===
-required_cols = {"method", "resource", "priority"}
-if not required_cols.issubset(df_priority.columns):
-    raise ValueError(f"CSV must contain the columns: {required_cols}")
-
-# === Update the JSON structure ===
-for _, row in df_priority.iterrows():
-    method = row["method"]
-    resource = row["resource"]
-    priority = row["priority"]
-
-    if method in cost_sliders and resource in cost_sliders[method]:
-        cost_sliders[method][resource]["priority"] = priority
-    else:
-        print(f"⚠️ Warning: ({method} / {resource}) not found in JSON.")
-
-# === Save the updated JSON ===
-with open("cost_sliders_with_priority.json", "w") as f:
-    json.dump(cost_sliders, f, indent=2)
-
-print("✅ Updated JSON saved to cost_sliders_with_priority.json")

optimization/optimization.py

@@ -2,161 +2,225 @@ import numpy as np
 from scipy.optimize import linprog
 
 
-def run_optimization(
-    resource_caps,
-    method_constraints,
-    method_costs,
-    custom_resources=None,
-    enabled_methods=None,
-):
-    """
-    Maximize total CO₂ removal subject to resource caps and method constraints.
+def apply_enabled_methods(method_costs, enabled_methods):
+    """Return a copy of method_costs with coefficients zeroed for disabled (method, resource) pairs.
 
-    LP variables:
-      y_m    = CO₂ removed by method m  (indices 0..M-1)
-      z_{m,n} = CO₂ drawn from custom batch n by method m  (indices M..N-1)
-    """
-
-    resource_caps = dict(resource_caps)
-    method_costs  = {m: dict(v) for m, v in method_costs.items()}
-    print("first enabled_methods ----------- ")
+    Args:
+        method_costs (dict): {method: {resource: coefficient}}.
+        enabled_methods (dict): {resource: {method: bool}} — False entries disable the coefficient.
 
-    # ── Apply manual allocation overrides ─────────────────────────────────────
+    Returns:
+        dict: deep copy of method_costs with disabled coefficients set to 0.0.
+    """
+    result = {m: dict(v) for m, v in method_costs.items()}
     enabled_methods = enabled_methods or {}
-    print(enabled_methods)
-    for method, resources in method_costs.items():
+    for method, resources in result.items():
         for resource in list(resources):
             if not enabled_methods.get(resource, {}).get(method, True):
-                method_costs[method][resource] = 0.0
+                result[method][resource] = 0.0
+    return result
+
+
+def build_custom_batch_structures(method_costs, resource_caps, custom_resources):
+    """Build the custom-batch index structures and inject fallback coefficients.
+
+    Mutates method_costs (adds fallback median coefficients) and resource_caps
+    (adds batch caps that are not yet present). Both dicts are already copies
+    when this function is called from run_optimization.
+
+    Args:
+        method_costs (dict): {method: {resource: coefficient}} — mutated in place.
+        resource_caps (dict): {resource: cap} — mutated in place.
+        custom_resources (list | None): list of custom batch dicts with keys
+                                        name, group, amount, methods.
 
-    # ── Custom batch metadata ─────────────────────────────────────────────────
-    custom_batch_info = {}
+    Returns:
+        tuple[dict, dict, set]:
+            custom_batch_specs       – {batch_name: {group, amount, primary_methods}}.
+            group_to_custom_batches  – {reference_resource: [batch_name, ...]}.
+            custom_batch_names       – set of all batch names.
+    """
+    custom_batch_specs = {}
     for batch in (custom_resources or []):
-        custom_batch_info[batch["name"]] = {
+        custom_batch_specs[batch["name"]] = {
             "group":           batch["group"],
             "amount":          float(batch["amount"]),
             "primary_methods": set(batch.get("methods", {}).keys()),
         }
-    custom_names   = set(custom_batch_info)
-    ref_to_batches = {}
-    for bname, info in custom_batch_info.items():
-        ref_to_batches.setdefault(info["group"], []).append(bname)
-        if bname not in resource_caps:
-            resource_caps[bname] = info["amount"]
-
-    # ── Inject primary batch coefficients (fallback: use batch median if coef=0)
-    for batch in (custom_resources or []):
-        bname = batch["name"]
-        for method, coefs in batch["methods"].items():
-            if method_costs.get(method, {}).get(bname, 0.0) == 0.0:
-                method_costs.setdefault(method, {})[bname] = coefs["median"]
 
-    # ── Debug custom resources ────────────────────────────────────────────────
-    print(f"\n{'='*50}")
-    print(f"custom_resources received: {len(custom_resources or [])} batch(es)")
-    for batch in (custom_resources or []):
-        r_key = batch["name"]
-        print(f"  → '{r_key}' | amount: {resource_caps.get(r_key)} | methods: {list(batch['methods'].keys())}")
-        for method in batch["methods"]:
-            coef = method_costs.get(method, {}).get(r_key)
-            print(f"      method_costs['{method}']['{r_key}'] = {coef}")
-    print(method_costs)
-    print(f"Total resources in matrix: {len(resource_caps)}")
-    print(f"Total resources in matrix: {resource_caps}")
-    print(f"Resources: {list(resource_caps.keys())}")
-    print(f"{'='*50}\n")
-
-    # ── Active methods ────────────────────────────────────────────────────────
-    methods    = [m for m in method_costs if method_constraints.get(m, {}).get("active", True)]
-    M          = len(methods)
-    method_idx = {m: j for j, m in enumerate(methods)}
-    if not M:
-        return False, {"message": "No active methods."}
+    custom_batch_names = set(custom_batch_specs)
+    group_to_custom_batches = {}
+    for batch_name, specs in custom_batch_specs.items():
+        group_to_custom_batches.setdefault(specs["group"], []).append(batch_name)
+        if batch_name not in resource_caps:
+            resource_caps[batch_name] = specs["amount"]
 
-    # ── Split variables z_{m,n} ───────────────────────────────────────────────
-    z_pairs = []
-    for bname, info in custom_batch_info.items():
-        ref             = info["group"]
-        primary_methods = info["primary_methods"]
-        if resource_caps.get(bname, 0.0) <= 0:
+    # Fallback: use batch median coefficient if method has none
+    for batch in (custom_resources or []):
+        batch_name = batch["name"]
+        for method, coefs in batch["methods"].items():
+            if method_costs.get(method, {}).get(batch_name, 0.0) == 0.0:
+                method_costs.setdefault(method, {})[batch_name] = coefs["median"]
+
+    return custom_batch_specs, group_to_custom_batches, custom_batch_names
+
+
+def build_lp_indices(active_methods, num_methods, custom_batch_specs, resource_caps, method_costs):
+    """Build the LP variable index for custom-batch draw variables z_{m,n}.
+
+    When the user adds a custom resource batch (e.g. "degraded land patch A"),
+    the solver needs to track separately how much of each CDR method's output
+    comes from that specific batch vs. the standard resource pool.
+    These "draw variables" z_{m,n} represent:
+        z_{m,n} = amount of CO₂ method m produces using custom batch n.
+    They sit alongside the main y_m variables in the LP column vector.
+
+    Args:
+        active_methods (list[str]): ordered list of active CDR method names.
+        num_methods (int): len(active_methods) — index offset for z variables.
+        custom_batch_specs (dict): {batch_name: {group, amount, primary_methods}}.
+        resource_caps (dict): {resource: cap} — used to skip zero-cap batches.
+        method_costs (dict): {method: {resource: coefficient}}.
+
+    Returns:
+        tuple[list, dict, int]:
+            custom_usage_pairs   – [(method, batch_name)] with non-zero coefficient.
+            custom_pair_to_index – {(method, batch_name): lp_column_index}.
+            num_lp_vars          – total number of LP variables.
+    """
+    custom_usage_pairs = []
+    for batch_name, specs in custom_batch_specs.items():
+        primary_methods = specs["primary_methods"]
+        if resource_caps.get(batch_name, 0.0) <= 0:
             continue
-        for m in methods:
+        for m in active_methods:
             if m not in primary_methods:
                 continue
-            c_n = method_costs.get(m, {}).get(bname, 0.0)
-            if c_n > 0:
-                z_pairs.append((m, bname))
+            if method_costs.get(m, {}).get(batch_name, 0.0) > 0:
+                custom_usage_pairs.append((m, batch_name))
 
-    Z     = len(z_pairs)
-    z_idx = {pair: M + i for i, pair in enumerate(z_pairs)}
-    N     = M + Z
+    custom_pair_to_index = {pair: num_methods + i for i, pair in enumerate(custom_usage_pairs)}
+    num_lp_vars = num_methods + len(custom_usage_pairs)
+    return custom_usage_pairs, custom_pair_to_index, num_lp_vars
 
-    print(f"z_pairs ({Z}): {z_pairs}")
 
-    # ── Resource categorisation ───────────────────────────────────────────────
-    standard_resources     = [r for r in resource_caps if r not in custom_names]
-    resources_with_batches = [r for r in standard_resources if r in ref_to_batches]
-    resources_no_batches   = [r for r in standard_resources if r not in ref_to_batches]
-
-    # ── Build LP constraint matrix ────────────────────────────────────────────
+def build_constraint_matrix(
+    active_methods, method_to_index, num_lp_vars, num_methods,
+    resource_caps, method_costs, method_constraints,
+    custom_batch_specs, group_to_custom_batches,
+    resources_no_batches, resources_with_batches,
+    custom_usage_pairs, custom_pair_to_index,
+):
+    """Assemble the LP inequality constraint matrix (A_ub · x ≤ b_ub).
+
+    Builds five groups of constraints:
+      A – standard resources with no custom substitutes.
+      B – standard resources that have custom-batch substitutes.
+      C – custom batch capacity limits.
+      D1/D2 – coupling constraints between y_m and z_{m,n}.
+      E – per-method output caps (percent or absolute).
+
+    Args:
+        active_methods (list[str]): ordered active CDR method names.
+        method_to_index (dict): {method: lp_column_index}.
+        num_lp_vars (int): total LP variable count.
+        num_methods (int): number of y_m variables.
+        resource_caps (dict): {resource: cap}.
+        method_costs (dict): {method: {resource: coefficient}}.
+        method_constraints (dict): {method: {cap_type, cap_value}}.
+        custom_batch_specs (dict): {batch_name: {group, amount, primary_methods}}.
+        group_to_custom_batches (dict): {reference_resource: [batch_name]}.
+        resources_no_batches (list[str]): standard resources without substitutes.
+        resources_with_batches (list[str]): standard resources that have substitutes.
+        custom_usage_pairs (list): [(method, batch_name)].
+        custom_pair_to_index (dict): {(method, batch_name): lp_column_index}.
+
+    Returns:
+        tuple[np.ndarray, np.ndarray, list]:
+            A_ub               – constraint coefficient matrix.
+            b_ub               – constraint right-hand-side vector.
+            constraint_labels  – list of (type_str, identifier) per row.
+    """
     A_rows, b_rows, constraint_labels = [], [], []
 
-    # (A) Standard resources — no custom substitutes
+    # ── CONSTRAINT GROUPS ─────────────────────────────────────────────────────
+    # Each group adds one row per resource/method to the matrix A_ub.
+    # The solver will find the y_m values that maximise total CO₂ removal while
+    # keeping every A_ub · x ≤ b_ub inequality satisfied.
+    #
+    # Plain-English summary of each group:
+    #   A – "Don't use more of a standard resource than is available."
+    #   B – "Same, but subtract the part already covered by custom batches."
+    #   C – "Each custom batch can only supply up to its declared quantity."
+    #   D – "Book-keeping: custom-batch draw variables can't exceed the method's
+    #        total output, and if a method has no standard resource it must draw
+    #        entirely from custom batches."
+    #   E – "Respect each method's user-defined cap (% or absolute MtCO₂/yr)."
+    # ─────────────────────────────────────────────────────────────────────────
+
+    # (A) Standard resources — no custom substitutes.
+    # Rule: total resource consumed across all methods ≤ available amount.
     for r in resources_no_batches:
-        row = np.zeros(N)
-        for j, m in enumerate(methods):
+        row = np.zeros(num_lp_vars)
+        for j, m in enumerate(active_methods):
             row[j] = method_costs.get(m, {}).get(r, 0.0)
-        if np.any(row[:M] != 0):
+        if np.any(row[:num_methods] != 0):
             A_rows.append(row)
             b_rows.append(resource_caps[r])
             constraint_labels.append(("resource", r))
 
-    # (B) Standard resources — with custom substitutes (subtract z contribution)
-    # Σ_m cost(m,r) · (y_m − Σ_n z_{m,n}) ≤ cap(r)
+    # (B) Standard resources that have custom-batch substitutes.
+    # Rule: only the portion of the resource NOT already covered by custom batches
+    # counts against the standard pool cap. Formula: Σ cost(m,r)·(y_m − Σ z_{m,n}) ≤ cap(r)
     for r in resources_with_batches:
-        row = np.zeros(N)
-        for j, m in enumerate(methods):
-            c_s_m = method_costs.get(m, {}).get(r, 0.0)
+        row = np.zeros(num_lp_vars)
+        for j, m in enumerate(active_methods):
+            c_s_m = method_costs.get(m, {}).get(r, 0.0)   # coefficient for standard resource r
             row[j] = c_s_m
-            for bname in ref_to_batches.get(r, []):
-                if (m, bname) in z_idx:
-                    row[z_idx[(m, bname)]] -= c_s_m
+            for batch_name in group_to_custom_batches.get(r, []):
+                if (m, batch_name) in custom_pair_to_index:
+                    row[custom_pair_to_index[(m, batch_name)]] -= c_s_m   # subtract batch draw
         if np.any(row != 0):
             A_rows.append(row)
             b_rows.append(resource_caps[r])
             constraint_labels.append(("resource", r))
 
-    # (C) Custom batch capacity: Σ_m cost(m,n) · z_{m,n} ≤ Q_n
-    for bname, info in custom_batch_info.items():
-        if resource_caps.get(bname, 0.0) <= 0:
+    # (C) Custom batch capacity.
+    # Rule: total resource drawn from this specific batch ≤ batch quantity Q_n.
+    for batch_name, specs in custom_batch_specs.items():
+        if resource_caps.get(batch_name, 0.0) <= 0:
             continue
-        row = np.zeros(N)
-        for j, m in enumerate(methods):
-            if (m, bname) not in z_idx:
+        row = np.zeros(num_lp_vars)
+        for j, m in enumerate(active_methods):
+            if (m, batch_name) not in custom_pair_to_index:
                 continue
-            c_n_m = method_costs.get(m, {}).get(bname, 0.0)
+            c_n_m = method_costs.get(m, {}).get(batch_name, 0.0)   # coefficient for batch n
             if c_n_m > 0:
-                row[z_idx[(m, bname)]] = c_n_m
+                row[custom_pair_to_index[(m, batch_name)]] = c_n_m
         if np.any(row != 0):
             A_rows.append(row)
-            b_rows.append(resource_caps.get(bname, 0.0))
-            constraint_labels.append(("custom_batch", bname))
+            b_rows.append(resource_caps.get(batch_name, 0.0))
+            constraint_labels.append(("custom_batch", batch_name))
 
-    # (D1) Σ z_{m,n} ≤ y_m  — keeps standard resource usage non-negative
-    # (D2) y_m ≤ Σ z_{m,n}  — only when c_s=0: entire output must come from batch
-    #      D1 + D2 together force y_m = Σz when the standard resource is unavailable
+    # (D) Coupling constraints — link z_{m,n} draw variables to y_m output.
+    # D1: Σ z_{m,n} ≤ y_m  — can't draw more from batches than the method produces.
+    # D2: y_m ≤ Σ z_{m,n}  — only added when the method has no standard resource (c_s=0),
+    #     which forces the method to source 100 % of its output from custom batches.
     coupling_done = set()
-    for (m, bname) in z_pairs:
-        ref = custom_batch_info[bname]["group"]
+    for (m, batch_name) in custom_usage_pairs:
+        ref = custom_batch_specs[batch_name]["group"]
         key = (m, ref)
         if key in coupling_done:
             continue
         coupling_done.add(key)
-        j     = method_idx[m]
+        j     = method_to_index[m]
         c_s_m = method_costs.get(m, {}).get(ref, 0.0)
-        batch_cols = [z_idx[(m, bn)] for bn in ref_to_batches.get(ref, []) if (m, bn) in z_idx]
-
-        row = np.zeros(N)
+        batch_cols = [
+            custom_pair_to_index[(m, sibling)]
+            for sibling in group_to_custom_batches.get(ref, [])
+            if (m, sibling) in custom_pair_to_index
+        ]
+        row = np.zeros(num_lp_vars)
         row[j] = -1.0
         for col in batch_cols:
             row[col] = 1.0
@@ -165,7 +229,7 @@ def run_optimization(
         constraint_labels.append(("coupling_D1", (m, ref)))
 
         if c_s_m == 0:
-            row2 = np.zeros(N)
+            row2 = np.zeros(num_lp_vars)
             row2[j] = 1.0
             for col in batch_cols:
                 row2[col] = -1.0
@@ -173,103 +237,245 @@ def run_optimization(
             b_rows.append(0.0)
             constraint_labels.append(("coupling_D2", (m, ref)))
 
-    # (E) Method caps
-    for j, m in enumerate(methods):
+    # (E) Method output caps — respect the user's per-method limits from Tab 2.
+    # Absolute cap: y_m ≤ cap_value (in MtCO₂/yr).
+    # Percent cap:  y_m ≤ cap_ratio · Σ y_all  (fraction of total portfolio output).
+    for j, m in enumerate(active_methods):
         constraint = method_constraints.get(m, {})
         cap_type   = constraint.get("cap_type",  "percent")
         cap_value  = constraint.get("cap_value", 100)
         if cap_type == "absolute":
-            row     = np.zeros(N)
-            row[j]  = 1.0
+            row    = np.zeros(num_lp_vars)
+            row[j] = 1.0
             A_rows.append(row)
             b_rows.append(cap_value)
             constraint_labels.append(("method_cap", m))
         else:
-            cap_ratio  = cap_value / 100.0
-            row        = np.zeros(N)
-            row[:M]   -= cap_ratio
-            row[j]    += 1.0
+            cap_ratio = cap_value / 100.0
+            row = np.zeros(num_lp_vars)
+            row[:num_methods] -= cap_ratio
+            row[j]            += 1.0
             A_rows.append(row)
             b_rows.append(0.0)
             constraint_labels.append(("method_cap", m))
 
-    A_ub = np.array(A_rows) if A_rows else np.empty((0, N))
+    A_ub = np.array(A_rows) if A_rows else np.empty((0, num_lp_vars))
     b_ub = np.array(b_rows)
+    return A_ub, b_ub, constraint_labels
+
+
+def extract_resource_usage(
+    active_methods, num_methods, method_outputs, lp_solution, method_costs,
+    resource_caps, custom_batch_specs, group_to_custom_batches,
+    custom_pair_to_index, standard_resources,
+    resources_no_batches, resources_with_batches, custom_batch_names,
+):
+    """Compute per-method resource consumption from the LP solution.
+
+    Args:
+        active_methods (list[str]): ordered active CDR method names.
+        num_methods (int): number of y_m variables.
+        method_outputs (np.ndarray): y_m values from LP solution (length num_methods).
+        lp_solution (np.ndarray): full LP solution vector x.
+        method_costs (dict): {method: {resource: coefficient}}.
+        resource_caps (dict): {resource: cap} — used for resource_remaining.
+        custom_batch_specs (dict): {batch_name: {group, amount, primary_methods}}.
+        group_to_custom_batches (dict): {reference_resource: [batch_name]}.
+        custom_pair_to_index (dict): {(method, batch_name): lp_column_index}.
+        standard_resources (list[str]): all non-batch resource names.
+        resources_no_batches (list[str]): standard resources without substitutes.
+        resources_with_batches (list[str]): standard resources with substitutes.
+        custom_batch_names (set[str]): set of all custom batch names.
+
+    Returns:
+        tuple[dict, dict, dict]:
+            resource_usage       – {resource: {method: qty_used}}.
+            resource_used_total  – {resource: total_qty_used}.
+            resource_remaining   – {resource: qty_remaining}.
+    """
+    all_resource_names = standard_resources + list(custom_batch_names)
+    resource_usage = {r: {} for r in all_resource_names}
+
+    # 1e-9 is a near-zero threshold: LP solvers return tiny floating-point residuals
+    # (e.g. 0.000000001) instead of exact 0. Values below this threshold are treated
+    # as zero so they don't appear as spurious resource usage in the output.
+    for r in resources_no_batches:
+        for j, m in enumerate(active_methods):
+            used = method_costs.get(m, {}).get(r, 0.0) * method_outputs[j]
+            if used > 1e-9:
+                resource_usage[r][m] = float(used)
+
+    for r in resources_with_batches:
+        for j, m in enumerate(active_methods):
+            c_s_m = method_costs.get(m, {}).get(r, 0.0)
+            z_sum = sum(
+                lp_solution[custom_pair_to_index[(m, batch_name)]]
+                for batch_name in group_to_custom_batches.get(r, [])
+                if (m, batch_name) in custom_pair_to_index
+            )
+            used = c_s_m * (method_outputs[j] - z_sum)
+            if used > 1e-9:
+                resource_usage[r][m] = float(used)
+
+    for batch_name, specs in custom_batch_specs.items():
+        primary_methods = specs["primary_methods"]
+        for j, m in enumerate(active_methods):
+            if m not in primary_methods:
+                continue
+            c_n_m = method_costs.get(m, {}).get(batch_name, 0.0)
+            if c_n_m <= 0:
+                continue
+            used = (
+                c_n_m * lp_solution[custom_pair_to_index[(m, batch_name)]]
+                if (m, batch_name) in custom_pair_to_index
+                else 0.0
+            )
+            if used > 1e-9:
+                resource_usage[batch_name][m] = float(used)
+
+    resource_used_total = {r: sum(v.values()) for r, v in resource_usage.items()}
+    all_caps = {
+        **resource_caps,
+        **{batch_name: specs["amount"] for batch_name, specs in custom_batch_specs.items()},
+    }
+    resource_remaining = {
+        r: all_caps.get(r, 0.0) - resource_used_total.get(r, 0.0)
+        for r in all_caps
+    }
+    return resource_usage, resource_used_total, resource_remaining
+
+
+def run_perturbation(constraint_labels, A_ub, b_ub, objective_coefficients, bounds, num_methods, total_removed):
+    """Compute marginal CDR gain per unit for each binding resource constraint.
+
+    Re-solves the LP with each resource constraint right-hand side increased by 1
+    to measure the actual CO₂ gain that one extra unit would unlock.
+
+    Args:
+        constraint_labels (list): list of (type_str, identifier) per constraint row.
+        A_ub (np.ndarray): LP constraint coefficient matrix.
+        b_ub (np.ndarray): LP constraint right-hand-side vector.
+        objective_coefficients (np.ndarray): LP objective vector.
+        bounds (list): variable bounds for linprog.
+        num_methods (int): number of y_m variables (for summing total removed).
+        total_removed (float): baseline total CO₂ removed.
+
+    Returns:
+        dict: {resource_or_batch_name: CDR_gain_for_plus_1_unit (float)}.
+    """
+    resource_actual_gain = {}
+    for i, (ctype, cid) in enumerate(constraint_labels):
+        if ctype not in ("resource", "custom_batch"):
+            continue
+        b_perturbed = b_ub.copy()
+        b_perturbed[i] += 1.0
+        try:
+            perturbed = linprog(
+                objective_coefficients, A_ub=A_ub, b_ub=b_perturbed, bounds=bounds, method="highs"
+            )
+            if perturbed.success:
+                new_total = float(perturbed.x[:num_methods].sum())
+                resource_actual_gain[cid] = max(new_total - total_removed, 0.0)
+        except Exception:
+            pass
+    return resource_actual_gain
+
+
+def run_optimization(
+    resource_caps,
+    method_constraints,
+    method_costs,
+    custom_resources=None,
+    enabled_methods=None,
+):
+    """Maximize total CO₂ removal subject to resource caps and method constraints.
+
+    Solves a linear programme (HiGHS solver via scipy.optimize.linprog).
+    Also runs a perturbation analysis: for each binding resource constraint,
+    re-solves with cap + 1 to compute the marginal CDR gain per unit.
+
+    LP variables (two types, packed into one vector x):
+      y_m     = MtCO₂ removed by CDR method m — the main "answer" (indices 0..num_methods-1).
+      z_{m,n} = MtCO₂ that method m draws specifically from custom batch n — a helper
+                variable introduced when the user adds a custom resource batch; it lets the
+                solver track which batch supplies which method without double-counting
+                (indices num_methods..num_lp_vars-1).
+
+    Args:
+        resource_caps (dict): {resource: available amount (float)}.
+        method_constraints (dict): {method: {active (bool), cap_type (str), cap_value (float)}}.
+        method_costs (dict): {method: {resource: coefficient (float)}}.
+        custom_resources (list | None): list of custom batch dicts with keys
+                                         name, group, amount, methods.
+        enabled_methods (dict | None): {resource: {method: bool}} — False entries
+                                        zero-out the corresponding coefficient before solving.
+
+    Returns:
+        tuple[bool, dict]:
+            (True, result) on success, where result contains:
+                total_removed (float), method_usage (dict), resource_usage (dict),
+                resource_used_total (dict), resource_remaining (dict),
+                resource_actual_gain (dict).
+            (False, {"message": str}) on failure.
+    """
+    resource_caps = dict(resource_caps)
+    method_costs  = apply_enabled_methods(method_costs, enabled_methods)
+
+    custom_batch_specs, group_to_custom_batches, custom_batch_names = build_custom_batch_structures(
+        method_costs, resource_caps, custom_resources
+    )
+
+    active_methods  = [m for m in method_costs if method_constraints.get(m, {}).get("active", True)]
+    num_methods     = len(active_methods)
+    method_to_index = {m: j for j, m in enumerate(active_methods)}
+    if not num_methods:
+        return False, {"message": "No active methods."}
+
+    custom_usage_pairs, custom_pair_to_index, num_lp_vars = build_lp_indices(
+        active_methods, num_methods, custom_batch_specs, resource_caps, method_costs
+    )
+
+    standard_resources     = [r for r in resource_caps if r not in custom_batch_names]
+    resources_with_batches = [r for r in standard_resources if r in group_to_custom_batches]
+    resources_no_batches   = [r for r in standard_resources if r not in group_to_custom_batches]
+
+    A_ub, b_ub, constraint_labels = build_constraint_matrix(
+        active_methods, method_to_index, num_lp_vars, num_methods,
+        resource_caps, method_costs, method_constraints,
+        custom_batch_specs, group_to_custom_batches,
+        resources_no_batches, resources_with_batches,
+        custom_usage_pairs, custom_pair_to_index,
+    )
 
-    # Objective: maximize Σ y_m  →  minimize −Σ y_m
-    c_obj         = np.zeros(N)
-    c_obj[:M]     = -1.0
-    bounds        = [(0, None)] * N
+    # linprog minimises by convention, so we negate the objective to maximise Σ y_m.
+    objective_coefficients = np.zeros(num_lp_vars)
+    objective_coefficients[:num_methods] = -1.0   # only y_m variables enter the objective
+    bounds = [(0, None)] * num_lp_vars             # all variables must be ≥ 0
 
-    # ── Solve ─────────────────────────────────────────────────────────────────
     try:
-        result = linprog(c_obj, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method="highs")
+        result = linprog(objective_coefficients, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method="highs")
         if not result.success:
             return False, {"message": result.message}
 
-        sol = result.x
-        y   = sol[:M]
-
-        total_removed = float(y.sum())
-        method_usage  = {methods[j]: float(y[j]) for j in range(M) if y[j] > 1e-9}
-
-        # ── Resource usage ────────────────────────────────────────────────────
-        all_resource_names = standard_resources + list(custom_names)
-        resource_usage     = {r: {} for r in all_resource_names}
-
-        for r in resources_no_batches:
-            for j, m in enumerate(methods):
-                used = method_costs.get(m, {}).get(r, 0.0) * y[j]
-                if used > 1e-9:
-                    resource_usage[r][m] = float(used)
-
-        for r in resources_with_batches:
-            for j, m in enumerate(methods):
-                c_s_m = method_costs.get(m, {}).get(r, 0.0)
-                z_sum = sum(
-                    sol[z_idx[(m, bn)]]
-                    for bn in ref_to_batches.get(r, [])
-                    if (m, bn) in z_idx
-                )
-                used = c_s_m * (y[j] - z_sum)
-                if used > 1e-9:
-                    resource_usage[r][m] = float(used)
-
-        for bname, info in custom_batch_info.items():
-            primary_methods = info["primary_methods"]
-            for j, m in enumerate(methods):
-                if m not in primary_methods:
-                    continue
-                c_n_m = method_costs.get(m, {}).get(bname, 0.0)
-                if c_n_m <= 0:
-                    continue
-                used = c_n_m * sol[z_idx[(m, bname)]] if (m, bname) in z_idx else 0.0
-                if used > 1e-9:
-                    resource_usage[bname][m] = float(used)
-
-        resource_used_total = {r: sum(v.values()) for r, v in resource_usage.items()}
-
-        all_caps           = {**resource_caps,
-                              **{bn: info["amount"] for bn, info in custom_batch_info.items()}}
-        resource_remaining = {r: all_caps.get(r, 0.0) - resource_used_total.get(r, 0.0)
-                              for r in all_caps}
-
-        # ── Perturbation analysis: marginal CO₂ gain per +1 unit of each resource
-        resource_actual_gain = {}
-        for i, (ctype, cid) in enumerate(constraint_labels):
-            if ctype not in ("resource", "custom_batch"):
-                continue
-            b_perturbed = b_ub.copy()
-            b_perturbed[i] += 1.0
-            try:
-                perturbed = linprog(
-                    c_obj, A_ub=A_ub, b_ub=b_perturbed, bounds=bounds, method="highs"
-                )
-                if perturbed.success:
-                    new_total = float(perturbed.x[:M].sum())
-                    resource_actual_gain[cid] = max(new_total - total_removed, 0.0)
-            except Exception:
-                pass
+        lp_solution    = result.x
+        method_outputs = lp_solution[:num_methods]
+        total_removed  = float(method_outputs.sum())
+        method_usage   = {
+            active_methods[j]: float(method_outputs[j])
+            for j in range(num_methods) if method_outputs[j] > 1e-9
+        }
+
+        resource_usage, resource_used_total, resource_remaining = extract_resource_usage(
+            active_methods, num_methods, method_outputs, lp_solution, method_costs,
+            resource_caps, custom_batch_specs, group_to_custom_batches,
+            custom_pair_to_index, standard_resources,
+            resources_no_batches, resources_with_batches, custom_batch_names,
+        )
+
+        resource_actual_gain = run_perturbation(
+            constraint_labels, A_ub, b_ub, objective_coefficients, bounds,
+            num_methods, total_removed,
+        )
 
         return True, {
             "total_removed":        total_removed,
@@ -281,4 +487,4 @@ def run_optimization(
         }
 
     except Exception as e:
-        return False, {"message": str(e)}
+        return False, {"message": str(e)}

tabs/tab0_welcome.py

@@ -1,34 +1,43 @@
-import streamlit as st
-from config.config import CO2_UNIT
-
-def render_tab():
-    st.markdown(f"""
-    <div class='custom-corps'>
-
-    This tool helps you optimize your carbon direct removal portfolio by adjusting resource usage and constraints.
-
-    <h3 class="wt wt-1">Required:</h3>
-    <ol>
-        <li><b>Resource inputs</b>: provide the total available quantities of resources for 1 year.</li>
-    </ol>
-
-    <h3 class="wt wt-2">Optional:</h3>
-    <ol start="2">
-        <li><b>Method constraints</b>: select which carbon removal methods are active and set their <b>maximum deployment cap</b> (as % of total potential or absolute value in {CO2_UNIT}/yr).</li>
-        <li><b>Resource efficiency coefficients</b>: adjust the resource usage for each method.</li>
-    </ol>
-
-    <h3 class="wt wt-3">Outputs:</h3>
-    <ol start="4">
-        <li><b>Portfolio generation</b>: run the optimization to find the best portfolio: how much CO₂ is removed, what methods are used, and in what proportions.</li>
-    </ol>
-
-    <h3 class="wt wt-4">Explore:</h3>
-    <ol start="5">
-        <li><b>Sensitivity analysis</b>: analyze how changes in method caps or resource availability affect the portfolio.</li>
-        <li><b>Scenario comparison</b>: compare different scenarios based on the optimization results.</li>
-    </ol>
-
-    Let’s get started! Use the side tabs to navigate through the sections.
-    </div>
+import streamlit as st
+from config.config import CO2_UNIT
+from utils.ui_helpers import show_bar
+
+def render_tab():
+    """Render the Welcome tab with a step-by-step guide to using the tool.
+
+    Returns:
+        None
+    """
+    st.markdown('<h1 class="crra-heading">Welcome!</h1>', unsafe_allow_html=True)
+    show_bar()
+
+    st.markdown(f"""
+    <div class='custom-corps'>
+
+    This tool helps you optimize your carbon direct removal portfolio by adjusting resource usage and constraints.
+
+    <h3 class="wt wt-1">Required:</h3>
+    <ol>
+        <li><b>Resource inputs</b>: provide the total available quantities of resources for 1 year.</li>
+    </ol>
+
+    <h3 class="wt wt-2">Optional:</h3>
+    <ol start="2">
+        <li><b>Method constraints</b>: select which carbon removal methods are active and set their <b>maximum deployment cap</b> (as % of total potential or absolute value in {CO2_UNIT}/yr).</li>
+        <li><b>Resource efficiency coefficients</b>: adjust the resource usage for each method.</li>
+    </ol>
+
+    <h3 class="wt wt-3">Outputs:</h3>
+    <ol start="4">
+        <li><b>Portfolio generation</b>: run the optimization to find the best portfolio: how much CO₂ is removed, what methods are used, and in what proportions.</li>
+    </ol>
+
+    <h3 class="wt wt-4">Explore:</h3>
+    <ol start="5">
+        <li><b>Sensitivity analysis</b>: analyze how changes in method caps or resource availability affect the portfolio.</li>
+        <li><b>Scenario comparison</b>: compare different scenarios based on the optimization results.</li>
+    </ol>
+
+    Let’s get started! Use the side tabs to navigate through the sections.
+    </div>
     """, unsafe_allow_html=True)

tabs/tab1_inputs.py

@@ -1,818 +1,869 @@
-import pandas as pd
-import streamlit as st
-
-from config.config import (resource_groups, resource_order, resource_tooltips,
-                           resource_unit_map, method_groups, CO2_UNIT, secondary_resources)
-from utils.data_utils import render_resource_input, strip_unit_suffix
-from utils.ui_helpers import show_bar
-from io import BytesIO
-
-# ─── Custom resource helpers ──────────────────────────────────────────────────
-
-def standard_resource_names():
-    return {r for rlist in resource_groups.values() for r in rlist}
-
-
-def init_custom_resources():
-    if "custom_resources" not in st.session_state:
-        st.session_state.custom_resources = []
-    if "enabled_methods" not in st.session_state:
-        st.session_state.enabled_methods = {}
-    if "auto_disabled_methods" not in st.session_state:
-        st.session_state.auto_disabled_methods = set()
-    for batch in st.session_state.custom_resources:
-        try:
-            batch["amount"] = float(batch["amount"])
-        except (ValueError, TypeError):
-            batch["amount"] = 0.0
-        for m, coefs in batch.get("methods", {}).items():
-            for key in ("min", "median", "max"):
-                try:
-                    coefs[key] = float(coefs[key])
-                except (ValueError, TypeError):
-                    coefs[key] = 0.0
-
-
-# ─── Dialog: add / edit a custom resource batch ───────────────────────────────
-
-@st.dialog("Add a new resource", width="large")
-def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, preset_resources: list | None = None):
-
-    if edit_index is not None and not st.session_state.get(f"_dlg_initialized_{edit_index}"):
-        for key in list(st.session_state.keys()):
-            if key.startswith(("_dlg_existing_enable_",
-                            "_dlg_existing_min_", "_dlg_existing_med_", "_dlg_existing_max_",
-                            "_dlg_new_chk_", "_dlg_new_min_", "_dlg_new_med_", "_dlg_new_max_")):
-                del st.session_state[key]
-        st.session_state[f"_dlg_initialized_{edit_index}"] = True
-
-    standard_names = standard_resource_names()
-    existing_names = {
-        b["name"] for i, b in enumerate(st.session_state.custom_resources)
-        if i != edit_index
-    }
-    existing = st.session_state.custom_resources[edit_index] if edit_index is not None else {}
-
-    resource_to_group = {
-        r: group
-        for group, resources in resource_groups.items()
-        for r in resources
-    }
-
-    # If opened from a specific resource-group expander ("+ Add resource" inline
-    # button), restrict the reference-resource choice to that group's resources
-    # only — the user picked the group by clicking that button.
-    group_options = preset_resources if preset_resources else resource_order
-    if preset_resources:
-        physical_group = resource_to_group.get(preset_resources[0], "")
-        st.markdown(
-            f'<p class="caption-input">Adding a new resource batch in the <strong>{physical_group}</strong> group.</p>',
-            unsafe_allow_html=True,
-        )
-
-    st.markdown('<p class="dialog-title">1 — Name & group</p>', unsafe_allow_html=True)
-
-    col_name, col_group = st.columns(2)
-    with col_name:
-        batch_name = st.text_input(
-            "Resource name *",
-            value=existing.get("name", ""),
-            placeholder="e.g. Degraded forest lands – North",
-            help="It can't match the name of an existing resource.",
-            key="label-input-name"
-        )
-    with col_group:
-        default_group_idx = group_options.index(existing["group"]) if existing.get("group") in group_options else 0
-        batch_group = st.selectbox(
-            "Resource group *",
-            options=group_options,
-            index=default_group_idx,
-            help="Determines the physical unit of this resource.",
-            disabled=bool(preset_resources) and len(group_options) == 1,
-            key="label-input-group"
-        )
-
-    group = resource_to_group.get(batch_group)
-    unit = resource_unit_map.get(group, "?")
-
-    st.markdown(f'<p class="caption">Unit for this group: <strong>{unit}</strong></p>', unsafe_allow_html=True)
-
-    st.markdown('<p class="dialog-title">2 — Available quantity</p>', unsafe_allow_html=True)
-
-    batch_amount = st.number_input(
-        f"Available amount ({unit})",
-        min_value=0.0,
-        format="%.2f",
-        value=float(existing["amount"]) if existing.get("amount") and existing.get("amount") != 0.0 else None,
-        help=f"Total quantity available for 1 year, in {unit}.",
-        key="label-input-amount",
-        placeholder="0.0"
-    )
-
-    st.markdown('<p class="dialog-title">3 — Existing CDR methods for this resource</p>', unsafe_allow_html=True)
-
-    method_configs = {}
-
-    # All methods linked to this resource (primary + secondary)
-    all_related_methods = {}
-    for cdr_method, resource in cost_sliders.items():
-        for name, coeff in resource.items():
-            if batch_group == strip_unit_suffix(name):
-                all_related_methods[cdr_method] = {
-                    "min": coeff["min"],
-                    "median": coeff["median"],
-                    "max": coeff["max"],
-                }
-
-    # Split into primary (selectable) and secondary (auto-linked in Tab 3)
-    primary_related = {
-        m: coeff for m, coeff in all_related_methods.items()
-        if (m, batch_group) not in secondary_resources
-    }
-    secondary_related = {
-        m: coeff for m, coeff in all_related_methods.items()
-        if (m, batch_group) in secondary_resources
-    }
-
-    # group_name -> primary methods only
-    primary_by_group = {}
-    for m, coeff in primary_related.items():
-        method_group = next(
-            (g for g, methods in method_groups.items() if m in methods),
-            "Other"
-        )
-        primary_by_group.setdefault(method_group, {})[m] = coeff
-
-    if not primary_by_group:
-        st.markdown('<p class="caption">No primary CDR methods use this resource directly.</p>', unsafe_allow_html=True)
-
-    for method_group, methods in primary_by_group.items():
-        with st.expander(f"**{method_group}**", expanded=False):
-            for m, coeff in methods.items():
-
-                already_selected = m in existing.get("methods", {})
-
-                if f"_dlg_existing_enable_{m}" not in st.session_state:
-                    st.session_state[f"_dlg_existing_enable_{m}"] = already_selected
-
-                enabled = st.checkbox(
-                    f"{m}",
-                    key=f"_dlg_existing_enable_{m}",
-                )
-
-                if not enabled:
-                    continue
-
-                existing_coeff = existing.get("methods", {}).get(m, coeff)
-
-                st.info("Modifying these values only affects this resource batch: the base method coefficients are unchanged.")
-                col_min, col_med, col_max = st.columns(3)
-                with col_min:
-                    e_min = st.number_input(
-                        f"Min ({unit}/{CO2_UNIT})",
-                        min_value=0.0,
-                        format="%.10g",
-                        value=float(existing_coeff["min"]),
-                        key=f"_dlg_existing_min_{m}",
-                    )
-                with col_med:
-                    e_med = st.number_input(
-                        f"Median ({unit}/{CO2_UNIT})",
-                        min_value=0.0,
-                        format="%.10g",
-                        value=float(existing_coeff["median"]),
-                        key=f"_dlg_existing_med_{m}",
-                    )
-                with col_max:
-                    e_max = st.number_input(
-                        f"Max ({unit}/{CO2_UNIT})",
-                        min_value=0.0,
-                        format="%.10g",
-                        value=float(existing_coeff["max"]),
-                        key=f"_dlg_existing_max_{m}",
-                    )
-                method_configs[m] = {
-                    "min": e_min,
-                    "median": e_med,
-                    "max": e_max,
-                }
-
-    if secondary_related:
-        names = "\n".join(f"- **{m}**" for m in secondary_related)
-        st.info(
-        f"""The following methods use this resource as **secondary** and may be assigned later in the **Resource Coefficients** tab:\n{names}
-        """,
-            icon="ℹ️",
-        )
-
-    # -------------------------------------------------
-    # Part 4 : new/custom methods only
-    # -------------------------------------------------
-
-    st.markdown('<p class="dialog-title">4 — Add additional CDR methods</p>', unsafe_allow_html=True)
-    st.markdown(f'<p class="caption">Select additional methods and enter their coefficients in {unit}/{CO2_UNIT}.</p>', unsafe_allow_html=True)
-
-    already_used = set(all_related_methods.keys())
-
-    for group_name, methods in method_groups.items():
-        available_methods = [
-            m for m in methods
-            if m not in already_used
-        ]
-        if not available_methods:
-            continue
-        with st.expander(f"**{group_name}**", expanded=False):
-            for m in available_methods:
-                enabled = st.checkbox(
-                    f"**{m}**",
-                    key=f"_dlg_new_chk_{m}",
-                )
-                if enabled:
-                    col_min, col_med, col_max = st.columns(3)
-                    with col_min:
-                        v_min = st.number_input(
-                            f"Min ({unit}/{CO2_UNIT})",
-                            min_value=0.0,
-                            value=None,
-                            format="%.10g",
-                            key=f"_dlg_new_min_{m}",
-                            placeholder="0.0000",
-                        )
-                    with col_med:
-                        v_med = st.number_input(
-                            f"Median ({unit}/{CO2_UNIT})",
-                            min_value=0.0,
-                            value=None,
-                            format="%.10g",
-                            key=f"_dlg_new_med_{m}",
-                            placeholder="0.0000",
-                        )
-                    with col_max:
-                        v_max = st.number_input(
-                            f"Ma ({unit}/{CO2_UNIT})",
-                            min_value=0.0,
-                            value=None,
-                            format="%.10g",
-                            key=f"_dlg_new_max_{m}",
-                            placeholder="0.0000",
-                        )
-                    method_configs[m] = {
-                        "min": v_min,
-                        "median": v_med,
-                        "max": v_max,
-                    }
-    error_placeholder = st.empty()
-    col_save, col_cancel = st.columns([2, 2])
-
-    with col_cancel:
-        if st.button("Cancel", use_container_width=True, key="btn-reset-cancel"):
-            st.rerun()
-
-    def _validate():
-        errors = []
-        if not batch_name.strip():
-            errors.append("Resource name is required.")
-        elif batch_name.strip() in standard_names:
-            errors.append(f"**{batch_name}** matches a standard resource name. Choose a different name.")
-        elif batch_name.strip() in existing_names:
-            errors.append(f"**{batch_name}** already exists. Choose a different name.")
-        if not batch_amount or batch_amount <= 0:
-            errors.append("Available amount must be greater than 0.")
-        # if not method_configs:
-        #     errors.append("Select at least one CDR method.")
-        for m, c in method_configs.items():
-            if any(v is None for v in [c["min"], c["median"], c["max"]]):
-                errors.append(f"**{m}**: all coefficient fields (min, median, max) are required.")
-                continue
-            if c["min"] > c["max"]:
-                errors.append(f"**{m}**: min ({c['min']}) cannot be greater than max ({c['max']}).")
-            if not (c["min"] <= c["median"] <= c["max"]):
-                errors.append(f"**{m}**: median must be between min and max.")
-        return errors
-
-    with col_save:
-        if st.button("Add to session", type="tertiary", use_container_width=True, icon=":material/check:", key="btn-new-add"):
-            errors = _validate()
-            if errors:
-                with error_placeholder.container():
-                    for e in errors:
-                        st.error(e, icon=":material/error:")
-            else:
-                batch = {
-                    "name": batch_name.strip(),
-                    "group": batch_group,
-                    "amount": float(batch_amount),   # always store as float
-                    "unit": resource_unit_map.get(resource_to_group.get(batch_group), "?"),
-                    "methods": method_configs,
-                }
-                if edit_index is not None:
-                    st.session_state.custom_resources[edit_index] = batch
-                    st.session_state.pop(f"custom_amount_{edit_index}", None)
-                else:
-                    new_idx = len(st.session_state.custom_resources)
-                    st.session_state.custom_resources.append(batch)
-                    st.session_state.pop(f"custom_amount_{new_idx}", None)
-                st.session_state.pop("latest_result", None)
-                st.rerun()
-
-
-# ─── Excel helpers ────────────────────────────────────────────────────────────
-
-def to_excel_bytes(batches: list) -> bytes:
-    """Serialize all custom resource batches to an Excel file (one row per batch×method)."""
-    rows = []
-    for batch in batches:
-        for m, coefs in batch["methods"].items():
-            rows.append({
-                "name":   batch["name"],
-                "group":  batch["group"],
-                "amount": float(batch["amount"]),
-                "unit": batch["unit"],
-                "method": m,
-                "min":    float(coefs["min"]),
-                "median": float(coefs["median"]),
-                "max":    float(coefs["max"]),
-            })
-    buf = BytesIO()
-    with pd.ExcelWriter(buf, engine="openpyxl") as writer:
-        pd.DataFrame(rows).to_excel(writer, index=False, sheet_name="custom_resources")
-    return buf.getvalue()
-
-
-def _parse_custom_excel(file) -> list:
-    df = pd.read_excel(file, sheet_name=0)
-    required = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
-    if not required.issubset(df.columns):
-        raise ValueError(f"Missing columns: {required - set(df.columns)}")
-    batches = []
-    for bname in df["name"].unique():
-        df_b = df[df["name"] == bname]
-        methods = {
-            row["method"]: {
-                "min":    float(row["min"]),
-                "median": float(row["median"]),
-                "max":    float(row["max"]),
-            }
-            for _, row in df_b.iterrows()
-        }
-        group_name = str(df_b["group"].iloc[0])
-        _r2g = {r: g for g, rs in resource_groups.items() for r in rs}
-        batches.append({
-            "name":    str(bname),
-            "group":   group_name,
-            "amount":  float(df_b["amount"].iloc[0]),
-            "unit":    resource_unit_map.get(_r2g.get(group_name), "?"),
-            "methods": methods,
-        })
-    return batches
-
-
-# ─── Load dialog ──────────────────────────────────────────────────────────────
-
-@st.dialog("Load custom resource batches", width="large")
-def dialog_load_custom_batch():
-    st.markdown('<p class="caption">Import an Excel file previously exported from the <strong>Custom resource</strong> section.</p>', unsafe_allow_html=True)
-
-    uploaded = st.file_uploader("Upload Excel file", type=["xlsx"], key="inputs_loader_custom")
-    if uploaded is None:
-        return
-
-    try:
-        new_batches = _parse_custom_excel(uploaded)
-    except Exception as e:
-        st.error(f"Error reading file: {e}")
-        return
-
-    standard_names = standard_resource_names()
-    existing_names = {b["name"] for b in st.session_state.custom_resources}
-
-    previews = []
-    for batch in new_batches:
-        if batch["name"] in standard_names:
-            status = "❌ Conflicts with standard resource — will be skipped"
-        elif batch["name"] in existing_names:
-            status = "⚠️ Already exists — will be overwritten"
-        else:
-            status = "✅ New"
-        previews.append({
-            "Resource name": batch["name"],
-            "Group": batch["group"],
-            "Amount": f"{batch["amount"]} {resource_unit_map.get(batch["group"], "")}",
-            "Methods": len(batch["methods"]),
-            "Status": status,
-        })
-    st.dataframe(pd.DataFrame(previews), use_container_width=True, hide_index=True)
-
-    if st.button("↩️ Import all batches", type="primary", use_container_width=True):
-        imported = 0
-        for batch in new_batches:
-            if batch["name"] in standard_names:
-                continue
-            if batch["name"] in existing_names:
-                idx = next(i for i, b in enumerate(st.session_state.custom_resources)
-                           if b["name"] == batch["name"])
-                st.session_state.custom_resources[idx] = batch
-            else:
-                st.session_state.custom_resources.append(batch)
-            imported += 1
-        st.session_state.pop("latest_result", None)
-        st.success(f"Imported {imported} batch(es).")
-        st.rerun()
-
-
-# ─── Custom resources panel ───────────────────────────────────────────────────
-
-def _render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
-    """Render a single custom batch inside its resource-group expander."""
-    n_methods = len(batch["methods"])
-    amount_val = float(batch["amount"])
-    batch["unit"] = unit  # keep in sync for Excel export
-
-    # st.markdown(f"🆕 **{batch['name']}** — CDR methods: **{n_methods}**")
-    with st.container(border=True):
-        key_amount = f"custom_amount_{global_idx}"
-        if key_amount not in st.session_state:
-            st.session_state[key_amount] = amount_val
-
-        col_amount, _, _, _ = st.columns(4)
-        with col_amount:
-            new_amount = st.number_input(
-                f"{batch['name']}",
-                min_value=0.0,
-                format="%.2f",
-                key=key_amount,
-            )
-        if new_amount != amount_val:
-            st.session_state.custom_resources[global_idx]["amount"] = float(new_amount)
-            st.session_state.pop("latest_result", None)
-
-        col_min = f"Min ({unit}/MtCO₂)"
-        col_med = f"Median ({unit}/MtCO₂)"
-        col_max = f"Max ({unit}/MtCO₂)"
-        rows = [
-            {
-                "Method": m,
-                col_min: float(c["min"]),
-                col_med: float(c["median"]),
-                col_max: float(c["max"]),
-            }
-            for m, c in batch["methods"].items()
-        ]
-        st.dataframe(
-            pd.DataFrame(rows),
-            use_container_width=True,
-            hide_index=True,
-            key=f"batch_editor_{global_idx}",
-            column_config={
-                "Method": st.column_config.TextColumn(disabled=True),
-                col_min: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
-                col_med: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
-                col_max: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
-            },
-        )
-
-        with st.container(key="container-btn-new"):
-            if st.button("Delete", key=f"del_batch_{global_idx}",
-                            type="primary", icon=":material/delete:"):
-                st.session_state.custom_resources.pop(global_idx)
-                st.session_state.pop("latest_result", None)
-                st.rerun()
-            if st.button("Edit", key=f"edit_batch_{global_idx}", 
-                            type="secondary", icon=":material/edit:"):
-                dialog_add_custom_resource(cost_sliders, edit_index=global_idx)
-
-
-
-def panel_custom_resources_controls(cost_sliders):
-    """Buttons to add / load / download custom resource batches (no batch display here)."""
-    init_custom_resources()
-
-    st.markdown('<p class="crra-sub-heading">➕ New resource</p>', unsafe_allow_html=True)
-    st.markdown(
-        '<p class="caption"> Add sub-batches for any resource group and manually assign them to specific CDR methods.</p>',
-        unsafe_allow_html=True,
-    )
-    batches = st.session_state.custom_resources
-
-    with st.container(key="container-btn"):
-        if st.button("New resource", type="tertiary", icon=":material/add:", key="btn-new-resource"):
-            dialog_add_custom_resource(cost_sliders)
-        if st.button("Load from Excel", type="tertiary", icon=":material/arrow_upload_progress:", key="btn-load"):
-            dialog_load_custom_batch()
-        if batches:
-            st.download_button(
-                "Download new resources",
-                data=to_excel_bytes(batches),
-                file_name="new_resources.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                icon=":material/download:",
-                key="download_button_save_custom",
-            )
-
-
-# ─── Main render ──────────────────────────────────────────────────────────────
-
-def render_tab(cost_sliders):
-    if "resource_caps" not in st.session_state:
-        st.session_state.resource_caps = {}
-    for r in resource_order:
-        if r not in st.session_state.resource_caps:
-            st.session_state.resource_caps[r] = 0.0
-    init_custom_resources()
-
-    st.markdown('<h1 class="crra-heading">Resource inputs</h1>', unsafe_allow_html=True)
-    show_bar()
-
-    st.markdown('<p class="objective_title">OBJECTIVE</p>', unsafe_allow_html=True)
-    st.markdown(
-        '<p class="text_with_border">This section lets you define the <strong>total available '
-        'quantities of each resource</strong> for the optimization model.</p>',
-        unsafe_allow_html=True,
-    )
-
-    with st.container(key="warning_resources"):
-        st.warning(
-            "Resources with zero availability will block portfolio feasibility if required by active methods.",
-            icon=":material/warning:",
-        )
-
-    st.markdown('<p class="crra-sub-heading">Controls</p>', unsafe_allow_html=True)
-
-    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
-        for r in st.session_state.resource_caps:
-            st.session_state.resource_caps[r] = 0.0
-        st.session_state.custom_resources = []
-        st.session_state.enabled_methods = {}
-        st.success("All resource values reset to 0.")
-        st.rerun()
-
-    st.markdown('<p class="crra-sub-sub-heading">Import resource values</p>', unsafe_allow_html=True)
-    col_template, col_upload = st.columns([1, 1])
-    with col_template:
-        st.markdown("<div class='caption'><p>Use the template below to fill in your resource "
-                    "availability values and import them directly into the tool.</p></div>",
-                    unsafe_allow_html=True)
-        with open("data/resource_template.xlsx", "rb") as f:
-            st.download_button(
-                label="Download Excel Template",
-                data=f,
-                file_name="resource_template.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                icon=":material/download:",
-                key="download_button_resource_template"
-            )
-    with col_upload:
-        uploaded_file = st.file_uploader(
-            "Upload your Excel file", type="xlsx",
-            key=f"resource_uploader_{st.session_state.get('resource_uploader_key', 0)}",
-        )
-        if uploaded_file is not None and uploaded_file.name != st.session_state.get("resource_last_loaded_file"):
-            try:
-                df = pd.read_excel(uploaded_file)
-                required_cols = {"Resource", "Available Amount"}
-                if not required_cols.issubset(df.columns):
-                    raise ValueError(f"Missing columns: {required_cols - set(df.columns)}")
-                for r in st.session_state.resource_caps:
-                    st.session_state.resource_caps[r] = 0.0
-                    st.session_state[f"cap_{r}"] = 0.0
-                for _, row in df.iterrows():
-                    r = row["Resource"]
-                    val = row["Available Amount"]
-                    if r not in st.session_state.resource_caps:
-                        continue
-                    try:
-                        val = 0.0 if pd.isna(val) else float(val)
-                    except (ValueError, TypeError):
-                        val = 0.0
-                    st.session_state.resource_caps[r] = val
-                    st.session_state[f"cap_{r}"] = val
-                st.session_state["resource_last_loaded_file"] = uploaded_file.name
-                st.success("Resource values imported successfully.", icon="✅")
-                for key in ["excel_loaded_file", "scenario_name_suggestion",
-                            "scenario_loaded_file", "input_file_name_suggestion", "latest_result"]:
-                    st.session_state.pop(key, None)
-                st.rerun()
-            except Exception as e:
-                st.error(f"Error importing resource values: {e}")
-        elif st.session_state.get("resource_last_loaded_file"):
-            st.success(f"Loaded: **{st.session_state['resource_last_loaded_file']}**", icon="✅")
-
-    # Standard resource inputs
-    st.markdown('<p class="crra-sub-heading">Set available resources for one year</p>', unsafe_allow_html=True)
-
-    # Pré-calcul : pour chaque méthode, la liste de ses ressources primaires (non secondaires)
-    method_to_primary_resources = {}
-    for cdr_method, resource_coeffs in cost_sliders.items():
-        for name in resource_coeffs:
-            r_clean = strip_unit_suffix(name)
-            if (cdr_method, r_clean) not in secondary_resources:
-                method_to_primary_resources.setdefault(cdr_method, []).append(r_clean)
-
-    for r in method_to_primary_resources:
-        pass  # no-op, kept for clarity of intent below
-
-    resource_to_group = {
-        r: g
-        for g, rlist in resource_groups.items()
-        for r in rlist
-    }
-
-    for group, rlist in resource_groups.items():
-        unit = resource_unit_map.get(group, "")
-        with st.expander(f"**{group}** ({unit})", expanded=True):
-
-            cols = st.columns(4)
-
-            for i, r in enumerate(rlist):
-
-                tooltip = resource_tooltips.get(r, None)
-                name_clean = r.split(" (")[0]
-
-                with cols[i % 4]:
-
-                    render_resource_input(name_clean, r, tooltip=tooltip)
-
-                    related_methods = {}
-                    related_by_group = {}
-
-                    for cdr_method, resource in cost_sliders.items():
-                        for name, coeff in resource.items():
-                            if r == strip_unit_suffix(name):
-                                related_methods[cdr_method] = coeff
-
-                    for m in related_methods:
-                        method_group = next(
-                            (g for g, methods in method_groups.items() if m in methods),
-                            "Other"
-                        )
-                        related_by_group.setdefault(method_group, []).append(m)
-
-                    related_method_names = list(related_methods.keys())
-                    secondary_for_r = [m for m in related_method_names if (m, r) in secondary_resources]
-                    primary_for_r = [m for m in related_method_names if (m, r) not in secondary_resources]
-
-                    if r not in st.session_state.enabled_methods:
-                        st.session_state.enabled_methods[r] = {}
-                    for m in related_method_names:
-                        st.session_state.enabled_methods[r].setdefault(m, True)
-                    popover_key_prefix = f"pop_{r}"
-
-                    with st.popover(
-                        f":material/tune: Related CDR Methods",
-                        use_container_width=True,
-                    ):
-                        for method_group, methods in related_by_group.items():
-                            primary_in_group = [m for m in methods if m in primary_for_r]
-                            if not primary_in_group:
-                                continue
-                            st.markdown(f"*{method_group}*")
-                            for m in primary_in_group:
-                                widget_key = f"{popover_key_prefix}_{m}"
-                                if widget_key not in st.session_state:
-                                    st.session_state[widget_key] = st.session_state.enabled_methods[r][m]
-
-                                checked = st.checkbox(m, key=widget_key)
-                                st.session_state.enabled_methods[r][m] = checked
-
-                        if secondary_for_r:
-                            st.caption(
-                                "Secondary methods that can be added in the **Resource Coefficient** tab:\n\n"
-                                + "\n".join(f"- {m}" for m in secondary_for_r)
-                            )
-
-                    for m in secondary_for_r:
-                        st.session_state.enabled_methods[r][m] = True
-
-            # Custom batches for this group
-            group_unit = resource_unit_map.get(group, "")
-            group_batches = [
-                (idx, b) for idx, b in enumerate(st.session_state.get("custom_resources", []))
-                if resource_to_group.get(b["group"]) == group
-            ]
-            for global_idx, batch in group_batches:
-                _render_custom_batch_inline(global_idx, batch, cost_sliders, group_unit)
-            
-            _, col_button = st.columns([3,1])
-            with col_button:
-                if st.button(
-                    "Add resource", key=f"simple-btn-resource-{group}",
-                    type="tertiary", icon=":material/add:", use_container_width=True
-                ):
-                    dialog_add_custom_resource(cost_sliders, preset_resources=rlist)
-
-    # ─── Vérification globale : si une méthode n'a plus aucune ressource
-    # primaire active, on la désactive directement (constraints[m]["active"] = False)
-    # plutôt que de bloquer le décochage. C'est un état valide : l'utilisateur a
-    # choisi de retirer cette méthode de l'optimisation pour cette ressource.
-    method_active_resource_count = {}
-    for r, methods in st.session_state.enabled_methods.items():
-        for m, ok in methods.items():
-            if (m, r) in secondary_resources:
-                continue
-            method_active_resource_count.setdefault(m, 0)
-            if ok:
-                method_active_resource_count[m] += 1
-
-    # Custom batches are INDEPENDENT of the standard resource toggle: a method
-    # linked to a custom batch with capacity counts as having an active resource,
-    # even if it is disabled for the standard reference resource.
-    for batch in st.session_state.get("custom_resources", []):
-        if float(batch.get("amount") or 0) <= 0:
-            continue
-        for m_name in batch.get("methods", {}).keys():
-            method_active_resource_count.setdefault(m_name, 0)
-            method_active_resource_count[m_name] += 1
-
-    methods_with_no_active_resource = [
-        m for m in method_to_primary_resources
-        if method_active_resource_count.get(m, 0) == 0
-    ]
-
-    # Re-enable methods that were auto-disabled but now have at least one active resource
-    for m in list(st.session_state.auto_disabled_methods):
-        if method_active_resource_count.get(m, 0) > 0:
-            if m in st.session_state.constraints:
-                st.session_state.constraints[m]["active"] = True
-            toggle_key = f"toggle_{m}"
-            if toggle_key in st.session_state:
-                st.session_state[toggle_key] = True
-            st.session_state.auto_disabled_methods.discard(m)
-
-    # Auto-disable methods that now have no active primary resource
-    newly_disabled = []
-    for m in methods_with_no_active_resource:
-        if st.session_state.constraints.get(m, {}).get("active", True):
-            st.session_state.constraints.setdefault(m, {"active": True, "cap_type": "percent", "cap_value": 100})
-            st.session_state.constraints[m]["active"] = False
-            st.session_state.auto_disabled_methods.add(m)
-            newly_disabled.append(m)
-            toggle_key = f"toggle_{m}"
-            if toggle_key in st.session_state:
-                st.session_state[toggle_key] = False
-
-    if newly_disabled:
-        st.info(
-            "The following methods have no active resource left and were "
-            "automatically deactivated (see Method constraints tab): "
-            + ", ".join(newly_disabled),
-            icon=":material/info:"
-        )
-
-
-    # Controls: New resource / Load / Download
-    panel_custom_resources_controls(cost_sliders)
-
-    # Summary table
-    st.markdown('<p class="crra-sub-heading">Summary of available resources</p>', unsafe_allow_html=True)
-
-    resource_to_unit = {
-        r: resource_unit_map[group]
-        for group, resources in resource_groups.items()
-        for r in resources
-    }
-
-    df_caps = pd.DataFrame.from_dict(
-        {r: st.session_state.resource_caps[r] for r in resource_order
-         if st.session_state.resource_caps.get(r, 0.0) > 0},
-        orient="index", columns=["Available Amount"],
-    ).reindex(resource_order).dropna()
-    df_caps["Available Amount"] = [
-        f"{value:,.2f} {resource_to_unit.get(resource, '?')}"
-        for resource, value in df_caps["Available Amount"].items()
-    ]
-
-    custom_rows = []
-    for batch in st.session_state.get("custom_resources", []):
-        group = resource_to_group.get(batch["group"])
-        unit = resource_unit_map.get(group, "?")
-        custom_rows.append({
-            "Resource": batch["name"],
-            "Available Amount": f"{float(batch['amount']):,.2f} {unit}",
-        })
-
-    if not df_caps.empty or custom_rows:
-        dfs = []
-        if not df_caps.empty:
-            df_std = df_caps.copy()
-            df_std["Type"] = "Standard"
-            dfs.append(df_std)
-        if custom_rows:
-            df_custom = pd.DataFrame(custom_rows).set_index("Resource")
-            df_custom["Type"] = "New"
-            dfs.append(df_custom)
-        df_all = pd.concat(dfs)[["Available Amount", "Type"]].reset_index().rename(columns={"index": "Resource"})
-        num_rows = len(df_all)
-        st.dataframe(
-            df_all,
-            use_container_width=True,
-            hide_index=True,
-            height=(num_rows * 36 + 36),
-            column_config={
-                "Resource": st.column_config.TextColumn("Resource", width="large"),
-                "Available Amount": st.column_config.TextColumn("Available Amount"),
-                "Type": st.column_config.TextColumn("Type"),
-            },
-            row_height=36
-        )
-    else:
+import pandas as pd
+import streamlit as st
+
+from config.config import (resource_groups, resource_order, resource_tooltips,
+                           resource_unit_map, method_groups, CO2_UNIT, secondary_resources)
+from utils.data_utils import render_resource_input, strip_unit_suffix, get_resource_to_group, get_resource_to_unit, get_method_group
+from utils.ui_helpers import show_bar
+from io import BytesIO
+
+
+def standard_resource_names():
+    """Return the set of all standard resource names defined in resource_groups config.
+
+    Returns:
+        set[str]: flat set of every resource name across all resource groups.
+    """
+    return {r for rlist in resource_groups.values() for r in rlist}
+
+
+def init_custom_resources():
+    """Initialise custom resource session state keys and coerce amounts/coefficients to float.
+
+    Ensures custom_resources, enabled_methods, and auto_disabled_methods exist in
+    session state, then sanitises every batch so numeric fields are float (not str).
+
+    Returns:
+        None
+    """
+    if "custom_resources" not in st.session_state:
+        st.session_state.custom_resources = []
+    if "enabled_methods" not in st.session_state:
+        st.session_state.enabled_methods = {}
+    if "auto_disabled_methods" not in st.session_state:
+        st.session_state.auto_disabled_methods = set()
+    for batch in st.session_state.custom_resources:
+        try:
+            batch["amount"] = float(batch["amount"])
+        except (ValueError, TypeError):
+            batch["amount"] = 0.0
+        for m, coefs in batch.get("methods", {}).items():
+            for key in ("min", "median", "max"):
+                try:
+                    coefs[key] = float(coefs[key])
+                except (ValueError, TypeError):
+                    coefs[key] = 0.0
+
+
+@st.dialog("Add a new resource", width="large")
+def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, preset_resources: list | None = None):
+    """Dialog for adding or editing a custom resource batch.
+
+    Opens a modal form where the user picks a name, reference resource group,
+    available quantity, and per-method coefficients (min/median/max).
+
+    Args:
+        cost_sliders (dict): full cost slider config {method: {resource: {min, median, max}}}.
+        edit_index (int | None): index into custom_resources to edit; None for a new batch.
+        preset_resources (list | None): restrict the group selector to this resource list
+                                        (used when launched from a group expander button).
+
+    Returns:
+        None
+    """
+    if edit_index is not None and not st.session_state.get(f"_dlg_initialized_{edit_index}"):
+        for key in list(st.session_state.keys()):
+            if key.startswith(("_dlg_existing_enable_",
+                            "_dlg_existing_min_", "_dlg_existing_med_", "_dlg_existing_max_",
+                            "_dlg_new_chk_", "_dlg_new_min_", "_dlg_new_med_", "_dlg_new_max_")):
+                del st.session_state[key]
+        st.session_state[f"_dlg_initialized_{edit_index}"] = True
+
+    standard_names = standard_resource_names()
+    existing_names = {
+        b["name"] for i, b in enumerate(st.session_state.custom_resources)
+        if i != edit_index
+    }
+    existing = st.session_state.custom_resources[edit_index] if edit_index is not None else {}
+
+    resource_to_group = get_resource_to_group()
+
+    # If opened from a specific resource-group expander ("+ Add resource" inline
+    # button), restrict the reference-resource choice to that group's resources
+    # only — the user picked the group by clicking that button.
+    group_options = preset_resources if preset_resources else resource_order
+    if preset_resources:
+        physical_group = resource_to_group.get(preset_resources[0], "")
+        st.markdown(
+            f'<p class="caption-input">Adding a new resource batch in the <strong>{physical_group}</strong> group.</p>',
+            unsafe_allow_html=True,
+        )
+
+    st.markdown('<p class="dialog-title">1 — Name & group</p>', unsafe_allow_html=True)
+
+    col_name, col_group = st.columns(2)
+    with col_name:
+        batch_name = st.text_input(
+            "Resource name *",
+            value=existing.get("name", ""),
+            placeholder="e.g. Degraded forest lands – North",
+            help="It can't match the name of an existing resource.",
+            key="label-input-name"
+        )
+    with col_group:
+        default_group_idx = group_options.index(existing["group"]) if existing.get("group") in group_options else 0
+        batch_group = st.selectbox(
+            "Resource group *",
+            options=group_options,
+            index=default_group_idx,
+            help="Determines the physical unit of this resource.",
+            disabled=bool(preset_resources) and len(group_options) == 1,
+            key="label-input-group"
+        )
+
+    group = resource_to_group.get(batch_group)
+    unit = resource_unit_map.get(group, "?")
+
+    st.markdown(f'<p class="caption">Unit for this group: <strong>{unit}</strong></p>', unsafe_allow_html=True)
+
+    st.markdown('<p class="dialog-title">2 — Available quantity</p>', unsafe_allow_html=True)
+
+    batch_amount = st.number_input(
+        f"Available amount ({unit})",
+        min_value=0.0,
+        format="%.2f",
+        value=float(existing["amount"]) if existing.get("amount") and existing.get("amount") != 0.0 else None,
+        help=f"Total quantity available for 1 year, in {unit}.",
+        key="label-input-amount",
+        placeholder="0.0"
+    )
+
+    st.markdown('<p class="dialog-title">3 — Existing CDR methods for this resource</p>', unsafe_allow_html=True)
+
+    method_configs = {}
+
+    all_related_methods = {}
+    for cdr_method, resource in cost_sliders.items():
+        for name, coeff in resource.items():
+            if batch_group == strip_unit_suffix(name):
+                all_related_methods[cdr_method] = {
+                    "min": coeff["min"],
+                    "median": coeff["median"],
+                    "max": coeff["max"],
+                }
+
+    # Split into primary (selectable) and secondary (auto-linked in Tab 3)
+    primary_related = {
+        m: coeff for m, coeff in all_related_methods.items()
+        if (m, batch_group) not in secondary_resources
+    }
+    secondary_related = {
+        m: coeff for m, coeff in all_related_methods.items()
+        if (m, batch_group) in secondary_resources
+    }
+
+    primary_by_group = {}
+    for m, coeff in primary_related.items():
+        method_group = get_method_group(m)
+        primary_by_group.setdefault(method_group, {})[m] = coeff
+
+    if not primary_by_group:
+        st.markdown('<p class="caption">No primary CDR methods use this resource directly.</p>', unsafe_allow_html=True)
+
+    for method_group, methods in primary_by_group.items():
+        with st.expander(f"**{method_group}**", expanded=False):
+            for m, coeff in methods.items():
+
+                already_selected = m in existing.get("methods", {})
+
+                if f"_dlg_existing_enable_{m}" not in st.session_state:
+                    st.session_state[f"_dlg_existing_enable_{m}"] = already_selected
+
+                enabled = st.checkbox(
+                    f"{m}",
+                    key=f"_dlg_existing_enable_{m}",
+                )
+
+                if not enabled:
+                    continue
+
+                existing_coeff = existing.get("methods", {}).get(m, coeff)
+
+                st.warning("Modifying these values only affects this resource batch: the base method coefficients are unchanged.")
+                col_min, col_med, col_max = st.columns(3)
+                with col_min:
+                    e_min = st.number_input(
+                        f"Min ({unit}/{CO2_UNIT})",
+                        min_value=0.0,
+                        format="%.10g",
+                        value=float(existing_coeff["min"]),
+                        key=f"_dlg_existing_min_{m}",
+                    )
+                with col_med:
+                    e_med = st.number_input(
+                        f"Median ({unit}/{CO2_UNIT})",
+                        min_value=0.0,
+                        format="%.10g",
+                        value=float(existing_coeff["median"]),
+                        key=f"_dlg_existing_med_{m}",
+                    )
+                with col_max:
+                    e_max = st.number_input(
+                        f"Max ({unit}/{CO2_UNIT})",
+                        min_value=0.0,
+                        format="%.10g",
+                        value=float(existing_coeff["max"]),
+                        key=f"_dlg_existing_max_{m}",
+                    )
+                method_configs[m] = {
+                    "min": e_min,
+                    "median": e_med,
+                    "max": e_max,
+                }
+
+    if secondary_related:
+        names = "\n".join(f"- **{m}**" for m in secondary_related)
+        st.info(
+        f"""The following methods use this resource as **secondary** and may be assigned later in the **Resource Coefficients** tab:\n{names}
+        """,
+            icon=":material/info:",
+        )
+
+
+    st.markdown('<p class="dialog-title">4 — Add additional CDR methods</p>', unsafe_allow_html=True)
+    st.markdown(f'<p class="caption">Select additional methods and enter their coefficients in {unit}/{CO2_UNIT}.</p>', unsafe_allow_html=True)
+
+    already_used = set(all_related_methods.keys())
+
+    for group_name, methods in method_groups.items():
+        available_methods = [
+            m for m in methods
+            if m not in already_used
+        ]
+        if not available_methods:
+            continue
+        with st.expander(f"**{group_name}**", expanded=False):
+            for m in available_methods:
+                enabled = st.checkbox(
+                    f"**{m}**",
+                    key=f"_dlg_new_chk_{m}",
+                )
+                if enabled:
+                    col_min, col_med, col_max = st.columns(3)
+                    with col_min:
+                        v_min = st.number_input(
+                            f"Min ({unit}/{CO2_UNIT})",
+                            min_value=0.0,
+                            value=None,
+                            format="%.10g",
+                            key=f"_dlg_new_min_{m}",
+                            placeholder="0.0000",
+                        )
+                    with col_med:
+                        v_med = st.number_input(
+                            f"Median ({unit}/{CO2_UNIT})",
+                            min_value=0.0,
+                            value=None,
+                            format="%.10g",
+                            key=f"_dlg_new_med_{m}",
+                            placeholder="0.0000",
+                        )
+                    with col_max:
+                        v_max = st.number_input(
+                            f"Ma ({unit}/{CO2_UNIT})",
+                            min_value=0.0,
+                            value=None,
+                            format="%.10g",
+                            key=f"_dlg_new_max_{m}",
+                            placeholder="0.0000",
+                        )
+                    method_configs[m] = {
+                        "min": v_min,
+                        "median": v_med,
+                        "max": v_max,
+                    }
+    error_placeholder = st.empty()
+    col_save, col_cancel = st.columns([2, 2])
+
+    with col_cancel:
+        if st.button("Cancel", width='stretch', key="btn-reset-cancel"):
+            st.rerun()
+
+    def _validate():
+        errors = []
+        if not batch_name.strip():
+            errors.append("Resource name is required.")
+        elif batch_name.strip() in standard_names:
+            errors.append(f"**{batch_name}** matches a standard resource name. Choose a different name.")
+        elif batch_name.strip() in existing_names:
+            errors.append(f"**{batch_name}** already exists. Choose a different name.")
+        if not batch_amount or batch_amount <= 0:
+            errors.append("Available amount must be greater than 0.")
+        # if not method_configs:
+        #     errors.append("Select at least one CDR method.")
+        for m, c in method_configs.items():
+            if any(v is None for v in [c["min"], c["median"], c["max"]]):
+                errors.append(f"**{m}**: all coefficient fields (min, median, max) are required.")
+                continue
+            if c["min"] > c["max"]:
+                errors.append(f"**{m}**: min ({c['min']}) cannot be greater than max ({c['max']}).")
+            if not (c["min"] <= c["median"] <= c["max"]):
+                errors.append(f"**{m}**: median must be between min and max.")
+        return errors
+
+    with col_save:
+        if st.button("Add to session", type="tertiary", width='stretch', icon=":material/check:", key="btn-new-add"):
+            errors = _validate()
+            if errors:
+                with error_placeholder.container():
+                    for e in errors:
+                        st.error(e, icon=":material/error:")
+            else:
+                batch = {
+                    "name": batch_name.strip(),
+                    "group": batch_group,
+                    "amount": float(batch_amount),   # always store as float
+                    "unit": resource_unit_map.get(resource_to_group.get(batch_group), "?"),
+                    "methods": method_configs,
+                }
+                if edit_index is not None:
+                    st.session_state.custom_resources[edit_index] = batch
+                    st.session_state.pop(f"custom_amount_{edit_index}", None)
+                else:
+                    new_idx = len(st.session_state.custom_resources)
+                    st.session_state.custom_resources.append(batch)
+                    st.session_state.pop(f"custom_amount_{new_idx}", None)
+                st.session_state.pop("latest_result", None)
+                st.rerun()
+
+
+
+def to_excel_bytes(batches: list) -> bytes:
+    """Serialise all custom resource batches to an Excel file (one row per batch × method).
+
+    Args:
+        batches (list): list of custom batch dicts with keys name, group, amount, unit, methods.
+
+    Returns:
+        bytes: raw bytes of the .xlsx workbook.
+    """
+    rows = []
+    for batch in batches:
+        for m, coefs in batch["methods"].items():
+            rows.append({
+                "name":   batch["name"],
+                "group":  batch["group"],
+                "amount": float(batch["amount"]),
+                "unit": batch["unit"],
+                "method": m,
+                "min":    float(coefs["min"]),
+                "median": float(coefs["median"]),
+                "max":    float(coefs["max"]),
+            })
+    excel_buffer = BytesIO()
+    with pd.ExcelWriter(excel_buffer, engine="openpyxl") as writer:
+        pd.DataFrame(rows).to_excel(writer, index=False, sheet_name="custom_resources")
+    return excel_buffer.getvalue()
+
+
+def _parse_custom_excel(file) -> list:
+    """Parse a custom resource Excel file into a list of batch dicts.
+
+    Expects columns: name, group, amount, unit, method, min, median, max.
+
+    Args:
+        file: file-like object pointing to an .xlsx workbook.
+
+    Returns:
+        list[dict]: one dict per unique batch name with keys
+                    name, group, amount, unit, methods.
+
+    Raises:
+        ValueError: if required columns are missing.
+    """
+    df = pd.read_excel(file, sheet_name=0)
+    required = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
+    if not required.issubset(df.columns):
+        raise ValueError(f"Missing columns: {required - set(df.columns)}")
+    batches = []
+    for batch_name in df["name"].unique():
+        df_b = df[df["name"] == batch_name]
+        methods = {
+            row["method"]: {
+                "min":    float(row["min"]),
+                "median": float(row["median"]),
+                "max":    float(row["max"]),
+            }
+            for _, row in df_b.iterrows()
+        }
+        group_name = str(df_b["group"].iloc[0])
+        resource_to_group = get_resource_to_group()
+        batches.append({
+            "name":    str(batch_name),
+            "group":   group_name,
+            "amount":  float(df_b["amount"].iloc[0]),
+            "unit":    resource_unit_map.get(resource_to_group.get(group_name), "?"),
+            "methods": methods,
+        })
+    return batches
+
+
+
+@st.dialog("Load custom resource batches", width="large")
+def dialog_load_custom_batch():
+    """Dialog for importing custom resource batches from an Excel file.
+
+    Reads an .xlsx file produced by to_excel_bytes, previews each batch's
+    status (new / overwrite / conflict), and merges them into session state
+    on confirmation.
+
+    Returns:
+        None
+    """
+    st.markdown('<p class="caption">Import an Excel file previously exported from the <strong>Custom resource</strong> section.</p>', unsafe_allow_html=True)
+
+    uploaded = st.file_uploader("Upload Excel file", type=["xlsx"], key="inputs_loader_custom")
+    if uploaded is None:
+        return
+
+    try:
+        new_batches = _parse_custom_excel(uploaded)
+    except Exception as e:
+        st.error(f"Error reading file: {e}")
+        return
+
+    standard_names = standard_resource_names()
+    existing_names = {b["name"] for b in st.session_state.custom_resources}
+
+    previews = []
+    for batch in new_batches:
+        if batch["name"] in standard_names:
+            status = "❌ Conflicts with standard resource — will be skipped"
+        elif batch["name"] in existing_names:
+            status = "⚠️ Already exists — will be overwritten"
+        else:
+            status = "✅ New"
+        previews.append({
+            "Resource name": batch["name"],
+            "Group": batch["group"],
+            "Amount": f"{batch["amount"]} {resource_unit_map.get(batch["group"], "")}",
+            "Methods": len(batch["methods"]),
+            "Status": status,
+        })
+    st.dataframe(pd.DataFrame(previews), width='stretch', hide_index=True)
+
+    if st.button("↩️ Import all batches", type="primary", width='stretch'):
+        imported = 0
+        for batch in new_batches:
+            if batch["name"] in standard_names:
+                continue
+            if batch["name"] in existing_names:
+                idx = next(i for i, b in enumerate(st.session_state.custom_resources)
+                           if b["name"] == batch["name"])
+                st.session_state.custom_resources[idx] = batch
+            else:
+                st.session_state.custom_resources.append(batch)
+            imported += 1
+        st.session_state.pop("latest_result", None)
+        st.success(f"Imported {imported} batch(es).")
+        st.rerun()
+
+
+
+def _render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
+    """Render a single custom batch inside its resource-group expander."""
+    n_methods = len(batch["methods"])
+    amount_val = float(batch["amount"])
+    batch["unit"] = unit  # keep in sync for Excel export
+
+    # st.markdown(f"🆕 **{batch['name']}** — CDR methods: **{n_methods}**")
+    with st.container(border=True):
+        key_amount = f"custom_amount_{global_idx}"
+        if key_amount not in st.session_state:
+            st.session_state[key_amount] = amount_val
+
+        col_amount, _, _, _ = st.columns(4)
+        with col_amount:
+            new_amount = st.number_input(
+                f"{batch['name']}",
+                min_value=0.0,
+                format="%.2f",
+                key=key_amount,
+            )
+        if new_amount != amount_val:
+            st.session_state.custom_resources[global_idx]["amount"] = float(new_amount)
+            st.session_state.pop("latest_result", None)
+
+        col_min = f"Min ({unit}/MtCO₂)"
+        col_med = f"Median ({unit}/MtCO₂)"
+        col_max = f"Max ({unit}/MtCO₂)"
+        rows = [
+            {
+                "Method": m,
+                col_min: float(c["min"]),
+                col_med: float(c["median"]),
+                col_max: float(c["max"]),
+            }
+            for m, c in batch["methods"].items()
+        ]
+        st.dataframe(
+            pd.DataFrame(rows),
+            width='stretch',
+            hide_index=True,
+            key=f"batch_editor_{global_idx}",
+            column_config={
+                "Method": st.column_config.TextColumn(disabled=True),
+                col_min: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
+                col_med: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
+                col_max: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
+            },
+        )
+
+        with st.container(key=f"container-button-{global_idx}"):
+            if st.button("Delete", key=f"del_batch_{global_idx}",
+                            type="primary", icon=":material/delete:"):
+                st.session_state.custom_resources.pop(global_idx)
+                st.session_state.pop("latest_result", None)
+                st.rerun()
+            if st.button("Edit", key=f"edit_batch_{global_idx}", 
+                            type="secondary", icon=":material/edit:"):
+                dialog_add_custom_resource(cost_sliders, edit_index=global_idx)
+
+
+
+def panel_custom_resources_controls(cost_sliders):
+    """Buttons to add / load / download custom resource batches (no batch display here)."""
+    init_custom_resources()
+
+    st.markdown('<p class="crra-sub-heading">➕ New resource</p>', unsafe_allow_html=True)
+    st.markdown(
+        '<p class="caption"> Add sub-batches for any resource group and manually assign them to specific CDR methods.</p>',
+        unsafe_allow_html=True,
+    )
+    batches = st.session_state.custom_resources
+
+    with st.container(key="container-btn"):
+        if st.button("New resource", type="tertiary", icon=":material/add:", key="btn-new-resource"):
+            dialog_add_custom_resource(cost_sliders)
+        if st.button("Load from Excel", type="tertiary", icon=":material/arrow_upload_progress:", key="btn-load"):
+            dialog_load_custom_batch()
+        if batches:
+            st.download_button(
+                "Download new resources",
+                data=to_excel_bytes(batches),
+                file_name="new_resources.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                icon=":material/download:",
+                key="download_button_save_custom",
+            )
+
+
+
+def render_tab(cost_sliders):
+    """Render the Resource Inputs tab.
+
+    Shows per-resource number inputs grouped by resource group, custom batch
+    controls, an upload/download template workflow, and a summary table. Also
+    auto-deactivates CDR methods whose primary resources are all disabled.
+
+    Args:
+        cost_sliders (dict): full cost slider config {method: {resource: {min, median, max}}}.
+
+    Returns:
+        None
+    """
+    if "resource_caps" not in st.session_state:
+        st.session_state.resource_caps = {}
+    for r in resource_order:
+        if r not in st.session_state.resource_caps:
+            st.session_state.resource_caps[r] = 0.0
+    init_custom_resources()
+
+    st.markdown('<h1 class="crra-heading">Resource inputs</h1>', unsafe_allow_html=True)
+    show_bar()
+
+    st.markdown('<p class="objective_title">OBJECTIVE</p>', unsafe_allow_html=True)
+    st.markdown(
+        '<p class="text_with_border">This section lets you define the <strong>total available '
+        'quantities of each resource</strong> for the optimization model.</p>',
+        unsafe_allow_html=True,
+    )
+
+    with st.container(key="warning_resources"):
+        st.warning(
+            "Resources with zero availability will block portfolio feasibility if required by active methods.",
+            icon=":material/warning:",
+        )
+
+    st.markdown('<p class="crra-sub-heading">Controls</p>', unsafe_allow_html=True)
+
+    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
+        for r in st.session_state.resource_caps:
+            st.session_state.resource_caps[r] = 0.0
+        st.session_state.custom_resources = []
+        st.session_state.enabled_methods = {}
+        st.success("All resource values reset to 0.")
+        st.rerun()
+
+    st.markdown('<p class="crra-sub-sub-heading">Import resource values</p>', unsafe_allow_html=True)
+    col_template, col_upload = st.columns([1, 1])
+    with col_template:
+        st.markdown("<div class='caption'><p>Use the template below to fill in your resource "
+                    "availability values and import them directly into the tool.</p></div>",
+                    unsafe_allow_html=True)
+        with open("data/resource_template.xlsx", "rb") as f:
+            st.download_button(
+                label="Download Excel Template",
+                data=f,
+                file_name="resource_template.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                icon=":material/download:",
+                key="download_button_resource_template"
+            )
+    with col_upload:
+        uploaded_file = st.file_uploader(
+            "Upload your Excel file", type="xlsx",
+            key=f"resource_uploader_{st.session_state.get('resource_uploader_key', 0)}"
+        )
+        if uploaded_file is not None and uploaded_file.name != st.session_state.get("resource_last_loaded_file"):
+            try:
+                df = pd.read_excel(uploaded_file)
+                required_cols = {"Resource", "Available Amount"}
+                if not required_cols.issubset(df.columns):
+                    raise ValueError(f"Missing columns: {required_cols - set(df.columns)}")
+                for r in st.session_state.resource_caps:
+                    st.session_state.resource_caps[r] = 0.0
+                    st.session_state[f"cap_{r}"] = 0.0
+                for _, row in df.iterrows():
+                    r = row["Resource"]
+                    val = row["Available Amount"]
+                    if r not in st.session_state.resource_caps:
+                        continue
+                    try:
+                        val = 0.0 if pd.isna(val) else float(val)
+                    except (ValueError, TypeError):
+                        val = 0.0
+                    st.session_state.resource_caps[r] = val
+                    st.session_state[f"cap_{r}"] = val
+                st.session_state["resource_last_loaded_file"] = uploaded_file.name
+                st.success("Resource values imported successfully.", icon="✅")
+                for key in ["excel_loaded_file", "scenario_name_suggestion",
+                            "scenario_loaded_file", "input_file_name_suggestion", "latest_result"]:
+                    st.session_state.pop(key, None)
+                st.rerun()
+            except Exception as e:
+                st.error(f"Error importing resource values: {e}")
+        elif st.session_state.get("resource_last_loaded_file"):
+            st.success(f"Loaded: **{st.session_state['resource_last_loaded_file']}**", icon="✅")
+
+    # Standard resource inputs
+    st.markdown('<p class="crra-sub-heading">Set available resources for one year</p>', unsafe_allow_html=True)
+
+    # Build a lookup: for each CDR method, which resources are "primary" (mandatory)?
+    # Secondary resources are optional add-ons — a method can still run without them.
+    # A method can only run in the optimisation if at least one primary resource is available.
+    method_to_primary_resources = {}
+    for cdr_method, resource_coeffs in cost_sliders.items():
+        for name in resource_coeffs:
+            r_clean = strip_unit_suffix(name)
+            if (cdr_method, r_clean) not in secondary_resources:
+                method_to_primary_resources.setdefault(cdr_method, []).append(r_clean)
+
+    for r in method_to_primary_resources:
+        pass  # no-op, kept for clarity of intent below
+
+    resource_to_group = get_resource_to_group()
+
+    for group, rlist in resource_groups.items():
+        unit = resource_unit_map.get(group, "")
+        with st.expander(f"**{group}** ({unit})", expanded=True):
+
+            cols = st.columns(4)
+
+            for i, r in enumerate(rlist):
+
+                tooltip = resource_tooltips.get(r, None)
+                name_clean = r.split(" (")[0]
+
+                with cols[i % 4]:
+
+                    render_resource_input(name_clean, r, tooltip=tooltip)
+
+                    related_methods = {}
+                    related_by_group = {}
+
+                    for cdr_method, resource in cost_sliders.items():
+                        for name, coeff in resource.items():
+                            if r == strip_unit_suffix(name):
+                                related_methods[cdr_method] = coeff
+
+                    for m in related_methods:
+                        related_by_group.setdefault(get_method_group(m), []).append(m)
+
+                    related_method_names = list(related_methods.keys())
+                    secondary_for_r = [m for m in related_method_names if (m, r) in secondary_resources]
+                    primary_for_r = [m for m in related_method_names if (m, r) not in secondary_resources]
+
+                    if r not in st.session_state.enabled_methods:
+                        st.session_state.enabled_methods[r] = {}
+                    for m in related_method_names:
+                        st.session_state.enabled_methods[r].setdefault(m, True)
+                    popover_key_prefix = f"pop_{r}"
+
+                    with st.popover(
+                        f":material/tune: Related CDR Methods",
+                        width='stretch',
+                    ):
+                        for method_group, methods in related_by_group.items():
+                            primary_in_group = [m for m in methods if m in primary_for_r]
+                            if not primary_in_group:
+                                continue
+                            st.markdown(f"*{method_group}*")
+                            for m in primary_in_group:
+                                widget_key = f"{popover_key_prefix}_{m}"
+                                if widget_key not in st.session_state:
+                                    st.session_state[widget_key] = st.session_state.enabled_methods[r][m]
+
+                                checked = st.checkbox(m, key=widget_key)
+                                st.session_state.enabled_methods[r][m] = checked
+
+                        if secondary_for_r:
+                            st.caption(
+                                "Secondary methods that can be added in the **Resource Coefficient** tab:\n\n"
+                                + "\n".join(f"- {m}" for m in secondary_for_r)
+                            )
+
+                    for m in secondary_for_r:
+                        st.session_state.enabled_methods[r][m] = True
+
+            # Custom batches for this group
+            group_unit = resource_unit_map.get(group, "")
+            group_batches = [
+                (idx, b) for idx, b in enumerate(st.session_state.get("custom_resources", []))
+                if resource_to_group.get(b["group"]) == group
+            ]
+            for global_idx, batch in group_batches:
+                _render_custom_batch_inline(global_idx, batch, cost_sliders, group_unit)
+            
+            _, col_button = st.columns([3,1])
+            with col_button:
+                if st.button(
+                    "Add resource", key=f"simple-btn-resource-{group}",
+                    type="tertiary", icon=":material/add:", width='stretch'
+                ):
+                    dialog_add_custom_resource(cost_sliders, preset_resources=rlist)
+
+    # ── AUTO-DISABLE LOGIC ────────────────────────────────────────────────────
+    # A CDR method cannot run in the optimisation if it has no usable resources.
+    # This block detects that situation automatically and deactivates the method
+    # in the Method Constraints tab — so the optimisation never fails silently.
+    #
+    # The logic runs in three steps every time this tab renders:
+    #   1. Count how many active primary resources each method still has.
+    #   2. Re-enable any method that was auto-disabled and now has resources again
+    #      (e.g. the user re-entered a value). Methods the user manually disabled
+    #      are stored separately and are NOT touched here.
+    #   3. Disable any method whose resource count just dropped to zero, and show
+    #      a notification so the user knows what changed.
+    # ─────────────────────────────────────────────────────────────────────────
+
+    # Step 1 – count active primary resources per method (secondary resources are
+    # optional extras; they do not determine whether a method can run).
+    method_active_resource_count = {}
+    for r, methods in st.session_state.enabled_methods.items():
+        for m, ok in methods.items():
+            if (m, r) in secondary_resources:
+                continue
+            method_active_resource_count.setdefault(m, 0)
+            if ok:
+                method_active_resource_count[m] += 1
+
+    # Custom batches also count as active resources for the methods they are
+    # assigned to, even when the standard reference resource is toggled off.
+    for batch in st.session_state.get("custom_resources", []):
+        if float(batch.get("amount") or 0) <= 0:
+            continue
+        for m_name in batch.get("methods", {}).keys():
+            method_active_resource_count.setdefault(m_name, 0)
+            method_active_resource_count[m_name] += 1
+
+    methods_with_no_active_resource = [
+        m for m in method_to_primary_resources
+        if method_active_resource_count.get(m, 0) == 0
+    ]
+
+    # Step 2 – re-enable methods that the tool previously auto-disabled but that
+    # now have at least one active resource (user restored a value or added a batch).
+    for m in list(st.session_state.auto_disabled_methods):
+        if method_active_resource_count.get(m, 0) > 0:
+            if m in st.session_state.constraints:
+                st.session_state.constraints[m]["active"] = True
+            toggle_key = f"toggle_{m}"
+            if toggle_key in st.session_state:
+                st.session_state[toggle_key] = True
+            st.session_state.auto_disabled_methods.discard(m)
+
+    # Step 3 – disable methods that now have zero active primary resources.
+    # We record which methods the tool disabled (auto_disabled_methods) so that
+    # step 2 can safely re-enable them later without touching user-chosen settings.
+    newly_disabled = []
+    for m in methods_with_no_active_resource:
+        if st.session_state.constraints.get(m, {}).get("active", True):
+            st.session_state.constraints.setdefault(m, {"active": True, "cap_type": "percent", "cap_value": 100})
+            st.session_state.constraints[m]["active"] = False
+            st.session_state.auto_disabled_methods.add(m)
+            newly_disabled.append(m)
+            toggle_key = f"toggle_{m}"
+            if toggle_key in st.session_state:
+                st.session_state[toggle_key] = False
+
+    if newly_disabled:
+        st.info(
+            "The following methods have no active resource left and were "
+            "automatically deactivated (see Method constraints tab): "
+            + ", ".join(newly_disabled),
+            icon=":material/info:"
+        )
+
+
+    panel_custom_resources_controls(cost_sliders)
+
+    st.markdown('<p class="crra-sub-heading">Summary of available resources</p>', unsafe_allow_html=True)
+
+    resource_to_unit = get_resource_to_unit()
+
+    df_caps = pd.DataFrame.from_dict(
+        {r: st.session_state.resource_caps[r] for r in resource_order
+         if st.session_state.resource_caps.get(r, 0.0) > 0},
+        orient="index", columns=["Available Amount"],
+    ).reindex(resource_order).dropna()
+    df_caps["Available Amount"] = [
+        f"{value:,.2f} {resource_to_unit.get(resource, '?')}"
+        for resource, value in df_caps["Available Amount"].items()
+    ]
+
+    custom_rows = []
+    for batch in st.session_state.get("custom_resources", []):
+        group = resource_to_group.get(batch["group"])
+        unit = resource_unit_map.get(group, "?")
+        custom_rows.append({
+            "Resource": batch["name"],
+            "Available Amount": f"{float(batch['amount']):,.2f} {unit}",
+        })
+
+    if not df_caps.empty or custom_rows:
+        dfs = []
+        if not df_caps.empty:
+            df_std = df_caps.copy()
+            df_std["Type"] = "Standard"
+            dfs.append(df_std)
+        if custom_rows:
+            df_custom = pd.DataFrame(custom_rows).set_index("Resource")
+            df_custom["Type"] = "New"
+            dfs.append(df_custom)
+        df_all = pd.concat(dfs)[["Available Amount", "Type"]].reset_index().rename(columns={"index": "Resource"})
+        num_rows = len(df_all)
+        st.dataframe(
+            df_all,
+            width='stretch',
+            hide_index=True,
+            height=(num_rows * 36 + 36),
+            column_config={
+                "Resource": st.column_config.TextColumn("Resource", width="large"),
+                "Available Amount": st.column_config.TextColumn("Available Amount"),
+                "Type": st.column_config.TextColumn("Type"),
+            },
+            row_height=36
+        )
+    else:
         st.error("No resources defined yet. Set availability above to populate the summary table.")

tabs/tab2_constraints.py

@@ -1,188 +1,201 @@
-# tabs/tab2_constraints.py
-
-import pandas as pd
-import streamlit as st
-
-from config.config import CO2_UNIT, method_groups, method_order, method_tooltips
-from utils.ui_helpers import show_bar
-
-
-# ─── Helpers ─────────────────────────────────────────────────────────────────
-
-def default_constraint():
-    return {"active": True, "cap_type": "percent", "cap_value": int(100)}
-
-
-def render_method(m, cols, i):
-    with cols[i % 3]:
-        tooltip = method_tooltips.get(m, None)
-
-        # ─────────────────────────────────────────
-        # INIT SAFE
-        # ─────────────────────────────────────────
-        if m not in st.session_state.constraints:
-            st.session_state.constraints[m] = default_constraint()
-
-        constraint = st.session_state.constraints[m]
-
-        toggle_key = f"toggle_{m}"
-        cap_type_key = f"cap_type_{m}"
-        slider_key = f"slider_{m}"
-        manual_key = f"manual_{m}"
-
-        # init widgets ONLY from constraint (not reverse)
-        st.session_state.setdefault(toggle_key, constraint["active"])
-        st.session_state.setdefault(cap_type_key, constraint["cap_type"])
-
-        if constraint["cap_type"] == "percent":
-            st.session_state.setdefault(slider_key, int(constraint["cap_value"]))
-        else:
-            st.session_state.setdefault(manual_key, float(constraint["cap_value"]))
-
-        # ─────────────────────────────────────────
-        # TOGGLE
-        # ─────────────────────────────────────────
-        is_active = st.toggle(m, key=toggle_key, help=tooltip)
-
-        st.session_state.constraints[m]["active"] = is_active
-
-        if not is_active:
-            return
-
-        # ─────────────────────────────────────────
-        # CAP TYPE
-        # ─────────────────────────────────────────
-        cap_type = st.radio(
-            "Cap value type",
-            ["percent", "absolute"],
-            horizontal=True,
-            key=cap_type_key,
-            format_func=lambda x: "% of total potential"
-            if x == "percent"
-            else f"Absolute ({CO2_UNIT}/yr)",
-            label_visibility="collapsed",
-        )
-
-        st.session_state.constraints[m]["cap_type"] = cap_type
-
-        # ─────────────────────────────────────────
-        # PERCENT
-        # ─────────────────────────────────────────
-        if cap_type == "percent":
-
-            value = st.slider(
-                "Max share (%)",
-                0, 100, step=5,
-                key=slider_key,
-            )
-
-            st.session_state.constraints[m]["cap_value"] = value
-
-            if value == 0:
-                st.warning("Cap is 0% but method is active.", icon=":material/warning:")
-
-        # ─────────────────────────────────────────
-        # ABSOLUTE
-        # ─────────────────────────────────────────
-        else:
-            value = st.number_input(
-                f"Max cap ({CO2_UNIT}/yr)",
-                min_value=0.0,
-                format="%.2f",
-                value=None,
-                placeholder="0.00",
-                key=manual_key,
-            )
-
-            st.session_state.constraints[m]["cap_value"] = float(value) if value is not None else 0.0
-
-            if not value:
-                st.warning(f"Cap is 0 {CO2_UNIT}/yr but method is active.", icon=":material/warning:")
-
-def reset_all_constraints():
-    for m in method_order:
-        st.session_state.constraints[m] = default_constraint()
-        for key in [f"toggle_type_{m}", f"cap_type_{m}", f"slider_{m}_widget", f"manual_{m}_widget"]:
-            st.session_state.pop(key, None)
-    st.success("All method constraints reset to default.")
-    st.rerun()
-
-
-def build_summary_df():
-    """Build summary dataframe for active methods."""
-    rows = {}
-    for m in method_order:
-        c = st.session_state.constraints[m]
-        if not c["active"]:
-            continue
-        if c["cap_type"] == "percent":
-            rows[m] = {"Cap value": f"{c['cap_value']}%"}
-        else:
-            rows[m] = {"Cap value": f"{c['cap_value']:,.2f} {CO2_UNIT}/yr"}
-    return pd.DataFrame.from_dict(rows, orient="index") if rows else None
-
-
-# ─── Main render ─────────────────────────────────────────────────────────────
-
-def render_tab():
-    st.markdown('<h1 class="crra-heading">Method constraints</h1>', unsafe_allow_html=True)
-    show_bar()
-    
-    st.markdown(
-        """
-        <p class="objective_title">OBJECTIVE</p>
-        """,
-        unsafe_allow_html=True,
-    )
-
-    st.markdown(
-        """
-        <div class="text_with_border">
-            <p>
-            This section lets you control which CDR methods are included in the optimization
-            and set a <strong>maximum deployment cap</strong> per method.<br>
-            <li>Activate or deactivate individual methods</li>
-            <li>Cap each method by <strong>% of its total potential</strong> or by an
-            <strong>absolute value</strong> in {CO2_UNIT}/yr</li>
-            </p>
-        </div>
-        """.format(CO2_UNIT=CO2_UNIT),
-        unsafe_allow_html=True,
-    )
-
-    with st.expander("Manage methods", expanded=True, icon=":material/settings:"):
-        for group, method_list in method_groups.items():
-            st.markdown(f"""
-                <p class="crra-group-name">{group}</p>""",
-                unsafe_allow_html=True,
-            )
-            cols = st.columns(3)
-            for i, m in enumerate(method_list):
-                render_method(m, cols, i)
-
-    st.divider()
-    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
-        reset_all_constraints()
-
-    st.markdown("""
-        <p class="crra-sub-heading">Summary of Active methods and caps</p>""",
-        unsafe_allow_html=True,
-    )
-    df = build_summary_df()
-    if df is not None:
-        df_display = df.reset_index().rename(columns={"index": "CDR Method"})
-        df_display = df_display[["CDR Method", "Cap value"]]
-        num_rows = len(df_display)
-        st.dataframe(
-            df_display,
-            use_container_width=True,
-            hide_index=True,
-            height=(num_rows * 36 + 36),
-            column_config={
-                "CDR Method": st.column_config.TextColumn("CDR Method", width="large"),
-                "Cap value": st.column_config.TextColumn("Cap value"),
-            },
-            row_height=36
-        )
-    else:
+import pandas as pd
+import streamlit as st
+
+from config.config import CO2_UNIT, method_groups, method_order, method_tooltips
+from utils.ui_helpers import show_bar
+
+
+
+def default_constraint():
+    """Return the default constraint dict for a CDR method (active, 100% cap).
+
+    Returns:
+        dict: {"active": True, "cap_type": "percent", "cap_value": 100}.
+    """
+    return {"active": True, "cap_type": "percent", "cap_value": int(100)}
+
+
+def render_method(m, cols, i):
+    """Render the constraint widget group (toggle + cap slider/input) for one method.
+
+    Writes the result into st.session_state.constraints[m].
+
+    Args:
+        m (str): CDR method name.
+        cols (list): list of Streamlit column objects.
+        i (int): index used to pick the column (i % 3).
+
+    Returns:
+        None
+    """
+    with cols[i % 3]:
+        tooltip = method_tooltips.get(m, None)
+
+        if m not in st.session_state.constraints:
+            st.session_state.constraints[m] = default_constraint()
+
+        constraint = st.session_state.constraints[m]
+
+        toggle_key = f"toggle_{m}"
+        cap_type_key = f"cap_type_{m}"
+        slider_key = f"slider_{m}"
+        manual_key = f"manual_{m}"
+
+        # init widgets ONLY from constraint (not reverse)
+        st.session_state.setdefault(toggle_key, constraint["active"])
+        st.session_state.setdefault(cap_type_key, constraint["cap_type"])
+
+        if constraint["cap_type"] == "percent":
+            st.session_state.setdefault(slider_key, int(constraint["cap_value"]))
+        else:
+            st.session_state.setdefault(manual_key, float(constraint["cap_value"]))
+
+        is_active = st.toggle(m, key=toggle_key, help=tooltip)
+
+        st.session_state.constraints[m]["active"] = is_active
+
+        if not is_active:
+            return
+
+        cap_type = st.radio(
+            "Cap value type",
+            ["percent", "absolute"],
+            horizontal=True,
+            key=cap_type_key,
+            format_func=lambda x: "% of total potential"
+            if x == "percent"
+            else f"Absolute ({CO2_UNIT}/yr)",
+            label_visibility="collapsed",
+        )
+
+        st.session_state.constraints[m]["cap_type"] = cap_type
+
+        if cap_type == "percent":
+
+            value = st.slider(
+                "Max share (%)",
+                0, 100, step=5,
+                key=slider_key,
+            )
+
+            st.session_state.constraints[m]["cap_value"] = value
+
+            if value == 0:
+                st.warning("Cap is 0% but method is active.", icon=":material/warning:")
+
+        else:
+            value = st.number_input(
+                f"Max cap ({CO2_UNIT}/yr)",
+                min_value=0.0,
+                format="%.2f",
+                value=None,
+                placeholder="0.00",
+                key=manual_key,
+            )
+
+            st.session_state.constraints[m]["cap_value"] = float(value) if value is not None else 0.0
+
+            if not value:
+                st.warning(f"Cap is 0 {CO2_UNIT}/yr but method is active.", icon=":material/warning:")
+
+def reset_all_constraints():
+    """Reset all method constraints to their default values and rerun the app.
+
+    Returns:
+        None
+    """
+    for m in method_order:
+        st.session_state.constraints[m] = default_constraint()
+        for key in [f"toggle_type_{m}", f"cap_type_{m}", f"slider_{m}_widget", f"manual_{m}_widget"]:
+            st.session_state.pop(key, None)
+    st.success("All method constraints reset to default.")
+    st.rerun()
+
+
+def build_summary_df():
+    """Build a summary DataFrame of currently active methods and their caps.
+
+    Returns:
+        pd.DataFrame | None: index = method name, column "Cap value" as a formatted
+                             string. Returns None if no method is active.
+    """
+    rows = {}
+    for m in method_order:
+        c = st.session_state.constraints[m]
+        if not c["active"]:
+            continue
+        if c["cap_type"] == "percent":
+            rows[m] = {"Cap value": f"{c['cap_value']}%"}
+        else:
+            rows[m] = {"Cap value": f"{c['cap_value']:,.2f} {CO2_UNIT}/yr"}
+    return pd.DataFrame.from_dict(rows, orient="index") if rows else None
+
+
+
+def render_tab():
+    """Render the Method Constraints tab.
+
+    Returns:
+        None
+    """
+    st.markdown('<h1 class="crra-heading">Method constraints</h1>', unsafe_allow_html=True)
+    show_bar()
+    
+    st.markdown(
+        """
+        <p class="objective_title">OBJECTIVE</p>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+        <div class="text_with_border">
+            <p>
+            This section lets you control which CDR methods are included in the optimization
+            and set a <strong>maximum deployment cap</strong> per method.<br>
+            <li>Activate or deactivate individual methods</li>
+            <li>Cap each method by <strong>% of its total potential</strong> or by an
+            <strong>absolute value</strong> in {CO2_UNIT}/yr</li>
+            </p>
+        </div>
+        """.format(CO2_UNIT=CO2_UNIT),
+        unsafe_allow_html=True,
+    )
+
+    with st.expander("Manage methods", expanded=True, icon=":material/settings:"):
+        for group, method_list in method_groups.items():
+            st.markdown(f"""
+                <p class="crra-group-name">{group}</p>""",
+                unsafe_allow_html=True,
+            )
+            cols = st.columns(3)
+            for i, m in enumerate(method_list):
+                render_method(m, cols, i)
+
+    st.divider()
+    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
+        reset_all_constraints()
+
+    st.markdown("""
+        <p class="crra-sub-heading">Summary of Active methods and caps</p>""",
+        unsafe_allow_html=True,
+    )
+    df = build_summary_df()
+    if df is not None:
+        df_display = df.reset_index().rename(columns={"index": "CDR Method"})
+        df_display = df_display[["CDR Method", "Cap value"]]
+        num_rows = len(df_display)
+        st.dataframe(
+            df_display,
+            width='stretch',
+            hide_index=True,
+            height=(num_rows * 36 + 36),
+            column_config={
+                "CDR Method": st.column_config.TextColumn("CDR Method", width="large"),
+                "Cap value": st.column_config.TextColumn("Cap value"),
+            },
+            row_height=36
+        )
+    else:
         st.warning("No active methods selected.")

tabs/tab3_coefficients.py

@@ -1,422 +1,510 @@
-import pandas as pd
-import streamlit as st
-
-from config.config import (method_groups, method_order, resource_groups,
-                           resource_order, secondary_resources, resource_unit_map, CO2_UNIT)
-from utils.ui_helpers import format_efficiency_summary, show_bar
-from utils.data_utils import strip_unit_suffix
-
-def _normalize_costs(costs_dict: dict) -> dict:
-    """Strip unit suffixes from resource keys for legacy scenario compatibility."""
-    return {strip_unit_suffix(r): v for r, v in costs_dict.items()}
-
-def _get_slider_params(conf: dict) -> tuple:
-    """Return (step, fmt) based on the min value of a slider config."""
-    min_val = conf["min"]
-    if min_val < 0.01:
-        return 0.0001, "%.4f"
-    elif min_val < 1:
-        return 0.001, "%.3f"
-    elif min_val < 100:
-        return 0.01, "%.2f"
-    else:
-        return 1.0, "%.0f"
-
-def is_method_enabled(method, resource, enabled_methods):
-    return enabled_methods.get(resource, {}).get(method, True)
-
-def _make_sync_s_to_m(slider_key, manual_key):
-    """on_change for slider: mirror its value into the number_input."""
-    def _sync():
-        st.session_state[manual_key] = st.session_state[slider_key]
-    return _sync
-
-def _make_sync_m_to_s(slider_key, manual_key, min_val, max_val):
-    """on_change for number_input: clamp to [min, max] and sync both widgets."""
-    def _sync():
-        val = st.session_state[manual_key]
-        if val is None:
-            return
-        clamped = max(min_val, min(max_val, val))
-        st.session_state[manual_key] = clamped
-        st.session_state[slider_key] = clamped
-    return _sync
-
-
-def _enforce_disabled_coefficients():
-    # Intentionally a no-op: disabling a method for a resource must NOT permanently
-    # zero the stored coefficient in session state, because re-enabling would then
-    # see an existing key at 0 and the pre-init would skip restoration.
-    # The LP in optimization.py already applies enabled_methods at call time
-    # (zeroing only for that run, without mutating session state).
-    pass
-
-
-def render_tab(cost_sliders):
-    st.markdown('<h1 class="crra-heading">Resource efficiency coefficients</h1>', unsafe_allow_html=True)
-    show_bar()
-    
-    st.markdown(
-        """
-        <p class="objective_title">OBJECTIVE</p>
-        """,
-        unsafe_allow_html=True,
-    )
-
-    st.markdown(
-        """
-        <div class="text_with_border">
-            <p>
-            This section lets you adjust the resource usage coefficients for each CDR method to best fit your country conditions.<br>
-            <li>Primary resources are always active and initialized with default values.</li>
-            <li>Secondary resources are initialized at zero and toggled off by default.</li>
-            <li>Toggling on a secondary resource restores its default value.</li>
-            </p>
-        </div>
-        """.format(CO2_UNIT=CO2_UNIT),
-        unsafe_allow_html=True,
-    )
-
-    with st.container(key="warning_resources"):
-        st.warning(
-            "Red cells in the table highlight coefficients modified from their **default median values**",
-            icon=":material/warning:"
-        )
-
-    # Read the live, per-resource manual allocation state (set in tab1) and the
-    # custom resource batches — both are read fresh on every render, not cached
-    # at import time, so toggling a method on/off in tab1 is reflected here
-    # immediately without needing a session restart.
-    enabled_methods = st.session_state.get("enabled_methods", {})
-    custom_resources = st.session_state.get("custom_resources", [])
-
-    _enforce_disabled_coefficients()
-
-    # Normalize cost_sliders once: strip unit suffixes from resource keys
-    # cost_sliders_norm[method][resource_name] = {min, median, max}
-    cost_sliders_norm = {
-        m: _normalize_costs(resources)
-        for m, resources in cost_sliders.items()
-    }
-
-    # Build resource display labels: "Arable land" -> "Arable land (Mha/MtCO2)"
-    resource_display = {
-        r: f"{r} ({resource_unit_map[cat]}/{CO2_UNIT})"
-        for cat, resources in resource_groups.items()
-        for r in resources
-    }
-
-    # Custom (user-added) resources: name -> {method: {min, median, max}}.
-    # Primary links come from the dialog (batch["methods"]).
-    # Secondary links are auto-injected: when the reference resource (batch["group"])
-    # is secondary for a method, inherit that method's coefficients automatically.
-    custom_sliders_by_method = {}
-    custom_resource_names = set()
-    for batch in custom_resources:
-        r_name = batch["name"]
-        custom_resource_names.add(r_name)
-        # Explicit primary links chosen in the dialog
-        for m, coefs in batch["methods"].items():
-            custom_sliders_by_method.setdefault(m, {})[r_name] = coefs
-        # Auto-inject secondary method links from reference resource cost_sliders
-        ref = batch["group"]
-        for m, resources in cost_sliders_norm.items():
-            if (m, ref) in secondary_resources and r_name not in custom_sliders_by_method.get(m, {}):
-                ref_coefs = resources.get(ref)
-                if ref_coefs:
-                    custom_sliders_by_method.setdefault(m, {})[r_name] = ref_coefs
-
-    # custom resource name → reference resource name (batch["group"])
-    custom_resource_to_sub_group = {
-        batch["name"]: batch["group"]
-        for batch in custom_resources
-    }
-    resource_to_group = {
-        r: group
-        for group, resources in resource_groups.items()
-        for r in resources
-    }
-    custom_resource_to_group = {
-        r: resource_to_group[s_g]
-        for r, s_g in custom_resource_to_sub_group.items()
-        if s_g in resource_to_group
-    }
-
-    def is_custom_secondary(method_name, custom_r):
-        """True if the reference resource for custom_r is secondary for method_name."""
-        sub_group = custom_resource_to_sub_group.get(custom_r)
-        return sub_group is not None and (method_name, sub_group) in secondary_resources
-
-    # Build reverse index: custom resource name → set of valid methods
-    valid_methods_for_custom = {}
-    for m, resources in custom_sliders_by_method.items():
-        for r in resources:
-            valid_methods_for_custom.setdefault(r, set()).add(m)
-
-    # Remove stale session state entries: a method should not carry a custom
-    # resource coefficient if it is not linked to that batch (neither as
-    # explicit primary nor as secondary auto-injection).  Stale values can
-    # persist across reruns and cause the LP to create spurious z-pairs.
-    for r_name, valid in valid_methods_for_custom.items():
-        for m in list(st.session_state.get("costs", {}).keys()):
-            if r_name in st.session_state.costs.get(m, {}) and m not in valid:
-                del st.session_state.costs[m][r_name]
-
-    # Pre-initialize costs for custom resources so the summary table shows the
-    # correct value immediately, without needing to open the expander first.
-    # Secondary custom resources start at 0 (like standard secondary resources).
-    for m, resources in custom_sliders_by_method.items():
-        st.session_state.costs.setdefault(m, {})
-        for r, conf in resources.items():
-            if r not in st.session_state.costs[m]:
-                st.session_state.costs[m][r] = 0.0 if is_custom_secondary(m, r) else conf["median"]
-
-    # ── Method selector ──────────────────────────────────────────────────────
-    method_choices = []
-    method_lookup = {}
-    for group, methods in method_groups.items():
-        for method in methods:
-            label = f"{group} | {method}"
-            method_choices.append(label)
-            method_lookup[label] = method
-
-    selected_label = st.selectbox("Select a method:", method_choices, key="crra-select")
-
-    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
-        for m, sliders in cost_sliders_norm.items():
-            for r, conf in sliders.items():
-                is_secondary = (m, r) in secondary_resources
-                st.session_state.costs[m][r] = 0.0 if is_secondary else conf["median"]
-                for prefix in ["slider", "manual", "toggle"]:
-                    st.session_state.pop(f"{prefix}_{m}_{r}".replace(" ", "_").lower(), None)
-        for m, sliders in custom_sliders_by_method.items():
-            for r, conf in sliders.items():
-                st.session_state.costs.setdefault(m, {})[r] = 0.0 if is_custom_secondary(m, r) else conf["median"]
-                for prefix in ["slider", "manual", "toggle"]:
-                    st.session_state.pop(f"{prefix}_{m}_{r}".replace(" ", "_").lower(), None)
-        st.success("All methods reset to default values.")
-        st.rerun()
-
-    method = method_lookup[selected_label]
-
-    # ── Resource sliders ─────────────────────────────────────────────────────
-    with st.expander(f"Manage resources for **{method}**", expanded=True):
-        method_sliders = cost_sliders_norm.get(method, {})
-        print(method_sliders)
-        method_costs_norm = _normalize_costs(st.session_state.costs.get(method, {}))
-        custom_for_method = custom_sliders_by_method.get(method, {})
-
-        for group_name, rlist in resource_groups.items():
-            used = [r for r in rlist if r in method_sliders]
-            print(used)
-            custom_in_group = [
-                r for r in custom_for_method
-                if custom_resource_to_group.get(r) == group_name
-            ] if custom_for_method else []
-
-            if not used and not custom_in_group:
-                continue
-            st.markdown(f"""
-                <p class="crra-group-name">{group_name}</p>""",
-                unsafe_allow_html=True,
-            )
-            for r in used:
-                enabled = is_method_enabled(method, r, enabled_methods)
-                if not enabled:
-                    st.info(f"INFO: Method disabled for **{r}** (see Resource Inputs tab)")
-                    continue
-                conf = method_sliders[r]
-                display_label = resource_display.get(r, r)
-                step, fmt = _get_slider_params(conf)
-                is_secondary = (method, r) in secondary_resources
-
-                toggle_key = f"toggle_{method}_{r}".replace(" ", "_").lower()
-                slider_key = f"slider_{method}_{r}".replace(" ", "_").lower()
-                manual_key = f"manual_{method}_{r}".replace(" ", "_").lower()
-
-                current_val = method_costs_norm.get(r, 0.0)
-
-                if is_secondary:
-                    if toggle_key not in st.session_state:
-                        st.session_state[toggle_key] = current_val != 0.0
-                    enabled = st.checkbox(f"Use {display_label}", key=toggle_key)
-                    if not enabled:
-                        st.session_state.costs[method][r] = 0.0
-                        st.markdown("**DISABLED**")
-                        continue
-                    elif current_val == 0.0:
-                        st.session_state.costs[method][r] = conf["median"]
-                        current_val = conf["median"]
-
-                if conf["min"] == conf["max"]:
-                    st.markdown(f"""<p class="crra-resource-name">{display_label} = <strong>{conf['median']}</strong> (fixed)</p>""", unsafe_allow_html=True)
-                    st.session_state.costs[method][r] = conf["median"]
-                    if st.session_state.get("resource_caps", {}).get(r, 0) <= 0:
-                        st.info(f"No available quantity set for **{r}** in Resource Inputs tab: **{method}** won't be used in the optimization.", icon=":material/info:")
-                    continue
-
-                if slider_key not in st.session_state:
-                    st.session_state[slider_key] = current_val
-                if manual_key not in st.session_state:
-                    st.session_state[manual_key] = st.session_state[slider_key]
-                print(r)
-                if st.session_state.get("resource_caps", {}).get(r, 0) <= 0:
-                    st.info(f"No available quantity set for **{r}** in Resource Inputs tab: **{method}** won't be used in the optimization.", icon=":material/info:")
-
-                col1, col2 = st.columns([3, 1])
-                with col1:
-                    slider_val = st.slider(
-                        label=display_label,
-                        min_value=conf["min"],
-                        max_value=conf["max"],
-                        step=step,
-                        format=fmt,
-                        key=slider_key,
-                        on_change=_make_sync_s_to_m(slider_key, manual_key),
-                    )
-                with col2:
-                    st.number_input(
-                        label="label",
-                        label_visibility="collapsed",
-                        key=manual_key,
-                        help="Manual override (optional, any value)",
-                        format=fmt,
-                        value=None,
-                        placeholder=str(round(slider_val, 4)),
-                        on_change=_make_sync_m_to_s(slider_key, manual_key, conf["min"], conf["max"]),
-                    )
-
-                _mv = st.session_state.get(manual_key)
-                st.session_state.costs[method][r] = slider_val if _mv is None else _mv
-
-
-            # ── New (custom) resources linked to this method ────────────────
-
-            for r in custom_in_group:
-                conf = custom_for_method[r]
-                enabled = is_method_enabled(method, r, enabled_methods)
-                if not enabled:
-                    st.info("INFO: Method disabled for this resource (see Resource Inputs tab)")
-                    continue
-
-                _is_cust_secondary = is_custom_secondary(method, r)
-                display_label = r
-                step, fmt = _get_slider_params(conf)
-                toggle_key = f"toggle_{method}_{r}".replace(" ", "_").lower()
-                slider_key = f"slider_{method}_{r}".replace(" ", "_").lower()
-                manual_key = f"manual_{method}_{r}".replace(" ", "_").lower()
-
-                current_val = st.session_state.costs.get(method, {}).get(r, 0.0 if _is_cust_secondary else conf["median"])
-
-                if _is_cust_secondary:
-                    if toggle_key not in st.session_state:
-                        st.session_state[toggle_key] = current_val != 0.0
-                    use_resource = st.checkbox(f"Use {display_label}", key=toggle_key)
-                    if not use_resource:
-                        st.session_state.costs.setdefault(method, {})[r] = 0.0
-                        st.markdown("**DISABLED**")
-                        continue
-                    elif current_val == 0.0:
-                        st.session_state.costs.setdefault(method, {})[r] = conf["median"]
-                        current_val = conf["median"]
-
-                if slider_key not in st.session_state:
-                    st.session_state[slider_key] = current_val
-                if manual_key not in st.session_state:
-                    st.session_state[manual_key] = st.session_state[slider_key]
-
-                batch_amount = next((float(b.get("amount", 0)) for b in custom_resources if b["name"] == r), 0.0)
-                if batch_amount <= 0:
-                    st.info(f"No available quantity set for **{r}** in Resource Inputs — this method won't be used in the optimization.", icon=":material/info:")
-
-                col1, col2 = st.columns([3, 1])
-                with col1:
-                    slider_val = st.slider(
-                        label=display_label,
-                        min_value=conf["min"],
-                        max_value=conf["max"],
-                        step=step,
-                        format=fmt,
-                        key=slider_key,
-                        on_change=_make_sync_s_to_m(slider_key, manual_key),
-                    )
-                with col2:
-                    st.number_input(
-                        label="label",
-                        label_visibility="collapsed",
-                        key=manual_key,
-                        help="Manual override (optional, any value)",
-                        format=fmt,
-                        value=None,
-                        placeholder=str(round(slider_val, 4)),
-                        on_change=_make_sync_m_to_s(slider_key, manual_key, conf["min"], conf["max"]),
-                    )
-
-                st.session_state.costs.setdefault(method, {})
-                _mv = st.session_state.get(manual_key)
-                st.session_state.costs[method][r] = slider_val if _mv is None else _mv
-
-
-        # ── Reset buttons ────────────────────────────────────────────────────
-        if st.button("Reset selected method", key="btn-reset-method", icon=":material/reset_settings:"):
-            for r, conf in cost_sliders_norm.get(method, {}).items():
-                is_secondary = (method, r) in secondary_resources
-                st.session_state.costs[method][r] = 0.0 if is_secondary else conf["median"]
-                for prefix in ["slider", "manual", "toggle"]:
-                    st.session_state.pop(f"{prefix}_{method}_{r}".replace(" ", "_").lower(), None)
-            for r, conf in custom_sliders_by_method.get(method, {}).items():
-                st.session_state.costs.setdefault(method, {})[r] = conf["median"]
-                for prefix in ["slider", "manual"]:
-                    st.session_state.pop(f"{prefix}_{method}_{r}".replace(" ", "_").lower(), None)
-            st.success(f"{method} reset to default values.")
-            st.rerun()
-
-    # ── Summary table ─────────────────────────────────────────────────────────
-    st.markdown("""
-        <p class="crra-sub-heading">Summary of resource usage coefficients</p>""",
-        unsafe_allow_html=True,
-    )
-    all_resource_columns = resource_order + sorted(custom_resource_names)
-
-    df_default = pd.DataFrame(index=method_order, columns=all_resource_columns)
-    df_current = pd.DataFrame(index=method_order, columns=all_resource_columns)
-
-    for m in method_order:
-        current_costs = _normalize_costs(st.session_state.costs.get(m, {}))
-        sliders = dict(cost_sliders_norm.get(m, {}))
-        sliders.update(custom_sliders_by_method.get(m, {}))
-
-        for r in all_resource_columns:
-            is_secondary = (m, r) in secondary_resources or is_custom_secondary(m, r)
-            disabled = not is_method_enabled(m, r, enabled_methods)
-            current_val = 0.0 if disabled else current_costs.get(r, 0.0)
-            default_val = 0.0 if disabled else sliders.get(r, {}).get("median", 0.0)
-
-            if is_secondary and current_val == 0.0:
-                default_val = 0.0
-
-            df_default.at[m, r] = default_val
-            df_current.at[m, r] = current_val
-
-    df_default = df_default.astype(float).fillna(0.0)
-    df_current = df_current.astype(float).fillna(0.0)
-
-    resource_display_full = dict(resource_display)
-    resource_display_full.update({r: r for r in custom_resource_names})
-
-    df_default = df_default.rename(columns=resource_display_full)
-    df_current = df_current.rename(columns=resource_display_full)
-
-    styled = format_efficiency_summary(df_current, df_default)
-    num_rows = len(df_current)
-    st.dataframe(
-        data=styled, 
-        height=(num_rows * 36 + 37),
-        use_container_width=True, 
-        column_config={
-            "_index": st.column_config.TextColumn(
-                "Method",
-                width="large"
-        )},
-        row_height=36
+import pandas as pd
+import streamlit as st
+
+from config.config import (method_groups, method_order, resource_groups,
+                           resource_order, secondary_resources, resource_unit_map, CO2_UNIT)
+from utils.ui_helpers import format_efficiency_summary, show_bar
+from utils.data_utils import strip_unit_suffix, get_resource_to_group
+
+
+def normalize_costs(costs_dict: dict) -> dict:
+    """Strip unit suffixes from resource keys for legacy scenario compatibility."""
+    return {strip_unit_suffix(r): v for r, v in costs_dict.items()}
+
+
+def get_slider_params(conf: dict) -> tuple:
+    """Derive slider step size and display format from a coefficient config dict.
+
+    Args:
+        conf (dict): slider config with key "min" (the minimum coefficient value).
+
+    Returns:
+        tuple[float, str]: (step, fmt) where step is the slider increment and
+                           fmt is a printf-style format string for display.
+    """
+    min_coeff = conf["min"]
+    if min_coeff < 0.01:
+        return 0.0001, "%.4f"
+    elif min_coeff < 1:
+        return 0.001, "%.3f"
+    elif min_coeff < 100:
+        return 0.01, "%.2f"
+    else:
+        return 1.0, "%.0f"
+
+
+def is_method_enabled(method, resource, enabled_methods):
+    """Check whether a method is currently enabled for a given resource.
+
+    Args:
+        method (str): CDR method name.
+        resource (str): resource name.
+        enabled_methods (dict): {resource: {method: bool}} from session state.
+
+    Returns:
+        bool: True if the method is enabled (defaults to True if not explicitly set).
+    """
+    return enabled_methods.get(resource, {}).get(method, True)
+
+
+def is_custom_secondary(method_name, custom_r, custom_resource_to_sub_group):
+    """Return True if the reference resource for custom_r is secondary for method_name.
+
+    Args:
+        method_name (str): CDR method name.
+        custom_r (str): custom batch resource name.
+        custom_resource_to_sub_group (dict): {custom_r: reference_resource}.
+
+    Returns:
+        bool
+    """
+    sub_group = custom_resource_to_sub_group.get(custom_r)
+    return sub_group is not None and (method_name, sub_group) in secondary_resources
+
+
+def make_sync_s_to_m(slider_key, manual_key):
+    """on_change for slider: mirror its value into the number_input."""
+    def sync():
+        st.session_state[manual_key] = st.session_state[slider_key]
+    return sync
+
+
+def make_sync_m_to_s(slider_key, manual_key, min_val, max_val):
+    """on_change for number_input: clamp to [min, max] and sync both widgets."""
+    def sync():
+        val = st.session_state[manual_key]
+        if val is None:
+            return
+        clamped = max(min_val, min(max_val, val))
+        st.session_state[manual_key] = clamped
+        st.session_state[slider_key] = clamped
+    return sync
+
+
+def build_custom_slider_index(cost_sliders_norm, custom_resources):
+    """Build the per-method slider configs and group mappings for custom resource batches.
+
+    Also initialises session-state cost entries for custom resources (primary at
+    median, secondary at 0) and removes stale entries for methods no longer linked
+    to a given batch.
+
+    Args:
+        cost_sliders_norm (dict): {method: {resource: {min, median, max}}} with unit suffixes stripped.
+        custom_resources (list): list of custom batch dicts from session state.
+
+    Returns:
+        tuple[dict, set, dict, dict]:
+            custom_sliders_by_method     – {method: {resource: {min, median, max}}}.
+            custom_resource_names        – set of all custom batch names.
+            custom_resource_to_sub_group – {custom_r: reference_resource}.
+            custom_resource_to_group     – {custom_r: physical_group}.
+    """
+    custom_sliders_by_method = {}
+    custom_resource_names = set()
+    for batch in custom_resources:
+        r_name = batch["name"]
+        custom_resource_names.add(r_name)
+        for m, coefs in batch["methods"].items():
+            custom_sliders_by_method.setdefault(m, {})[r_name] = coefs
+        ref = batch["group"]
+        for m, resources in cost_sliders_norm.items():
+            if (m, ref) in secondary_resources and r_name not in custom_sliders_by_method.get(m, {}):
+                ref_coefs = resources.get(ref)
+                if ref_coefs:
+                    custom_sliders_by_method.setdefault(m, {})[r_name] = ref_coefs
+
+    custom_resource_to_sub_group = {batch["name"]: batch["group"] for batch in custom_resources}
+    resource_to_group = get_resource_to_group()
+    custom_resource_to_group = {
+        r: resource_to_group[s_g]
+        for r, s_g in custom_resource_to_sub_group.items()
+        if s_g in resource_to_group
+    }
+
+    # Remove stale cost entries for methods no longer linked to a batch
+    valid_methods_for_custom = {}
+    for m, resources in custom_sliders_by_method.items():
+        for r in resources:
+            valid_methods_for_custom.setdefault(r, set()).add(m)
+    for r_name, valid in valid_methods_for_custom.items():
+        for m in list(st.session_state.get("costs", {}).keys()):
+            if r_name in st.session_state.costs.get(m, {}) and m not in valid:
+                del st.session_state.costs[m][r_name]
+
+    # Pre-initialise cost entries for custom resources
+    for m, resources in custom_sliders_by_method.items():
+        st.session_state.costs.setdefault(m, {})
+        for r, conf in resources.items():
+            if r not in st.session_state.costs[m]:
+                st.session_state.costs[m][r] = (
+                    0.0 if is_custom_secondary(m, r, custom_resource_to_sub_group) else conf["median"]
+                )
+
+    return custom_sliders_by_method, custom_resource_names, custom_resource_to_sub_group, custom_resource_to_group
+
+
+def render_standard_resource_row(method, r, conf, display_label, enabled_methods):
+    """Render the slider row for a single standard resource coefficient.
+
+    Handles the secondary-resource toggle, fixed-value display, and the
+    slider + manual number_input pair. Writes the result to
+    st.session_state.costs[method][r].
+
+    Args:
+        method (str): CDR method name.
+        r (str): resource name.
+        conf (dict): {min, median, max} for this (method, resource) pair.
+        display_label (str): human-readable resource label with unit.
+        enabled_methods (dict): {resource: {method: bool}} from session state.
+
+    Returns:
+        None
+    """
+    if not is_method_enabled(method, r, enabled_methods):
+        st.info(f"INFO: Method disabled for **{r}** (see Resource Inputs tab)")
+        return
+
+    is_secondary = (method, r) in secondary_resources
+    step, fmt = get_slider_params(conf)
+    toggle_key = f"toggle_{method}_{r}".replace(" ", "_").lower()
+    slider_key = f"slider_{method}_{r}".replace(" ", "_").lower()
+    manual_key = f"manual_{method}_{r}".replace(" ", "_").lower()
+    current_val = normalize_costs(st.session_state.costs.get(method, {})).get(r, 0.0)
+
+    if is_secondary:
+        if toggle_key not in st.session_state:
+            st.session_state[toggle_key] = current_val != 0.0
+        if not st.checkbox(f"Use {display_label}", key=toggle_key):
+            st.session_state.costs[method][r] = 0.0
+            st.markdown("**DISABLED**")
+            return
+        elif current_val == 0.0:
+            st.session_state.costs[method][r] = conf["median"]
+            current_val = conf["median"]
+
+    if conf["min"] == conf["max"]:
+        st.markdown(
+            f'<p class="crra-resource-name">{display_label} = <strong>{conf["median"]}</strong> (fixed)</p>',
+            unsafe_allow_html=True,
+        )
+        st.session_state.costs[method][r] = conf["median"]
+        if st.session_state.get("resource_caps", {}).get(r, 0) <= 0:
+            st.info(
+                f"No available quantity set for **{r}** in Resource Inputs tab: "
+                f"**{method}** won't be used in the optimization.",
+                icon=":material/info:",
+            )
+        return
+
+    if slider_key not in st.session_state:
+        st.session_state[slider_key] = current_val
+    if manual_key not in st.session_state:
+        st.session_state[manual_key] = st.session_state[slider_key]
+    if st.session_state.get("resource_caps", {}).get(r, 0) <= 0:
+        st.info(
+            f"No available quantity set for **{r}** in Resource Inputs tab: "
+            f"**{method}** won't be used in the optimization.",
+            icon=":material/info:",
+        )
+
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        slider_val = st.slider(
+            label=display_label,
+            min_value=conf["min"], max_value=conf["max"], step=step, format=fmt,
+            key=slider_key,
+            on_change=make_sync_s_to_m(slider_key, manual_key),
+        )
+    with col2:
+        st.number_input(
+            label="label", label_visibility="collapsed",
+            key=manual_key, help="Manual override (optional, any value)",
+            format=fmt, value=None, placeholder=str(round(slider_val, 4)),
+            on_change=make_sync_m_to_s(slider_key, manual_key, conf["min"], conf["max"]),
+        )
+
+    manual_value = st.session_state.get(manual_key)
+    st.session_state.costs[method][r] = slider_val if manual_value is None else manual_value
+
+
+def render_custom_resource_row(method, r, conf, enabled_methods, custom_resource_to_sub_group, custom_resources):
+    """Render the slider row for a single custom resource batch coefficient.
+
+    Args:
+        method (str): CDR method name.
+        r (str): custom resource batch name.
+        conf (dict): {min, median, max} for this (method, resource) pair.
+        enabled_methods (dict): {resource: {method: bool}} from session state.
+        custom_resource_to_sub_group (dict): {custom_r: reference_resource}.
+        custom_resources (list): list of custom batch dicts from session state.
+
+    Returns:
+        None
+    """
+    if not is_method_enabled(method, r, enabled_methods):
+        st.info("INFO: Method disabled for this resource (see Resource Inputs tab)")
+        return
+
+    is_sec = is_custom_secondary(method, r, custom_resource_to_sub_group)
+    step, fmt = get_slider_params(conf)
+    toggle_key = f"toggle_{method}_{r}".replace(" ", "_").lower()
+    slider_key = f"slider_{method}_{r}".replace(" ", "_").lower()
+    manual_key = f"manual_{method}_{r}".replace(" ", "_").lower()
+    current_val = st.session_state.costs.get(method, {}).get(r, 0.0 if is_sec else conf["median"])
+
+    if is_sec:
+        if toggle_key not in st.session_state:
+            st.session_state[toggle_key] = current_val != 0.0
+        if not st.checkbox(f"Use {r}", key=toggle_key):
+            st.session_state.costs.setdefault(method, {})[r] = 0.0
+            st.markdown("**DISABLED**")
+            return
+        elif current_val == 0.0:
+            st.session_state.costs.setdefault(method, {})[r] = conf["median"]
+            current_val = conf["median"]
+
+    if slider_key not in st.session_state:
+        st.session_state[slider_key] = current_val
+    if manual_key not in st.session_state:
+        st.session_state[manual_key] = st.session_state[slider_key]
+
+    batch_amount = next((float(b.get("amount", 0)) for b in custom_resources if b["name"] == r), 0.0)
+    if batch_amount <= 0:
+        st.info(
+            f"No available quantity set for **{r}** in Resource Inputs — "
+            "this method won't be used in the optimization.",
+            icon=":material/info:",
+        )
+
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        slider_val = st.slider(
+            label=r,
+            min_value=conf["min"], max_value=conf["max"], step=step, format=fmt,
+            key=slider_key,
+            on_change=make_sync_s_to_m(slider_key, manual_key),
+        )
+    with col2:
+        st.number_input(
+            label="label", label_visibility="collapsed",
+            key=manual_key, help="Manual override (optional, any value)",
+            format=fmt, value=None, placeholder=str(round(slider_val, 4)),
+            on_change=make_sync_m_to_s(slider_key, manual_key, conf["min"], conf["max"]),
+        )
+
+    st.session_state.costs.setdefault(method, {})
+    manual_value = st.session_state.get(manual_key)
+    st.session_state.costs[method][r] = slider_val if manual_value is None else manual_value
+
+
+def panel_method_editor(
+    method, cost_sliders_norm, custom_sliders_by_method,
+    resource_display, enabled_methods, custom_resources,
+    custom_resource_to_group, custom_resource_to_sub_group,
+):
+    """Render the coefficient-editing expander for one CDR method.
+
+    Shows one slider row per standard resource, then one per custom resource batch,
+    grouped by resource group. Includes a per-method reset button.
+
+    Args:
+        method (str): CDR method name.
+        cost_sliders_norm (dict): {method: {resource: {min, median, max}}}.
+        custom_sliders_by_method (dict): {method: {resource: {min, median, max}}}.
+        resource_display (dict): {resource: label_with_unit}.
+        enabled_methods (dict): {resource: {method: bool}} from session state.
+        custom_resources (list): list of custom batch dicts from session state.
+        custom_resource_to_group (dict): {custom_r: physical_group}.
+        custom_resource_to_sub_group (dict): {custom_r: reference_resource}.
+
+    Returns:
+        None
+    """
+    with st.expander(f"Manage resources for **{method}**", expanded=True):
+        method_sliders = cost_sliders_norm.get(method, {})
+        custom_for_method = custom_sliders_by_method.get(method, {})
+
+        for group_name, rlist in resource_groups.items():
+            used = [r for r in rlist if r in method_sliders]
+            custom_in_group = [
+                r for r in custom_for_method
+                if custom_resource_to_group.get(r) == group_name
+            ]
+            if not used and not custom_in_group:
+                continue
+
+            st.markdown(f'<p class="crra-group-name">{group_name}</p>', unsafe_allow_html=True)
+
+            for r in used:
+                conf = method_sliders[r]
+                render_standard_resource_row(
+                    method, r, conf, resource_display.get(r, r), enabled_methods
+                )
+
+            for r in custom_in_group:
+                render_custom_resource_row(
+                    method, r, custom_for_method[r],
+                    enabled_methods, custom_resource_to_sub_group, custom_resources
+                )
+
+        if st.button("Reset selected method", key="btn-reset-method", icon=":material/reset_settings:"):
+            for r, conf in cost_sliders_norm.get(method, {}).items():
+                is_secondary = (method, r) in secondary_resources
+                st.session_state.costs[method][r] = 0.0 if is_secondary else conf["median"]
+                for prefix in ["slider", "manual", "toggle"]:
+                    st.session_state.pop(f"{prefix}_{method}_{r}".replace(" ", "_").lower(), None)
+            for r, conf in custom_sliders_by_method.get(method, {}).items():
+                st.session_state.costs.setdefault(method, {})[r] = conf["median"]
+                for prefix in ["slider", "manual"]:
+                    st.session_state.pop(f"{prefix}_{method}_{r}".replace(" ", "_").lower(), None)
+            st.success(f"{method} reset to default values.")
+            st.rerun()
+
+
+def panel_summary_table(
+    cost_sliders_norm, custom_sliders_by_method,
+    enabled_methods, custom_resource_names, custom_resource_to_sub_group,
+):
+    """Render the full coefficient summary table with cells highlighted when modified.
+
+    Args:
+        cost_sliders_norm (dict): {method: {resource: {min, median, max}}}.
+        custom_sliders_by_method (dict): {method: {resource: {min, median, max}}}.
+        enabled_methods (dict): {resource: {method: bool}} from session state.
+        custom_resource_names (set[str]): names of all custom resource batches.
+        custom_resource_to_sub_group (dict): {custom_r: reference_resource}.
+
+    Returns:
+        None
+    """
+    st.markdown(
+        '<p class="crra-sub-heading">Summary of resource usage coefficients</p>',
+        unsafe_allow_html=True,
+    )
+    resource_display = {
+        r: f"{r} ({resource_unit_map[cat]}/{CO2_UNIT})"
+        for cat, resources in resource_groups.items()
+        for r in resources
+    }
+    all_resource_columns = resource_order + sorted(custom_resource_names)
+
+    df_default = pd.DataFrame(index=method_order, columns=all_resource_columns)
+    df_current = pd.DataFrame(index=method_order, columns=all_resource_columns)
+
+    for m in method_order:
+        current_costs = normalize_costs(st.session_state.costs.get(m, {}))
+        sliders = dict(cost_sliders_norm.get(m, {}))
+        sliders.update(custom_sliders_by_method.get(m, {}))
+
+        for r in all_resource_columns:
+            is_sec = (m, r) in secondary_resources or is_custom_secondary(m, r, custom_resource_to_sub_group)
+            disabled = not is_method_enabled(m, r, enabled_methods)
+            current_val = 0.0 if disabled else current_costs.get(r, 0.0)
+            default_val = 0.0 if disabled else sliders.get(r, {}).get("median", 0.0)
+            if is_sec and current_val == 0.0:
+                default_val = 0.0
+            df_default.at[m, r] = default_val
+            df_current.at[m, r] = current_val
+
+    df_default = df_default.astype(float).fillna(0.0)
+    df_current = df_current.astype(float).fillna(0.0)
+
+    resource_display_full = dict(resource_display)
+    resource_display_full.update({r: r for r in custom_resource_names})
+    df_default = df_default.rename(columns=resource_display_full)
+    df_current = df_current.rename(columns=resource_display_full)
+
+    styled = format_efficiency_summary(df_current, df_default)
+    st.dataframe(
+        data=styled,
+        height=(len(df_current) * 36 + 36),
+        width='stretch',
+        column_config={"_index": st.column_config.TextColumn("Method", width="large")},
+        row_height=36
+    )
+
+
+def render_tab(cost_sliders):
+    """Render the Resource Efficiency Coefficients tab.
+
+    Args:
+        cost_sliders (dict): full cost slider config {method: {resource: {min, median, max}}}.
+
+    Returns:
+        None
+    """
+    st.markdown('<h1 class="crra-heading">Resource efficiency coefficients</h1>', unsafe_allow_html=True)
+    show_bar()
+
+    st.markdown('<p class="objective_title">OBJECTIVE</p>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="text_with_border"><p>'
+        "This section lets you adjust the resource usage coefficients for each CDR method "
+        "to best fit your country conditions.<br>"
+        "<li>Primary resources are always active and initialized with default values.</li>"
+        "<li>Secondary resources are initialized at zero and toggled off by default.</li>"
+        "<li>Toggling on a secondary resource restores its default value.</li>"
+        "</p></div>",
+        unsafe_allow_html=True,
+    )
+    with st.container(key="warning_resources"):
+        st.warning(
+            "Red cells in the table highlight coefficients modified from their **default median values**",
+            icon=":material/warning:",
+        )
+
+    enabled_methods  = st.session_state.get("enabled_methods", {})
+    custom_resources = st.session_state.get("custom_resources", [])
+
+    cost_sliders_norm = {m: normalize_costs(resources) for m, resources in cost_sliders.items()}
+    resource_display = {
+        r: f"{r} ({resource_unit_map[cat]}/{CO2_UNIT})"
+        for cat, resources in resource_groups.items()
+        for r in resources
+    }
+
+    (
+        custom_sliders_by_method,
+        custom_resource_names,
+        custom_resource_to_sub_group,
+        custom_resource_to_group,
+    ) = build_custom_slider_index(cost_sliders_norm, custom_resources)
+
+    method_choices = [f"{g} | {m}" for g, methods in method_groups.items() for m in methods]
+    method_lookup  = {label: label.split(" | ", 1)[1] for label in method_choices}
+    selected_label = st.selectbox("Select a method:", method_choices, key="crra-select")
+
+    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
+        for m, sliders in cost_sliders_norm.items():
+            for r, conf in sliders.items():
+                st.session_state.costs[m][r] = 0.0 if (m, r) in secondary_resources else conf["median"]
+                for prefix in ["slider", "manual", "toggle"]:
+                    st.session_state.pop(f"{prefix}_{m}_{r}".replace(" ", "_").lower(), None)
+        for m, sliders in custom_sliders_by_method.items():
+            for r, conf in sliders.items():
+                st.session_state.costs.setdefault(m, {})[r] = (
+                    0.0 if is_custom_secondary(m, r, custom_resource_to_sub_group) else conf["median"]
+                )
+                for prefix in ["slider", "manual", "toggle"]:
+                    st.session_state.pop(f"{prefix}_{m}_{r}".replace(" ", "_").lower(), None)
+        st.success("All methods reset to default values.")
+        st.rerun()
+
+    panel_method_editor(
+        method=method_lookup[selected_label],
+        cost_sliders_norm=cost_sliders_norm,
+        custom_sliders_by_method=custom_sliders_by_method,
+        resource_display=resource_display,
+        enabled_methods=enabled_methods,
+        custom_resources=custom_resources,
+        custom_resource_to_group=custom_resource_to_group,
+        custom_resource_to_sub_group=custom_resource_to_sub_group,
+    )
+
+    panel_summary_table(
+        cost_sliders_norm=cost_sliders_norm,
+        custom_sliders_by_method=custom_sliders_by_method,
+        enabled_methods=enabled_methods,
+        custom_resource_names=custom_resource_names,
+        custom_resource_to_sub_group=custom_resource_to_sub_group,
     )

tabs/tab5_sensitivity.py

@@ -1,185 +1,245 @@
-import copy
-import pandas as pd
-import streamlit as st
-import plotly.express as px
-
-from config.config import CO2_UNIT, method_order, resource_groups, resource_order, resource_unit_map
-from optimization.optimization import run_optimization
-from utils.ui_helpers import register_chart_data, show_bar
-
-
-def render_tab():
-    st.markdown('<h1 class="crra-heading">Sensitivity analysis</h1>', unsafe_allow_html=True)
-    show_bar()
-
-    st.markdown(
-        """
-        <p class="objective_title">OBJECTIVE</p>
-        """,
-        unsafe_allow_html=True,
-    )
-
-    st.markdown(
-        """
-        <div class="text_with_border">
-            <p>Explore how varying <strong>one or multiple resources' availability</strong> or <strong>methods' maximum allocation</strong> affects total CO₂ removed.</p>
-        </div>
-        """,
-        unsafe_allow_html=True
-    )
-
-    if "resource_caps" not in st.session_state or "constraints" not in st.session_state or "costs" not in st.session_state:
-        st.warning("Please complete the setup in previous tabs before running sensitivity analysis.")
-        return
-
-    # Compute baseline once
-    baseline_success, baseline_result = run_optimization(
-        resource_caps=st.session_state.resource_caps,
-        method_constraints=st.session_state.constraints,
-        method_costs=st.session_state.costs,
-        custom_resources=st.session_state.get("custom_resources", []),
-    )
-    baseline_removed = baseline_result["total_removed"] if baseline_success else 0
-
-    custom_resource_names = [b["name"] for b in st.session_state.get("custom_resources", [])]
-    all_resources = resource_order + custom_resource_names
-
-    resource_to_unit = {
-        r: resource_unit_map[group]
-        for group, resources in resource_groups.items()
-        for r in resources
-    }
-    for b in st.session_state.get("custom_resources", []):
-        resource_to_unit[b["name"]] = b.get("unit", "")
-
-    tab1, tab2 = st.tabs(["🔁 Resource sensitivity", "🔁 Method sensitivity"])
-
-    with tab1:
-        st.markdown("""
-            <p class="crra-sub-heading">Impact of resource availability</p>""",
-            unsafe_allow_html=True,
-        )
-        selected_resources = st.multiselect("Select one or more resources:", all_resources, key="crra-select-resource")
-
-        if not selected_resources:
-            st.warning("Please select at least one resource to run the sensitivity analysis.")
-        else:
-            percentages = list(range(0, 210, 10))
-            all_data = []
-
-            custom_amount_by_name = {
-                b["name"]: float(b.get("amount", 0))
-                for b in st.session_state.get("custom_resources", [])
-            }
-
-            for resource in selected_resources:
-                unit = resource_to_unit.get(resource, "")
-                base_cap = st.session_state.resource_caps.get(resource) or custom_amount_by_name.get(resource, 0)
-                for pct in percentages:
-                    temp_caps = st.session_state.resource_caps.copy()
-                    actual_amount = base_cap * pct / 100
-                    temp_caps[resource] = actual_amount
-
-                    success, result = run_optimization(
-                        resource_caps=temp_caps,
-                        method_constraints=st.session_state.constraints,
-                        method_costs=st.session_state.costs,
-                        custom_resources=st.session_state.get("custom_resources", []),
-                    )
-
-                    co2_removed = result["total_removed"] if success else 0
-                    all_data.append({
-                        "Input": resource,
-                        "% of cap": pct,
-                        "Actual amount": round(actual_amount, 4),
-                        "Unit": unit,
-                        f"CO₂ removed ({CO2_UNIT})": co2_removed
-                    })
-
-            df = pd.DataFrame(all_data)
-            st.markdown("#### Sensitivity to resource availability")
-            fig = px.line(
-                df, x="% of cap", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True,
-                hover_data={"Actual amount": ":.4f", "Unit": True},
-            )
-            fig.update_layout(
-                xaxis_title="Resource availability (% of current cap)",
-                yaxis_title=f"Total portfolio CO₂ removal ({CO2_UNIT})",
-            )
-            fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
-                        annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
-            st.plotly_chart(fig, use_container_width=True)
-            with st.expander("📊 View / download chart data"):
-                st.dataframe(df, use_container_width=True, hide_index=True)
-            register_chart_data("Sensitivity to resource availability", df)
-
-    with tab2:
-        st.markdown("""
-            <p class="crra-sub-heading">Impact of max allocation per method</p>""",
-            unsafe_allow_html=True,
-        )
-        selected_methods = st.multiselect("Select one or more methods:", method_order, key="crra-select-method")
-
-        if not selected_methods:
-            st.warning("Please select at least one method to run the sensitivity analysis.")
-        else:
-            percentages = list(range(0, 110, 10))
-            all_data = []
-            skipped = []
-
-            for method in selected_methods:
-                cap_type = st.session_state.constraints[method].get("cap_type", "percent")
-                current_cap = st.session_state.constraints[method].get("cap_value", 100 if cap_type == "percent" else 0.0)
-
-                if current_cap <= 0:
-                    skipped.append(method)
-                    continue
-
-                for pct in percentages:
-                    temp_constraints = copy.deepcopy(st.session_state.constraints)
-                    if cap_type == "percent":
-                        actual_cap = min(100, current_cap * pct / 100)
-                        temp_constraints[method]["cap_value"] = actual_cap
-                        cap_label = f"{actual_cap:.0f}% of potential"
-                    else:
-                        actual_cap = current_cap * pct / 100
-                        temp_constraints[method]["cap_value"] = actual_cap
-                        cap_label = f"{actual_cap:.2f} {CO2_UNIT}/yr"
-
-                    success, result = run_optimization(
-                        resource_caps=st.session_state.resource_caps,
-                        method_constraints=temp_constraints,
-                        method_costs=st.session_state.costs,
-                        custom_resources=st.session_state.get("custom_resources", []),
-                    )
-                    co2_removed = result["total_removed"] if success else 0
-                    all_data.append({
-                        "Method": method,
-                        "Cap type": cap_type,
-                        "% of current cap": pct,
-                        "Actual cap": cap_label,
-                        f"CO₂ removed ({CO2_UNIT})": co2_removed,
-                    })
-
-            for m in skipped:
-                st.warning(f"Method **{m}** has a cap of 0 — set a value first to include it.", icon="⚠️")
-
-            if all_data:
-                df = pd.DataFrame(all_data)
-                fig = px.line(
-                    df, x="% of current cap", y=f"CO₂ removed ({CO2_UNIT})",
-                    color="Method", markers=True,
-                    hover_data={"Actual cap": True, "Cap type": True},
-                )
-                fig.add_hline(
-                    y=baseline_removed, line_dash="dash", line_color="lightgray",
-                    annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}",
-                )
-                fig.update_layout(
-                    xaxis_title="% of current cap setting",
-                    yaxis_title=f"Total portfolio CO₂ removal ({CO2_UNIT})",
-                )
-                st.plotly_chart(fig, use_container_width=True)
-                with st.expander("📊 View / download chart data"):
-                    st.dataframe(df, use_container_width=True, hide_index=True)
-                register_chart_data("Sensitivity to method cap", df)
+import copy
+import pandas as pd
+import streamlit as st
+import plotly.express as px
+from config.config import CO2_UNIT, method_order, resource_order
+from optimization.optimization import run_optimization
+from utils.data_utils import get_resource_to_unit
+from utils.ui_helpers import register_chart_data, show_bar
+
+
+def compute_baseline():
+    """Run the baseline optimisation and build combined resource metadata.
+
+    Returns:
+        tuple[float, list[str], dict[str, str]]:
+            baseline_removed  – total CO₂ removed at current inputs (0 if failed).
+            all_resources     – standard resources + custom batch names.
+            resource_to_unit  – {resource: unit} including custom batches.
+    """
+    baseline_success, baseline_result = run_optimization(
+        resource_caps=st.session_state.resource_caps,
+        method_constraints=st.session_state.constraints,
+        method_costs=st.session_state.costs,
+        custom_resources=st.session_state.get("custom_resources", []),
+    )
+    baseline_removed = baseline_result["total_removed"] if baseline_success else 0
+
+    custom_resource_names = [b["name"] for b in st.session_state.get("custom_resources", [])]
+    all_resources = resource_order + custom_resource_names
+
+    resource_to_unit = get_resource_to_unit()
+    for b in st.session_state.get("custom_resources", []):
+        resource_to_unit[b["name"]] = b.get("unit", "")
+
+    return baseline_removed, all_resources, resource_to_unit
+
+
+def panel_resource_sensitivity(baseline_removed, all_resources, resource_to_unit):
+    """Render the resource-availability sensitivity sub-panel.
+
+    Sweeps each selected resource from 0 % to 200 % of its current cap in
+    10 % steps, re-solves the LP at each point, and plots total CO₂ removed.
+
+    Args:
+        baseline_removed (float): total CO₂ removed at current inputs.
+        all_resources (list[str]): standard + custom resource names to select from.
+        resource_to_unit (dict[str, str]): {resource: unit} for axis labels.
+
+    Returns:
+        None
+    """
+    st.markdown(
+        '<p class="crra-sub-heading">Impact of resource availability</p>',
+        unsafe_allow_html=True,
+    )
+    selected_resources = st.multiselect(
+        "Select one or more resources:", all_resources, key="crra-select-resource"
+    )
+
+    if not selected_resources:
+        st.warning("Please select at least one resource to run the sensitivity analysis.")
+        return
+
+    percentages = list(range(0, 210, 10))
+    custom_amount_by_name = {
+        b["name"]: float(b.get("amount", 0))
+        for b in st.session_state.get("custom_resources", [])
+    }
+    all_data = []
+
+    for resource in selected_resources:
+        unit = resource_to_unit.get(resource, "")
+        base_cap = (
+            st.session_state.resource_caps.get(resource)
+            or custom_amount_by_name.get(resource, 0)
+        )
+        for pct in percentages:
+            perturbed_caps = st.session_state.resource_caps.copy()
+            actual_amount = base_cap * pct / 100
+            perturbed_caps[resource] = actual_amount
+
+            success, result = run_optimization(
+                resource_caps=perturbed_caps,
+                method_constraints=st.session_state.constraints,
+                method_costs=st.session_state.costs,
+                custom_resources=st.session_state.get("custom_resources", []),
+            )
+            all_data.append({
+                "Input": resource,
+                "% of cap": pct,
+                "Actual amount": round(actual_amount, 4),
+                "Unit": unit,
+                f"CO₂ removed ({CO2_UNIT})": result["total_removed"] if success else 0,
+            })
+
+    df = pd.DataFrame(all_data)
+    st.markdown("#### Sensitivity to resource availability")
+    fig = px.line(
+        df, x="% of cap", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True,
+        hover_data={"Actual amount": ":.4f", "Unit": True},
+    )
+    fig.update_layout(
+        xaxis_title="Resource availability (% of current cap)",
+        yaxis_title=f"Total portfolio CO₂ removal ({CO2_UNIT})",
+    )
+    fig.add_hline(
+        y=baseline_removed, line_dash="dash", line_color="gray",
+        annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}",
+    )
+    st.plotly_chart(fig, width='stretch')
+    with st.expander("📊 View / download chart data"):
+        st.dataframe(df, width='stretch', hide_index=True)
+    register_chart_data("Sensitivity to resource availability", df)
+
+
+def panel_method_sensitivity(baseline_removed):
+    """Render the method-cap sensitivity sub-panel.
+
+    Sweeps each selected method's cap from 0 % to 100 % of its current value
+    in 10 % steps, re-solves the LP at each point, and plots total CO₂ removed.
+    Skips methods whose current cap is 0.
+
+    Args:
+        baseline_removed (float): total CO₂ removed at current inputs.
+
+    Returns:
+        None
+    """
+    st.markdown(
+        '<p class="crra-sub-heading">Impact of max allocation per method</p>',
+        unsafe_allow_html=True,
+    )
+    selected_methods = st.multiselect(
+        "Select one or more methods:", method_order, key="crra-select-method"
+    )
+
+    if not selected_methods:
+        st.warning("Please select at least one method to run the sensitivity analysis.")
+        return
+
+    percentages = list(range(0, 110, 10))
+    all_data = []
+    skipped = []
+
+    for method in selected_methods:
+        cap_type = st.session_state.constraints[method].get("cap_type", "percent")
+        current_cap = st.session_state.constraints[method].get(
+            "cap_value", 100 if cap_type == "percent" else 0.0
+        )
+
+        if current_cap <= 0:
+            skipped.append(method)
+            continue
+
+        for pct in percentages:
+            perturbed_constraints = copy.deepcopy(st.session_state.constraints)
+            if cap_type == "percent":
+                actual_cap = min(100, current_cap * pct / 100)
+                perturbed_constraints[method]["cap_value"] = actual_cap
+                cap_label = f"{actual_cap:.0f}% of potential"
+            else:
+                actual_cap = current_cap * pct / 100
+                perturbed_constraints[method]["cap_value"] = actual_cap
+                cap_label = f"{actual_cap:.2f} {CO2_UNIT}/yr"
+
+            success, result = run_optimization(
+                resource_caps=st.session_state.resource_caps,
+                method_constraints=perturbed_constraints,
+                method_costs=st.session_state.costs,
+                custom_resources=st.session_state.get("custom_resources", []),
+            )
+            all_data.append({
+                "Method": method,
+                "Cap type": cap_type,
+                "% of current cap": pct,
+                "Actual cap": cap_label,
+                f"CO₂ removed ({CO2_UNIT})": result["total_removed"] if success else 0,
+            })
+
+    for m in skipped:
+        st.warning(f"Method **{m}** has a cap of 0 — set a value first to include it.", icon="⚠️")
+
+    if not all_data:
+        return
+
+    df = pd.DataFrame(all_data)
+    fig = px.line(
+        df, x="% of current cap", y=f"CO₂ removed ({CO2_UNIT})",
+        color="Method", markers=True,
+        hover_data={"Actual cap": True, "Cap type": True},
+    )
+    fig.add_hline(
+        y=baseline_removed, line_dash="dash", line_color="lightgray",
+        annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}",
+    )
+    fig.update_layout(
+        xaxis_title="% of current cap setting",
+        yaxis_title=f"Total portfolio CO₂ removal ({CO2_UNIT})",
+    )
+    st.plotly_chart(fig, width='stretch')
+    with st.expander("📊 View / download chart data"):
+        st.dataframe(df, width='stretch', hide_index=True)
+    register_chart_data("Sensitivity to method cap", df)
+
+
+def render_tab():
+    """Render the Sensitivity Analysis tab.
+
+    Computes a baseline optimisation from session state, then lets the user
+    sweep one or more resources (or method caps) over a range and plots how
+    total CO₂ removed changes. Requires resource_caps, constraints, and costs
+    to be present in session state.
+
+    Returns:
+        None
+    """
+    st.markdown('<h1 class="crra-heading">Sensitivity analysis</h1>', unsafe_allow_html=True)
+    show_bar()
+
+    st.markdown('<p class="objective_title">OBJECTIVE</p>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="text_with_border">'
+        "<p>Explore how varying <strong>one or multiple resources' availability</strong> "
+        "or <strong>methods' maximum allocation</strong> affects total CO₂ removed.</p>"
+        "</div>",
+        unsafe_allow_html=True,
+    )
+
+    if (
+        "resource_caps" not in st.session_state
+        or "constraints" not in st.session_state
+        or "costs" not in st.session_state
+    ):
+        st.warning("Please complete the setup in previous tabs before running sensitivity analysis.")
+        return
+
+    baseline_removed, all_resources, resource_to_unit = compute_baseline()
+
+    tab1, tab2 = st.tabs(["🔁 Resource sensitivity", "🔁 Method sensitivity"])
+
+    with tab1:
+        panel_resource_sensitivity(baseline_removed, all_resources, resource_to_unit)
+
+    with tab2:
+        panel_method_sensitivity(baseline_removed)

tabs/tab6_scenarios.py

@@ -1,168 +1,199 @@
-import json
-
-import pandas as pd
-import plotly.express as px
-import streamlit as st
-from config.config import CO2_UNIT
-from utils.data_utils import is_valid_scenario
-from tabs.tab4_optimization import parse_zip_scenario
-from utils.ui_helpers import show_bar
-
-
-# ─── Load from file ───────────────────────────────────────────────────────────
-
-def panel_load_scenario():
-    st.markdown("""
-        <p class="crra-sub-heading">Load a scenario from file</p>""",
-        unsafe_allow_html=True,
-    )
-    st.markdown('<p class="caption">Accepts `.json` or `.zip` (CSV export)</p>', unsafe_allow_html=True)
-
-    uploaded = st.file_uploader("Upload scenario", type=["json", "zip"], key="comparison_loader", accept_multiple_files=True)
-    if uploaded is None:
-        return
-    for uploaded_file in uploaded:
-        if uploaded_file is not None:
-            try:
-                if uploaded_file.name.endswith(".json"):
-                    data = json.load(uploaded_file)
-                    if not is_valid_scenario(data):
-                        st.error(f"Invalid scenario format in {uploaded_file.name}.")
-                        continue
-                else:
-                    data = parse_zip_scenario(uploaded_file)
-                    if data is None:
-                        st.error(f"Invalid ZIP format in {uploaded_file.name}. Expected: resource_caps.csv, method_constraints.csv, method_costs.csv, allocations.csv")
-                        continue
-                st.session_state.scenarios[uploaded_file.name] = data
-            except Exception as e:
-                st.error(f"Error loading {uploaded_file.name}: {e}")
-
-# ─── Data preparation ─────────────────────────────────────────────────────────
-
-def _prepare_comparison_data(selected):
-    all_methods = sorted({
-        m for name in selected
-        for m in st.session_state.scenarios[name].get("allocations", {})
-    })
-    all_resources = sorted({
-        r for name in selected
-        for r in st.session_state.scenarios[name].get("resource_caps", {})
-    })
-
-    summary_rows, method_alloc_rows, resource_usage_rows = [], [], []
-
-    for name in selected:
-        scenario = st.session_state.scenarios[name]
-        allocations = scenario.get("allocations", {})
-        method_costs = scenario.get("method_costs", {})  # ← fix: was using method_constraints
-
-        row = {
-            "Scenario": name,
-            f"CO₂ Removed ({CO2_UNIT})": scenario.get("summary", {}).get("total_co2_removed", 0),
-        }
-
-        for method in all_methods:
-            val = allocations.get(method, 0)
-            row[f"{method} ({CO2_UNIT})"] = val
-            method_alloc_rows.append({"Scenario": name, "Method": method, f"{CO2_UNIT}": val})
-
-        for resource in all_resources:
-            total_used = 0
-            for method, tco2 in allocations.items():
-                used = method_costs.get(method, {}).get(resource, 0) * tco2
-                total_used += used
-                if used > 0:
-                    resource_usage_rows.append({
-                        "Scenario": name, "Method": method,
-                        "Resource": resource, "Used": used,
-                    })
-            row[f"{resource} used"] = total_used
-
-        summary_rows.append(row)
-
-    return (
-        pd.DataFrame(summary_rows),
-        pd.DataFrame(method_alloc_rows),
-        pd.DataFrame(resource_usage_rows),
-    )
-
-
-# ─── Charts ───────────────────────────────────────────────────────────────────
-
-def _show_method_allocations(df):
-    if df.empty:
-        return
-    st.markdown("""<p class="crra-sub-heading">Method Allocations</p>""", unsafe_allow_html=True)
-    fig = px.bar(df, x="Method", y=f"{CO2_UNIT}", color="Scenario", barmode="group")
-    fig.update_layout(xaxis_tickangle=-45)
-    st.plotly_chart(fig, use_container_width=True)
-
-    
-
-
-def _show_resource_usage(df):
-    if df.empty:
-        st.info("No resource usage data available (method_costs missing from scenarios?).")
-        return
-
-    st.markdown("""<p class="crra-sub-heading">Resource Use per Method</p>""", unsafe_allow_html=True)
-    for method in df["Method"].unique():
-        df_m = df[df["Method"] == method]
-        fig = px.bar(df_m, x="Resource", y="Used", color="Scenario", barmode="group", title=method)
-        fig.update_layout(xaxis_tickangle=-45)
-        st.plotly_chart(fig, use_container_width=True)
-
-    st.markdown("""<p class="crra-sub-heading">Total Resource Use per Scenario</p>""", unsafe_allow_html=True)
-    df_total = df.groupby(["Scenario", "Resource"]).sum(numeric_only=True).reset_index()
-    fig = px.bar(df_total, x="Scenario", y="Used", color="Resource", barmode="group")
-    fig.update_layout(xaxis_tickangle=-45)
-    st.plotly_chart(fig, use_container_width=True)
-
-
-# ─── Main tab entry point ─────────────────────────────────────────────────────
-
-def render_tab():
-    st.markdown('<h1 class="crra-heading">Scenario Comparison</h1>', unsafe_allow_html=True)
-    show_bar()
-
-    st.session_state.setdefault("scenarios", {})
-
-    panel_load_scenario()
-
-    if not st.session_state.scenarios:
-        st.info("No scenarios saved yet. Run an optimization in **Portfolio Optimization** tab or load a file above.")
-        return
-
-    # Select & manage scenarios
-    st.markdown("""<p class="crra-sub-heading">Select Scenarios to Compare</p>""", unsafe_allow_html=True)
-    scenario_names = list(st.session_state.scenarios.keys())
-    selected = st.multiselect("Select scenarios", scenario_names, default=scenario_names)
-
-    for name in selected:
-        col1, col2 = st.columns([10, 1])
-        with col1:
-            st.markdown(f"**{name}**")
-        with col2:
-            if st.button("❌", key=f"remove_{name}"):
-                st.session_state.scenarios.pop(name, None)
-                st.rerun()
-
-    if not selected:
-        st.warning("Please select at least one scenario.")
-        return
-
-    # Comparison
-    df_summary, df_methods, df_resources = _prepare_comparison_data(selected)
-
-    st.markdown("""<p class="crra-sub-heading">Summary Table</p>""", unsafe_allow_html=True)
-    st.dataframe(df_summary.style.format(na_rep="-", thousands=","), use_container_width=True)
-    st.download_button(
-        "Export Comparison CSV",
-        df_summary.to_csv(index=False).encode("utf-8"),
-        "scenario_comparison.csv", "text/csv",
-        icon=":material/download:"
-    )
-
-    _show_method_allocations(df_methods)
+import json
+import pandas as pd
+import plotly.express as px
+import streamlit as st
+from config.config import CO2_UNIT
+from utils.data_utils import is_valid_scenario
+from tabs.tab4_optimization import parse_zip_scenario
+from utils.ui_helpers import show_bar
+
+
+def panel_load_scenario():
+    """Render the file uploader panel to load one or more scenarios for comparison.
+
+    Accepts JSON and ZIP files. Adds valid scenarios to st.session_state.scenarios.
+
+    Returns:
+        None
+    """
+    st.markdown("""
+        <p class="crra-sub-heading">Load a scenario from file</p>""",
+        unsafe_allow_html=True,
+    )
+    st.markdown('<p class="caption">Accepts `.json` or `.zip` (CSV export)</p>', unsafe_allow_html=True)
+
+    uploaded = st.file_uploader("Upload scenario", type=["json", "zip"], key="comparison_loader", accept_multiple_files=True)
+    if uploaded is None:
+        return
+    for uploaded_file in uploaded:
+        if uploaded_file is not None:
+            try:
+                if uploaded_file.name.endswith(".json"):
+                    data = json.load(uploaded_file)
+                    if not is_valid_scenario(data):
+                        st.error(f"Invalid scenario format in {uploaded_file.name}.")
+                        continue
+                else:
+                    data = parse_zip_scenario(uploaded_file)
+                    if data is None:
+                        st.error(f"Invalid ZIP format in {uploaded_file.name}. Expected: resource_caps.csv, method_constraints.csv, method_costs.csv, allocations.csv")
+                        continue
+                st.session_state.scenarios[uploaded_file.name] = data
+            except Exception as e:
+                st.error(f"Error loading {uploaded_file.name}: {e}")
+
+def _prepare_comparison_data(selected):
+    """Build comparison DataFrames from the currently selected scenarios.
+
+    Args:
+        selected (list[str]): list of scenario names to include.
+
+    Returns:
+        tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+            df_summary — one row per scenario with total CO₂ and per-method values,
+            df_methods — long-format method allocation data,
+            df_resources — long-format resource usage data per method and scenario.
+    """
+    all_methods = sorted({
+        m for name in selected
+        for m in st.session_state.scenarios[name].get("allocations", {})
+    })
+    all_resources = sorted({
+        r for name in selected
+        for r in st.session_state.scenarios[name].get("resource_caps", {})
+    })
+
+    summary_rows, method_alloc_rows, resource_usage_rows = [], [], []
+
+    for name in selected:
+        scenario = st.session_state.scenarios[name]
+        allocations = scenario.get("allocations", {})
+        method_costs = scenario.get("method_costs", {})  # ← fix: was using method_constraints
+
+        row = {
+            "Scenario": name,
+            f"CO₂ Removed ({CO2_UNIT})": scenario.get("summary", {}).get("total_co2_removed", 0),
+        }
+
+        for method in all_methods:
+            val = allocations.get(method, 0)
+            row[f"{method} ({CO2_UNIT})"] = val
+            method_alloc_rows.append({"Scenario": name, "Method": method, f"{CO2_UNIT}": val})
+
+        for resource in all_resources:
+            total_used = 0
+            for method, tco2 in allocations.items():
+                used = method_costs.get(method, {}).get(resource, 0) * tco2
+                total_used += used
+                if used > 0:
+                    resource_usage_rows.append({
+                        "Scenario": name, "Method": method,
+                        "Resource": resource, "Used": used,
+                    })
+            row[f"{resource} used"] = total_used
+
+        summary_rows.append(row)
+
+    return (
+        pd.DataFrame(summary_rows),
+        pd.DataFrame(method_alloc_rows),
+        pd.DataFrame(resource_usage_rows),
+    )
+
+
+def _show_method_allocations(df):
+    """Render a grouped bar chart of method allocations across scenarios.
+
+    Args:
+        df (pd.DataFrame): long-format data with columns Scenario, Method, CO₂ value.
+
+    Returns:
+        None
+    """
+    if df.empty:
+        return
+    st.markdown("""<p class="crra-sub-heading">Method Allocations</p>""", unsafe_allow_html=True)
+    fig = px.bar(df, x="Method", y=f"{CO2_UNIT}", color="Scenario", barmode="group")
+    fig.update_layout(xaxis_tickangle=-45)
+    st.plotly_chart(fig, width='stretch')
+
+    
+
+
+def _show_resource_usage(df):
+    """Render grouped bar charts of resource usage per method and total per scenario.
+
+    Args:
+        df (pd.DataFrame): long-format data with columns Scenario, Method, Resource, Used.
+
+    Returns:
+        None
+    """
+    if df.empty:
+        st.info("No resource usage data available (method_costs missing from scenarios?).")
+        return
+
+    st.markdown("""<p class="crra-sub-heading">Resource Use per Method</p>""", unsafe_allow_html=True)
+    for method in df["Method"].unique():
+        df_m = df[df["Method"] == method]
+        fig = px.bar(df_m, x="Resource", y="Used", color="Scenario", barmode="group", title=method)
+        fig.update_layout(xaxis_tickangle=-45)
+        st.plotly_chart(fig, width='stretch')
+
+    st.markdown("""<p class="crra-sub-heading">Total Resource Use per Scenario</p>""", unsafe_allow_html=True)
+    df_total = df.groupby(["Scenario", "Resource"]).sum(numeric_only=True).reset_index()
+    fig = px.bar(df_total, x="Scenario", y="Used", color="Resource", barmode="group")
+    fig.update_layout(xaxis_tickangle=-45)
+    st.plotly_chart(fig, width='stretch')
+
+
+
+def render_tab():
+    """Render the Scenario Comparison tab.
+
+    Returns:
+        None
+    """
+    st.markdown('<h1 class="crra-heading">Scenario Comparison</h1>', unsafe_allow_html=True)
+    show_bar()
+
+    st.session_state.setdefault("scenarios", {})
+
+    panel_load_scenario()
+
+    if not st.session_state.scenarios:
+        st.info("No scenarios saved yet. Run an optimization in **Portfolio Optimization** tab or load a file above.")
+        return
+
+    # Select & manage scenarios
+    st.markdown("""<p class="crra-sub-heading">Select Scenarios to Compare</p>""", unsafe_allow_html=True)
+    scenario_names = list(st.session_state.scenarios.keys())
+    selected = st.multiselect("Select scenarios", scenario_names, default=scenario_names)
+
+    for name in selected:
+        col1, col2 = st.columns([10, 1])
+        with col1:
+            st.markdown(f"**{name}**")
+        with col2:
+            if st.button("❌", key=f"remove_{name}"):
+                st.session_state.scenarios.pop(name, None)
+                st.rerun()
+
+    if not selected:
+        st.warning("Please select at least one scenario.")
+        return
+
+    # Comparison
+    df_summary, df_methods, df_resources = _prepare_comparison_data(selected)
+
+    st.markdown("""<p class="crra-sub-heading">Summary Table</p>""", unsafe_allow_html=True)
+    st.dataframe(df_summary.style.format(na_rep="-", thousands=","), width='stretch')
+    st.download_button(
+        "Export Comparison CSV",
+        df_summary.to_csv(index=False).encode("utf-8"),
+        "scenario_comparison.csv", "text/csv",
+        icon=":material/download:"
+    )
+
+    _show_method_allocations(df_methods)
     _show_resource_usage(df_resources)

utils/data_utils.py

@@ -1,143 +1,235 @@
-import io
-import json
-import re
-import pandas as pd
-import streamlit as st
-import openpyxl
-from openpyxl.styles import PatternFill, Font
-from config.config import resource_unit_map, resource_order, method_order
-
-@st.cache_data
-def load_slider_data():
-    """Load slider data from a JSON file and cache it for performance."""
-    with open("data/cost_sliders.json") as f:
-        data = json.load(f)
-        return data
-    
-def render_resource_input(name_clean, r, tooltip=None):
-
-    widget_key = f"cap_{r}"
-
-    if widget_key not in st.session_state:
-        existing = st.session_state.resource_caps.get(r, 0.0)
-        st.session_state[widget_key] = existing if existing else None
-
-    cap = st.number_input(
-        label=name_clean,
-        min_value=0.0,
-        format="%.2f",
-        value=None,
-        placeholder="0.00",
-        key=widget_key,
-        help=tooltip
-    )
-
-    st.session_state.resource_caps[r] = cap if cap is not None else 0.0
-
-def is_valid_scenario(scenario):
-    base_ok = (
-        isinstance(scenario, dict)
-        and "allocations" in scenario
-        and "resource_caps" in scenario
-        and "method_costs" in scenario
-        and "method_constraints" in scenario
-        and "summary" in scenario
-    )
-    if not base_ok:
-        return False
-    return True
-
-def is_complete_scenario(scenario):
-    """A scenario that also carries the detailed optimisation outputs and the
-    per-resource manual allocation state, so reloading it reproduces the
-    exact same optimisation (not just the same inputs)."""
-    required_extra = {
-        "resource_usage", "resource_used_total", "resource_remaining","enabled_methods",
-    }
-    return is_valid_scenario(scenario) and required_extra.issubset(scenario.keys())
-
-def load_inputs_from_excel(file):
-    xl = pd.read_excel(file, sheet_name=None)
-
-    resource_caps = {}
-    if "resource_caps" in xl:
-        for _, row in xl["resource_caps"].iterrows():
-            resource_caps[row["Resource"]] = float(row["Available Amount"])
-
-    constraints = {}
-    if "constraints" in xl:
-        for _, row in xl["constraints"].iterrows():
-                constraints[row["method"]] = {
-                    "active": bool(row["active"]),
-                    "cap_type": str(row["cap_type (percent or absolute)"]),
-                    "cap_value": float(row["cap_value"])
-                }
-    costs = {}
-    if "coefficients" in xl:
-        for _, row in xl["coefficients"].iterrows():
-            m, r, v = row["method"], row["resource"], float(row["value"])
-            costs.setdefault(m, {})[r] = v
-
-    custom_resources = []
-    warnings = []
-    valid_resources = set(resource_order)
-    valid_methods = set(method_order)
-    if "custom_resources" in xl:
-        df_custom = xl["custom_resources"]
-        required_custom = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
-        if required_custom.issubset(df_custom.columns):
-            for bname in df_custom["name"].dropna().unique():
-                df_b = df_custom[df_custom["name"] == bname]
-                group = str(df_b["group"].iloc[0])
-                if group not in valid_resources:
-                    warnings.append(f"New resource \"{bname}\" - group \"{group}\" not found: check spelling.")
-                    continue
-                methods = {}
-                for _, row in df_b.iterrows():
-                    m = str(row["method"])
-                    if m not in valid_methods:
-                        warnings.append(f"New resource \"{bname}\" - method \"{m}\" not found: check spelling.")
-                        continue
-                    methods[m] = {
-                        "min": float(row["min"]),
-                        "median": float(row["median"]),
-                        "max": float(row["max"]),
-                    }
-                custom_resources.append({
-                    "name": str(bname),
-                    "group": group,
-                    "amount": float(df_b["amount"].iloc[0]),
-                    "unit": str(df_b["unit"].iloc[0]),
-                    "methods": methods,
-                })
-
-    # Per-resource manual method allocation (which CDR methods are allowed to
-    # use a given resource). Optional sheet for backward compatibility with
-    # older templates that predate this feature.
-    enabled_methods = {}
-    if "enabled_methods" in xl:
-        df_enabled = xl["enabled_methods"]
-        required_enabled = {"resource", "method", "enabled"}
-        if required_enabled.issubset(df_enabled.columns):
-            for _, row in df_enabled.iterrows():
-                r, m = row["resource"], row["method"]
-                enabled_methods.setdefault(r, {})[m] = bool(row["enabled"])
-
-    return resource_caps, constraints, costs, custom_resources, enabled_methods, warnings
-
-def strip_unit_suffix(resource_name: str) -> str:
-    """Remove legacy unit suffix from resource name, e.g. 'Unspecified land (ha/tCO2)' -> 'Unspecified land'"""
-    return re.sub(r"\s*\(.*?\)\s*$", "", resource_name).strip()
-
-def neutralize_zero_coefficient_methods(method_costs: dict, method_constraints: dict) -> dict:
-    safe_constraints = {m: c.copy() for m, c in method_constraints.items()}
-
-    for method, constraint in safe_constraints.items():
-        if not constraint.get("active", True):
-            continue
-        coeffs = method_costs.get(method, {})
-        all_zero = all(v == 0 for v in coeffs.values()) if coeffs else True
-        if all_zero:
-            constraint["active"] = False
-
+import io
+import json
+import re
+import pandas as pd
+import streamlit as st
+import openpyxl
+from openpyxl.styles import PatternFill, Font
+from config.config import resource_unit_map, resource_order, method_order, resource_groups, method_groups
+
+def get_resource_to_group() -> dict[str, str]:
+    """Map each resource name to its resource group.
+
+    Returns:
+        dict[str, str]: resource name → group name (e.g. "Arable land" → "Land").
+    """
+    return {r: g for g, resources in resource_groups.items() for r in resources}
+
+def get_resource_to_unit() -> dict[str, str]:
+    """Map each resource name to its physical unit.
+
+    Returns:
+        dict[str, str]: resource name → unit (e.g. "Arable land" → "Mha").
+    """
+    return {r: resource_unit_map[g] for g, resources in resource_groups.items() for r in resources}
+
+def get_method_group(method: str) -> str:
+    """Return the group a CDR method belongs to.
+
+    Args:
+        method (str): CDR method name.
+
+    Returns:
+        str: group name, or "Other" if not found.
+    """
+    return next((g for g, methods in method_groups.items() if method in methods), "Other")
+
+@st.cache_data
+def load_slider_data():
+    """Load and cache the cost slider configuration from data/cost_sliders.json.
+
+    Returns:
+        dict: nested dict {method: {resource: {min, median, max}}}.
+    """
+    with open("data/cost_sliders.json") as f:
+        data = json.load(f)
+        return data
+    
+def render_resource_input(name_clean, r, tooltip=None):
+    """Render a number_input widget for a single resource availability cap.
+
+    Writes the entered value into st.session_state.resource_caps[r].
+
+    Args:
+        name_clean (str): display label (resource name without unit suffix).
+        r (str): canonical resource name used as the session state key.
+        tooltip (str | None): optional help text shown on hover.
+
+    Returns:
+        None
+    """
+    widget_key = f"cap_{r}"
+
+    if widget_key not in st.session_state:
+        existing = st.session_state.resource_caps.get(r, 0.0)
+        st.session_state[widget_key] = existing if existing else None
+
+    cap = st.number_input(
+        label=name_clean,
+        min_value=0.0,
+        format="%.2f",
+        value=None,
+        placeholder="0.00",
+        key=widget_key,
+        help=tooltip
+    )
+
+    st.session_state.resource_caps[r] = cap if cap is not None else 0.0
+
+def is_valid_scenario(scenario):
+    """Check that a scenario dict has the minimum required keys to be loaded.
+
+    Args:
+        scenario (dict): scenario data to validate.
+
+    Returns:
+        bool: True if all base keys are present, False otherwise.
+    """
+    base_ok = (
+        isinstance(scenario, dict)
+        and "allocations" in scenario
+        and "resource_caps" in scenario
+        and "method_costs" in scenario
+        and "method_constraints" in scenario
+        and "summary" in scenario
+    )
+    if not base_ok:
+        return False
+    return True
+
+def is_complete_scenario(scenario):
+    """Check that a scenario carries full optimisation outputs, not just inputs.
+
+    A complete scenario can be displayed without re-running the optimisation.
+    An incomplete scenario (e.g. exported before resource_actual_gain was added)
+    triggers an automatic re-run on load.
+
+    Args:
+        scenario (dict): scenario data to validate.
+
+    Returns:
+        bool: True if the scenario includes all detailed output keys.
+    """
+    required_extra = {
+        "resource_usage", "resource_used_total", "resource_remaining",
+        "resource_actual_gain", "enabled_methods",
+    }
+    return is_valid_scenario(scenario) and required_extra.issubset(scenario.keys())
+
+def load_inputs_from_excel(file):
+    """Parse an Excel workbook exported from the tool into session-state-ready dicts.
+
+    Expects sheets: resource_caps, constraints, coefficients.
+    Optional sheets: custom_resources, enabled_methods.
+
+    Args:
+        file: file-like object pointing to an .xlsx workbook.
+
+    Returns:
+        tuple: (resource_caps, constraints, costs, custom_resources, enabled_methods, warnings)
+               where warnings is a list[str] of non-fatal import issues.
+    """
+    xl = pd.read_excel(file, sheet_name=None)
+
+    resource_caps = {}
+    if "resource_caps" in xl:
+        for _, row in xl["resource_caps"].iterrows():
+            resource_caps[row["Resource"]] = float(row["Available Amount"])
+
+    constraints = {}
+    if "constraints" in xl:
+        for _, row in xl["constraints"].iterrows():
+                constraints[row["method"]] = {
+                    "active": bool(row["active"]),
+                    "cap_type": str(row["cap_type (percent or absolute)"]),
+                    "cap_value": float(row["cap_value"])
+                }
+    costs = {}
+    if "coefficients" in xl:
+        for _, row in xl["coefficients"].iterrows():
+            m, r, v = row["method"], row["resource"], float(row["value"])
+            costs.setdefault(m, {})[r] = v
+
+    custom_resources = []
+    warnings = []
+    valid_resources = set(resource_order)
+    valid_methods = set(method_order)
+    if "custom_resources" in xl:
+        df_custom = xl["custom_resources"]
+        required_custom = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
+        if required_custom.issubset(df_custom.columns):
+            for bname in df_custom["name"].dropna().unique():
+                df_b = df_custom[df_custom["name"] == bname]
+                group = str(df_b["group"].iloc[0])
+                if group not in valid_resources:
+                    warnings.append(f"New resource \"{bname}\" - group \"{group}\" not found: check spelling.")
+                    continue
+                methods = {}
+                for _, row in df_b.iterrows():
+                    m = str(row["method"])
+                    if m not in valid_methods:
+                        warnings.append(f"New resource \"{bname}\" - method \"{m}\" not found: check spelling.")
+                        continue
+                    methods[m] = {
+                        "min": float(row["min"]),
+                        "median": float(row["median"]),
+                        "max": float(row["max"]),
+                    }
+                custom_resources.append({
+                    "name": str(bname),
+                    "group": group,
+                    "amount": float(df_b["amount"].iloc[0]),
+                    "unit": str(df_b["unit"].iloc[0]),
+                    "methods": methods,
+                })
+
+    # Per-resource manual method allocation (which CDR methods are allowed to
+    # use a given resource). Optional sheet for backward compatibility with
+    # older templates that predate this feature.
+    enabled_methods = {}
+    if "enabled_methods" in xl:
+        df_enabled = xl["enabled_methods"]
+        required_enabled = {"resource", "method", "enabled"}
+        if required_enabled.issubset(df_enabled.columns):
+            for _, row in df_enabled.iterrows():
+                r, m = row["resource"], row["method"]
+                enabled_methods.setdefault(r, {})[m] = bool(row["enabled"])
+
+    return resource_caps, constraints, costs, custom_resources, enabled_methods, warnings
+
+def strip_unit_suffix(resource_name: str) -> str:
+    """Remove trailing unit suffix from a resource name.
+
+    E.g. "Unspecified land (Mha/MtCO₂)" → "Unspecified land".
+
+    Args:
+        resource_name (str): raw resource name, possibly with a parenthetical unit.
+
+    Returns:
+        str: resource name without the unit suffix.
+    """
+    return re.sub(r"\s*\(.*?\)\s*$", "", resource_name).strip()
+
+def neutralize_zero_coefficient_methods(method_costs: dict, method_constraints: dict) -> dict:
+    """Return a copy of method_constraints with methods that have all-zero costs deactivated.
+
+    Prevents the LP from including methods with no usable resource coefficients.
+
+    Args:
+        method_costs (dict): {method: {resource: coefficient}} cost matrix.
+        method_constraints (dict): {method: {active, cap_type, cap_value}}.
+
+    Returns:
+        dict: modified copy of method_constraints with zero-cost methods deactivated.
+    """
+    safe_constraints = {m: c.copy() for m, c in method_constraints.items()}
+
+    for method, constraint in safe_constraints.items():
+        if not constraint.get("active", True):
+            continue
+        coeffs = method_costs.get(method, {})
+        all_zero = all(v == 0 for v in coeffs.values()) if coeffs else True
+        if all_zero:
+            constraint["active"] = False
+
     return safe_constraints

utils/ui_helpers.py

@@ -4,6 +4,15 @@ from config.config import CRRA_COLORS, CRRA_FONT, PLOTLY_TEMPLATE
 
 
 def apply_chart_style(fig, height=None):
+    """Apply the standard CRRA theme (font, colours, margins) to a Plotly figure.
+
+    Args:
+        fig: Plotly figure object.
+        height (int | None): optional fixed height in pixels.
+
+    Returns:
+        fig: the same figure with updated layout.
+    """
     fig.update_layout(
         template=PLOTLY_TEMPLATE,
         font=dict(family=CRRA_FONT, size=12, color=CRRA_COLORS["black"]),
@@ -20,12 +29,25 @@ def apply_chart_style(fig, height=None):
 
 
 def register_chart_data(name: str, df: pd.DataFrame):
-    """Enregistre les données d'un graphique pour l'export consolidé final."""
+    """Store a chart's underlying DataFrame in the session-level registry for bulk export.
+
+    Args:
+        name (str): unique chart label used as the dict key and export sheet name.
+        df (pd.DataFrame): data behind the chart.
+
+    Returns:
+        None
+    """
     st.session_state.setdefault("chart_data_registry", {})
     st.session_state["chart_data_registry"][name] = df.copy()
 
 
 def show_bar():
+    """Render the CRRA four-colour decorative bar below page headings.
+
+    Returns:
+        None
+    """
     st.markdown(
         """
         <div class="et_pb_module">
@@ -42,6 +64,17 @@ def show_bar():
 
 
 def smart_display_format(val):
+    """Format a numeric value with adaptive precision for table display.
+
+    Near-zero values are shown as an empty string; others use 2–5 decimal
+    places depending on magnitude.
+
+    Args:
+        val (float): numeric value to format.
+
+    Returns:
+        str: formatted string, or "" for near-zero values.
+    """
     if abs(val) < 1e-8:
         return ""
     elif abs(val) < 0.001:
@@ -57,6 +90,17 @@ def smart_display_format(val):
 
 
 def format_efficiency_summary(df: pd.DataFrame, df_default: pd.DataFrame):
+    """Build a styled Pandas Styler for the resource-efficiency coefficient summary table.
+
+    Cells whose value differs from the default median are highlighted in red.
+
+    Args:
+        df (pd.DataFrame): current coefficient values (methods × resources).
+        df_default (pd.DataFrame): default median values for the same shape.
+
+    Returns:
+        pandas.io.formats.style.Styler: styled dataframe ready for st.dataframe().
+    """
     df_numeric = df.copy()
     df_display = df_numeric.map(smart_display_format)