[FEAT] Objective 2: Custom resource batches with supplementary LP semantics

assets/styles.css

@@ -258,6 +258,20 @@ div.custom-corps {
     color: var(--red);
 }
 
+[class*="simple-btn-"] button {
+    color: var(--red);
+}
+
+[class*="simple-btn-"] button p{
+    text-transform: uppercase;
+    font-weight: bold;
+}
+
+[class*="simple-btn-"] button:hover{
+    color: #E5503F;
+    font-style: italic;
+}
+
 .stSidebar {
     background: var(--off-white) !important;
 }
@@ -297,6 +311,12 @@ section[data-testid="stExpander"] summary {
     letter-spacing: 0.05rem;
 }
 
+.caption-input {
+    font-family: var(--font);
+    font-style: italic;
+    letter-spacing: 0.05rem;
+}
+
 [class*="_dlg_existing_enable_"] p, [class*="label-input-"] p {
     font-family: var(--font);
 }

config/config.py

@@ -65,7 +65,10 @@ method_order = sum(method_groups.values(), [])
 
 # secondary resources
 secondary_df = pd.read_csv("data/secondary_resources.csv")
-secondary_resources = set(zip(secondary_df["method"], secondary_df["resource"]))
+secondary_resources = set(zip(
+    secondary_df["method"].str.strip(),
+    secondary_df["resource"].str.strip(),
+))
 
 # tooltips
 resource_tooltips = {

data/generate_cost_matrix.py

@@ -89,8 +89,6 @@ def create_sliders_inputs():
     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")
     
-    
-
     with open("data/cost_sliders.json", "w") as f:
         json.dump(cost_sliders, f, indent=2)
 

optimization/optimization.py

@@ -1,138 +1,277 @@
-import numpy as np
-from scipy.optimize import linprog
-
-
-def run_optimization(resource_caps, method_constraints, method_costs, custom_resources=None):
-    """
-    Run linear optimization to maximize CO₂ removal while respecting resource limits and method constraints.
-
-    Args:
-        resource_caps (dict): {resource: available_quantity}
-        method_constraints (dict): {method: {"active": bool, "cap_type": str, "cap_value": float}}
-            cap_type: "percent" → cap_value is a fraction of total (0 to 100)
-            cap_type: "absolute" → cap_value is a hard upper bound in CO₂ units
-        method_costs (dict): {method: {resource: usage_per_tCO2}}
-        custom_resources (list | None): list of custom batch dicts: [{"name": str, "group": str, "amount": float, "methods": {method: {"min", "median", "max"}}}]
-            If provided, each batch is injected as an extra resource row.
-
-    Returns:
-        (bool, dict): (success_flag, result_dict)
-            result_dict includes "total_removed", "method_usage"
-    """
-    # ── Inject custom resource batches ────────────────────────────────────────
-    # Work on shallow copies so callers are not mutated.
-    resource_caps = dict(resource_caps)
-    method_costs = {m: dict(v) for m, v in method_costs.items()}
- 
-    for batch in (custom_resources or []):
-        r_key = batch["name"]
-        resource_caps[r_key] = batch["amount"]
-        for method, coefs in batch["methods"].items():
-            if method in method_costs:
-                method_costs[method][r_key] = coefs["median"]
-            else:
-                method_costs[method] = {r_key: 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(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")
-
-    # ── Standard optimisation setup ───────────────────────────────────────────
-
-    # Only keep active methods
-    methods = [m for m in method_costs if method_constraints.get(m, {}).get("active", True)]
-    resources = list(resource_caps.keys())
-
-    if not methods:
-        return False, {"message": "No active methods."}
-    
-    # A matrix: each row is a resource, each column a method
-    A_resource = np.array([
-        [method_costs[m].get(r, 0.0) for m in methods]
-        for r in resources
-    ])
-    b_resource = np.array([resource_caps[r] for r in resources])
-
-    # Cap constraints per method
-    A_share = []
-    b_share = []
-    for i, m in enumerate(methods):
-        constraint = method_constraints.get(m, {})
-        cap_type = constraint.get("cap_type", "percent")
-        cap_value = constraint.get("cap_value", 100)
-
-        # x_i <= cap_value
-        if cap_type == "absolute":
-            row = np.zeros(len(methods))
-            row[i] = 1
-            A_share.append(row)
-            b_share.append(cap_value)
-        # x_i <= cap_value/100 * sum(x)  →  x_i - cap_value/100 * sum(x) <= 0
-        else:
-            cap_ratio = cap_value / 100
-            row = np.zeros(len(methods))
-            row += -cap_ratio
-            row[i] += 1
-            A_share.append(row)
-            b_share.append(0)
-
-    # Combine constraints
-    A_ub = np.vstack([A_resource, A_share])
-    b_ub = np.concatenate([b_resource, b_share])
-
-    # Objective: maximize sum(x_i), hence minimize -1 * sum(x_i)
-    c = -1 * np.ones(len(methods))
-    bounds = [(0, None)] * len(methods)
-
-    try:
-        result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method="highs")
-        if result.success:
-            # x = np.floor(result.x).astype(int)
-            x = result.x
-            total_removed = x.sum()
-            method_usage = {m: x[i] for i, m in enumerate(methods) if x[i] > 0}
-            resource_usage = {}
-            for i, r in enumerate(resources):
-                resource_usage[r] = {
-                    m: float(A_resource[i, j] * x[j])
-                    for j, m in enumerate(methods) if A_resource[i, j] * x[j] > 0
-                }
-
-            resource_used_total = {r: sum(resource_usage[r].values()) for r in resources}
-            resource_remaining = {r: resource_caps[r] - resource_used_total[r] for r in resources}
-
-            # Potentiel théorique par méthode (si seule, contrainte ressources + son propre cap)
-            method_potential = {}
-            for j, m in enumerate(methods):
-                limits = []
-                for i, r in enumerate(resources):
-                    coef = A_resource[i, j]
-                    if coef > 0:
-                        limits.append(resource_caps[r] / coef)
-                constraint = method_constraints.get(m, {})
-                if constraint.get("cap_type") == "absolute":
-                    limits.append(constraint.get("cap_value", float("inf")))
-                method_potential[m] = float(min(limits)) if limits else 0.0
-
-            return True, {
-                "total_removed": total_removed,
-                "method_usage": method_usage,
-                "method_potential": method_potential,
-                "resource_usage": resource_usage,
-                "resource_used_total": resource_used_total,
-                "resource_remaining": resource_remaining,
-            }
-        else:
-            return False, {"message": result.message}
-    except Exception as e:
-        return False, {"message": str(e)}
+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.
+
+    Custom resource batches are treated as supplementary pools for their reference
+    resource (batch["group"]).  Instead of adding a new AND-constraint per batch
+    (which would make the reference resource the bottleneck), the LP introduces
+    split variables z_{m,n} = CO₂ attributed to batch n for method m, so that
+    y_m = x_{m,standard} + z_{m,n} and each pool is constrained independently.
+
+    Args:
+        resource_caps       {resource: available_quantity}
+        method_constraints  {method: {"active": bool, "cap_type": str, "cap_value": float}}
+        method_costs        {method: {resource: usage_per_MtCO2}}
+        custom_resources    list of {"name", "group", "amount", "methods": {...}}
+        enabled_methods     {resource: {method: bool}}  — manual allocation overrides
+
+    Returns:
+        (success: bool, result: dict)
+    """
+
+    resource_caps = dict(resource_caps)
+    method_costs  = {m: dict(v) for m, v in method_costs.items()}
+
+    # ── Apply manual allocation overrides ─────────────────────────────────────
+    enabled_methods = enabled_methods or {}
+    for method, resources in method_costs.items():
+        for resource in list(resources):
+            if not enabled_methods.get(resource, {}).get(method, True):
+                method_costs[method][resource] = 0.0
+
+    # ── Custom batch metadata ─────────────────────────────────────────────────
+    custom_batch_info = {}          # {batch_name: {"group": ref, "amount": Q}}
+    for batch in (custom_resources or []):
+        custom_batch_info[batch["name"]] = {
+            "group":  batch["group"],
+            "amount": float(batch["amount"]),
+        }
+    custom_names   = set(custom_batch_info)
+    ref_to_batches = {}             # {standard_resource: [batch_name, ...]}
+    for bname, info in custom_batch_info.items():
+        ref_to_batches.setdefault(info["group"], []).append(bname)
+
+    # ── Inject primary batch coefficients (fallback) ─────────────────────────
+    # Tab 3 pre-init may have set the coefficient to 0 if it classified the
+    # link as secondary (or if the key already existed at 0 from a prior run).
+    # For methods explicitly listed in batch["methods"] (primary dialog links),
+    # fall back to the batch median so the LP can actually use the resource.
+    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(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 method list ────────────────────────────────────────────────────
+    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."}
+
+    # ── Split-variable list ───────────────────────────────────────────────────
+    # z_{m,n}  exists when BOTH c_s[m] > 0 AND c_n[m] > 0.
+    # It represents CO₂ attributed to custom pool n for method m, substituting
+    # for an equal amount of output that would otherwise consume standard pool s.
+    #
+    # Guard: if the standard resource cap is 0 (user left it unset), the custom
+    # batch is also inactive — a batch supplements an existing resource, it doesn't
+    # enable a resource type that the user hasn't allocated.
+    z_pairs = []
+    for bname, info in custom_batch_info.items():
+        ref = info["group"]
+        if resource_caps.get(ref, 0.0) <= 0:
+            continue  # standard resource unavailable → custom batch inactive too
+        for m in methods:
+            c_s = method_costs.get(m, {}).get(ref,   0.0)
+            c_n = method_costs.get(m, {}).get(bname, 0.0)
+            if c_s > 0 and c_n > 0:
+                z_pairs.append((m, bname))
+
+    Z     = len(z_pairs)
+    z_idx = {pair: M + i for i, pair in enumerate(z_pairs)}
+    N     = M + Z   # total LP variables: [y_0..y_{M-1}, z_0..z_{Z-1}]
+
+    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 ────────────────────────────────────────────
+    A_rows, b_rows = [], []
+
+    # (A) Standard resources with NO custom batch substitutes — unchanged rows
+    for r in resources_no_batches:
+        row = np.zeros(N)
+        for j, m in enumerate(methods):
+            row[j] = method_costs.get(m, {}).get(r, 0.0)
+        if np.any(row[:M] != 0):
+            A_rows.append(row)
+            b_rows.append(resource_caps[r])
+
+    # (B) Standard resources that DO have custom batch substitutes
+    # Constraint: Σ_m  c_s[m] * (y_m - Σ_n z_{m,n})  ≤ Q_s
+    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[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   # subtract z contribution
+        if np.any(row != 0):
+            A_rows.append(row)
+            b_rows.append(resource_caps[r])
+
+    # (C) Custom batch capacity constraints
+    # For substitutable pairs  (m, n) in z_idx  → c_n[m] * z_{m,n}
+    # For non-substitutable    (c_s = 0, c_n > 0) → c_n[m] * y_m  (method fully
+    #   relies on this batch since it has no access to the standard resource)
+    # Skip entirely when the standard resource cap is 0 (batch is inactive).
+    for bname, info in custom_batch_info.items():
+        ref = info["group"]
+        if resource_caps.get(ref, 0.0) <= 0:
+            continue
+        row = np.zeros(N)
+        for j, m in enumerate(methods):
+            c_n_m = method_costs.get(m, {}).get(bname, 0.0)
+            if c_n_m <= 0:
+                continue
+            c_s_m = method_costs.get(m, {}).get(ref, 0.0)
+            if c_s_m > 0 and (m, bname) in z_idx:
+                row[z_idx[(m, bname)]] = c_n_m
+            else:
+                row[j] = c_n_m          # entire y_m draws from this batch
+        if np.any(row != 0):
+            A_rows.append(row)
+            b_rows.append(info["amount"])
+
+    # (D) Coupling constraints per (method, standard-resource-type)
+    # Ensure  Σ_{n: ref(n)=s} z_{m,n}  ≤  y_m  so standard usage stays ≥ 0
+    coupling_done = set()
+    for (m, bname) in z_pairs:
+        ref = custom_batch_info[bname]["group"]
+        key = (m, ref)
+        if key in coupling_done:
+            continue
+        coupling_done.add(key)
+        j   = method_idx[m]
+        row = np.zeros(N)
+        row[j] = -1.0
+        for bn in ref_to_batches.get(ref, []):
+            if (m, bn) in z_idx:
+                row[z_idx[(m, bn)]] = 1.0
+        A_rows.append(row)
+        b_rows.append(0.0)
+
+    # (E) Method cap constraints (on y_m)
+    for j, m in enumerate(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
+            A_rows.append(row)
+            b_rows.append(cap_value)
+        else:
+            cap_ratio  = cap_value / 100.0
+            row        = np.zeros(N)
+            row[:M]   -= cap_ratio
+            row[j]    += 1.0
+            A_rows.append(row)
+            b_rows.append(0.0)
+
+    A_ub = np.array(A_rows) if A_rows else np.empty((0, N))
+    b_ub = np.array(b_rows)
+
+    # Objective: maximize Σ y_m  →  minimize -Σ y_m  (z variables don't add to objective)
+    c_obj         = np.zeros(N)
+    c_obj[:M]     = -1.0
+    bounds        = [(0, None)] * N
+
+    # ── Solve ─────────────────────────────────────────────────────────────────
+    try:
+        result = linprog(c_obj, 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 CO₂ per method
+
+        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}
+
+        # Standard resources without substitutes
+        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)
+
+        # Standard resources with substitutes: usage = c_s * (y_m - Σ z_{m,n})
+        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)
+
+        # Custom batches
+        for bname, info in custom_batch_info.items():
+            ref = info["group"]
+            for j, m in enumerate(methods):
+                c_n_m = method_costs.get(m, {}).get(bname, 0.0)
+                if c_n_m <= 0:
+                    continue
+                c_s_m = method_costs.get(m, {}).get(ref, 0.0)
+                if c_s_m > 0 and (m, bname) in z_idx:
+                    used = c_n_m * sol[z_idx[(m, bname)]]
+                else:
+                    used = c_n_m * y[j]
+                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}
+        print(method_costs)
+
+        return True, {
+            "total_removed":      total_removed,
+            "method_usage":       method_usage,
+            "resource_usage":     resource_usage,
+            "resource_used_total":resource_used_total,
+            "resource_remaining": resource_remaining,
+        }
+
+    except Exception as e:
+        return False, {"message": str(e)}

tabs/tab1_inputs.py

@@ -2,7 +2,7 @@ import pandas as pd
 import streamlit as st
 
 from config.config import (resource_groups, resource_order, resource_tooltips,
-                           resource_unit_map, method_groups, method_order, CO2_UNIT)
+                           resource_unit_map, method_groups, method_order, CO2_UNIT, secondary_resources)
 from utils.data_utils import render_resource_input, strip_unit_suffix
 from utils.ui_helpers import format_resource_summary, format_table_summary, show_bar
 from io import BytesIO
@@ -16,6 +16,8 @@ def standard_resource_names():
 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 = {}
     for batch in st.session_state.custom_resources:
         try:
             batch["amount"] = float(batch["amount"])
@@ -32,12 +34,11 @@ def init_custom_resources():
 # ─── 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):
+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_edit_existing_",
-                            "_dlg_min_existing_", "_dlg_med_existing_", "_dlg_max_existing_",
+            if key.startswith(("_dlg_existing_enable_",
                             "_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
@@ -54,7 +55,18 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
         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)
@@ -67,12 +79,13 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
             key="label-input-name"
         )
     with col_group:
-        default_group_idx = resource_order.index(existing["group"]) if existing.get("group") in resource_order else 0
+        default_group_idx = group_options.index(existing["group"]) if existing.get("group") in group_options else 0
         batch_group = st.selectbox(
             "Resource group *",
-            options=resource_order,
+            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"
         )
 
@@ -96,28 +109,40 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
 
     method_configs = {}
 
-    # Methods linked to this resource grouped by CDR group
-    related_methods = {}
+    # 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):
-                related_methods[cdr_method] = {
+                all_related_methods[cdr_method] = {
                     "min": coeff["min"],
                     "median": coeff["median"],
                     "max": coeff["max"],
                 }
 
-    # group_name -> methods
-    related_by_group = {}
+    # 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
+    }
 
-    for m, coeff in related_methods.items():
+    # 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"
         )
-        related_by_group.setdefault(method_group, {})[m] = coeff
+        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 related_by_group.items():
+    for method_group, methods in primary_by_group.items():
         with st.expander(f"**{method_group}**", expanded=False):
             for m, coeff in methods.items():
 
@@ -134,72 +159,25 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
                 if not enabled:
                     continue
 
-                if f"_dlg_edit_existing_{m}" not in st.session_state:
-                    saved = existing.get("methods", {}).get(m, {})
-                    default = coeff
-                    coeffs_differ = any(
-                        abs(float(saved.get(k, default[k])) - float(default[k])) > 1e-9
-                        for k in ("min", "median", "max")
-                    ) if saved else False
-                    st.session_state[f"_dlg_edit_existing_{m}"] = coeffs_differ
-
-                edit = st.checkbox(
-                    "Edit coefficients (will overwrite default values)",
-                    key=f"_dlg_edit_existing_{m}",
+                st.dataframe(
+                    pd.DataFrame([{
+                        "Min": coeff["min"],
+                        "Median": coeff["median"],
+                        "Max": coeff["max"],
+                    }]),
+                    hide_index=True,
+                    use_container_width=True,
                 )
+                method_configs[m] = coeff.copy()
+
+    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="ℹ️",
+        )
 
-                if edit:
-                    saved = existing.get("methods", {}).get(m, coeff)
-                    st.warning(
-                        "Editing this method will overwrite the default coefficient values.",
-                        icon="⚠️"
-                    )
-                    col_min, col_med, col_max = st.columns(3)
-                    with col_min:
-                        v_min = st.number_input(
-                            "Min",
-                            min_value=0.0,
-                            value=float(saved.get("min", coeff["min"])),
-                            format="%.4f",
-                            key=f"_dlg_min_existing_{m}",
-                        )
-
-                    with col_med:
-                        v_med = st.number_input(
-                            "Median ★",
-                            min_value=0.0,
-                            value=float(saved.get("median", coeff["median"])),
-                            format="%.4f",
-                            key=f"_dlg_med_existing_{m}",
-                        )
-
-                    with col_max:
-                        v_max = st.number_input(
-                            "Max",
-                            min_value=0.0,
-                            value=float(saved.get("max", coeff["max"])),
-                            format="%.4f",
-                            key=f"_dlg_max_existing_{m}",
-                        )
-
-                    method_configs[m] = {
-                        "min": v_min,
-                        "median": v_med,
-                        "max": v_max,
-                    }
-
-                else:
-                    st.dataframe(
-                        pd.DataFrame([{
-                            "Min": coeff["min"],
-                            "Median": coeff["median"],
-                            "Max": coeff["max"],
-                        }]),
-                        hide_index=True,
-                        use_container_width=True,
-                    )
-
-                    method_configs[m] = coeff.copy()
     # -------------------------------------------------
     # Part 4 : new/custom methods only
     # -------------------------------------------------
@@ -207,7 +185,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
     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(related_methods.keys())
+    already_used = set(all_related_methods.keys())
 
     for group_name, methods in method_groups.items():
         available_methods = [
@@ -267,8 +245,8 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
             errors.append(f"**{batch_name}** already exists. Choose a different name.")
         if batch_amount <= 0:
             errors.append("Available amount must be greater than 0.")
-        if not method_configs:
-            errors.append("Select at least one CDR method.")
+        # if not method_configs:
+        #     errors.append("Select at least one CDR method.")
         for m, c in method_configs.items():
             if c["min"] > c["max"]:
                 errors.append(f"**{m}**: min ({c['min']}) cannot be greater than max ({c['max']}).")
@@ -288,12 +266,16 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
                     "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()
 
@@ -337,10 +319,13 @@ def _parse_custom_excel(file) -> list:
             }
             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":   str(df_b["group"].iloc[0]),
+            "group":   group_name,
             "amount":  float(df_b["amount"].iloc[0]),
+            "unit":    resource_unit_map.get(_r2g.get(group_name), "?"),
             "methods": methods,
         })
     return batches
@@ -401,116 +386,93 @@ def dialog_load_custom_batch():
 
 # ─── Custom resources panel ───────────────────────────────────────────────────
 
-def panel_custom_resources(cost_sliders):
-    init_custom_resources()
+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"Available amount ({unit})",
+                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),
+            },
+        )
+
+        col_edit, col_del = st.columns([1, 1])
+        with col_edit:
+            if st.button("Edit", key=f"edit_batch_{global_idx}", use_container_width=True, icon=":material/edit:"):
+                dialog_add_custom_resource(cost_sliders, edit_index=global_idx)
+        with col_del:
+            if st.button("Delete", key=f"del_batch_{global_idx}", use_container_width=True,
+                         type="primary", icon=":material/delete:"):
+                st.session_state.custom_resources.pop(global_idx)
+                st.session_state.pop("latest_result", None)
+                st.rerun()
 
-    st.markdown('<p class="crra-sub-heading">➕ Custom 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)
 
-    col = st.container(key="container-btn")
+def panel_custom_resources_controls(cost_sliders):
+    """Buttons to add / load / download custom resource batches (no batch display here)."""
+    init_custom_resources()
 
-    with col:
+    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()
-
-    resource_to_group = {
-        r: group
-        for group, resources in resource_groups.items()
-        for r in resources
-    }
-        
-    batches = st.session_state.custom_resources
-    if not batches:
-        st.info("No new resources have been defined yet. Click **+ New resource** to get started.")
-        return
-
-    st.markdown(f"**{len(batches)} new resource(s)**")
-    for i, batch in enumerate(batches):
-
-        group = resource_to_group.get(batch["group"])
-        unit = resource_unit_map.get(group, "?")
-    
-        batch["unit"] = unit
-        n_methods = len(batch["methods"])
-        amount_val = float(batch["amount"])
-
-        with st.expander(
-            f"🆕 **{batch['name']}** ({batch['group']}) — CDR methods: **{n_methods}**",
-            expanded=False,
-        ):
-            st.markdown(f"**{batch['name']}** ({unit})")
-
-            key_amount = f"custom_amount_{i}"
-            # Initialise widget state only if not already set (avoids overwrite on rerun)
-            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(
-                    "Available amount",
-                    label_visibility="collapsed",
-                    min_value=0.0,
-                    format="%.2f",
-                    key=key_amount,
-                )
-            # Write back as float — never as a formatted string
-            if new_amount != amount_val:
-                st.session_state.custom_resources[i]["amount"] = float(new_amount)
-                st.session_state.pop("latest_result", None)
-
-            # Coefficients table
-            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_{i}",
-                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),
-                },
+        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",
             )
 
-            col_edit, col_del = st.columns([1, 1])
-            with col_edit:
-                if st.button("Edit", key=f"edit_batch_{i}", use_container_width=True, icon=":material/edit:"):
-                    dialog_add_custom_resource(cost_sliders, edit_index=i)
-            with col_del:
-                if st.button("Delete", key=f"del_batch_{i}", use_container_width=True,
-                             type="primary", icon=":material/delete:"):
-                    st.session_state.custom_resources.pop(i)
-                    st.session_state.pop("latest_result", None)
-                    st.rerun()
-
-    # Export all batches as a single Excel file
-    _, col_save_custom = st.columns(2)
-    with col_save_custom:
-        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:",
-            # use_container_width=True,
-            key="download_button_save_custom"
-        )
-
 
 # ─── Main render ──────────────────────────────────────────────────────────────
 
@@ -544,6 +506,7 @@ def render_tab(cost_sliders):
         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()
 
@@ -601,18 +564,146 @@ def render_tab(cost_sliders):
 
     # 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)
+
+            cols = st.columns(3)
+
             for i, r in enumerate(rlist):
+
                 tooltip = resource_tooltips.get(r, None)
                 name_clean = r.split(" (")[0]
-                with cols[i % 4]:
+
+                with cols[i % 3]:
+
                     render_resource_input(name_clean, r, tooltip=tooltip)
 
-    # Custom resource batches panel
-    panel_custom_resources(cost_sliders)
+                    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
+
+    methods_with_no_active_resource = [
+        m for m in method_to_primary_resources
+        if method_active_resource_count.get(m, 0) == 0
+    ]
+
+    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
+            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)
@@ -633,12 +724,6 @@ def render_tab(cost_sliders):
         for resource, value in df_caps["Available Amount"].items()
     ]
 
-    resource_to_group = {
-        r: group
-        for group, resources in resource_groups.items()
-        for r in resources
-    }
-    
     custom_rows = []
     for batch in st.session_state.get("custom_resources", []):
         group = resource_to_group.get(batch["group"])

tabs/tab2_constraints.py

@@ -10,7 +10,7 @@ from utils.ui_helpers import format_table_summary, show_bar
 # ─── Helpers ─────────────────────────────────────────────────────────────────
 
 def default_constraint():
-    return {"active": True, "cap_type": "percent", "cap_value": 100}
+    return {"active": True, "cap_type": "percent", "cap_value": int(100)}
 
 
 def render_method(m, cols, i):
@@ -35,7 +35,7 @@ def render_method(m, cols, i):
         st.session_state.setdefault(cap_type_key, constraint["cap_type"])
 
         if constraint["cap_type"] == "percent":
-            st.session_state.setdefault(slider_key, float(constraint["cap_value"]))
+            st.session_state.setdefault(slider_key, int(constraint["cap_value"]))
         else:
             st.session_state.setdefault(manual_key, float(constraint["cap_value"]))
 

tabs/tab3_coefficients.py

@@ -6,12 +6,10 @@ from config.config import (method_groups, method_order, resource_groups,
 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"]
@@ -24,6 +22,30 @@ def _get_slider_params(conf: dict) -> tuple:
     else:
         return 1.0, "%.0f"
 
+def is_method_enabled(method, resource, enabled_methods):
+    return enabled_methods.get(resource, {}).get(method, True)
+
+
+def _enforce_disabled_coefficients(method_order_, resource_order_, custom_resources, enabled_methods):
+    """Zero out st.session_state.costs[method][resource] for every (method, resource)
+    pair the user disabled in tab1 — even if that pair was never opened in this tab.
+    Without this, a disabled pair silently keeps its last/default coefficient and
+    gets exported/optimised as if it were still active."""
+    for r in resource_order_:
+        disallowed = {m for m, ok in enabled_methods.get(r, {}).items() if not ok}
+        if not disallowed:
+            continue
+        for m in disallowed:
+            if m in st.session_state.costs and r in st.session_state.costs[m]:
+                st.session_state.costs[m][r] = 0.0
+
+    for batch in custom_resources or []:
+        r = batch["name"]
+        disallowed = {m for m, ok in enabled_methods.get(r, {}).items() if not ok}
+        for m in disallowed:
+            if m in st.session_state.costs and r in st.session_state.costs[m]:
+                st.session_state.costs[m][r] = 0.0
+
 
 def render_tab(cost_sliders):
     st.markdown('<h1 class="crra-heading">Resource efficiency coefficients</h1>', unsafe_allow_html=True)
@@ -52,9 +74,19 @@ def render_tab(cost_sliders):
 
     with st.container(key="warning_resources"):
         st.warning(
-            "Blue cells in the table highlight coefficients modified from their **default median values**",
+            "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(method_order, resource_order, custom_resources, enabled_methods)
+
     # Normalize cost_sliders once: strip unit suffixes from resource keys
     # cost_sliders_norm[method][resource_name] = {min, median, max}
     cost_sliders_norm = {
@@ -69,6 +101,56 @@ def render_tab(cost_sliders):
         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
+
+    # 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 = {}
@@ -79,7 +161,7 @@ def render_tab(cost_sliders):
             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():
@@ -87,6 +169,11 @@ def render_tab(cost_sliders):
                 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()
 
@@ -96,16 +183,27 @@ def render_tab(cost_sliders):
     with st.expander(f"Manage resources for **{method}**", expanded=True):
         method_sliders = cost_sliders_norm.get(method, {})
         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]
-            if not 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)")
+                    st.session_state.costs[method][r] = 0.0
+                    continue
                 conf = method_sliders[r]
                 display_label = resource_display.get(r, r)
                 step, fmt = _get_slider_params(conf)
@@ -154,6 +252,64 @@ def render_tab(cost_sliders):
 
                 st.session_state.costs[method][r] = manual_val if manual_val != slider_val else slider_val
 
+            # ── 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)")
+                    st.session_state.costs.setdefault(method, {})[r] = 0.0
+                    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
+
+                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,
+                    )
+                with col2:
+                    manual_val = st.number_input(
+                        label="label",
+                        label_visibility="collapsed",
+                        value=slider_val,
+                        key=manual_key,
+                        help="Manual override (optional, any value)",
+                        format=fmt,
+                    )
+
+                st.session_state.costs.setdefault(method, {})
+                st.session_state.costs[method][r] = manual_val if manual_val != slider_val else slider_val
+
+
         # ── 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():
@@ -161,6 +317,10 @@ def render_tab(cost_sliders):
                 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()
 
@@ -169,17 +329,21 @@ def render_tab(cost_sliders):
         <p class="crra-sub-heading">Summary of resource usage coefficients</p>""",
         unsafe_allow_html=True,
     )
-    df_default = pd.DataFrame(index=method_order, columns=resource_order)
-    df_current = pd.DataFrame(index=method_order, columns=resource_order)
+    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 = cost_sliders_norm.get(m, {})
+        sliders = dict(cost_sliders_norm.get(m, {}))
+        sliders.update(custom_sliders_by_method.get(m, {}))
 
-        for r in resource_order:
-            is_secondary = (m, r) in secondary_resources
-            current_val = current_costs.get(r, 0.0)
-            default_val = sliders.get(r, {}).get("median", 0.0)
+        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
@@ -187,11 +351,22 @@ def render_tab(cost_sliders):
             df_default.at[m, r] = default_val
             df_current.at[m, r] = current_val
 
-    df_default = df_default.astype(float)
-    df_current = df_current.astype(float)
+    df_default = df_default.astype(float).fillna(0.0)
+    df_current = df_current.astype(float).fillna(0.0)
 
-    df_default = df_default.rename(columns=resource_display)
-    df_current = df_current.rename(columns=resource_display)
+    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.table(styled)
+    st.dataframe(
+        data=styled, 
+        use_container_width=True, 
+        column_config={
+            "_index": st.column_config.TextColumn(
+                "Method",
+                # width="large"
+        )
+    })

tabs/tab4_optimization.py

@@ -6,6 +6,7 @@ import unicodedata
 import zipfile
 import openpyxl
 
+import numpy as np
 import pandas as pd
 import streamlit as st
 import plotly.express as px
@@ -13,7 +14,26 @@ import plotly.express as px
 from config.config import CRRA_COLORS, PLOTLY_COLOR_SEQUENCE, PLOTLY_HEATMAP_SCALE, method_order, resource_order, resource_unit_map, resource_groups, secondary_resources, CO2_UNIT
 from optimization.optimization import run_optimization
 from utils.ui_helpers import apply_chart_style, format_table_summary, register_chart_data, show_bar
-from utils.data_utils import is_valid_scenario, load_inputs_from_excel, strip_unit_suffix
+from utils.data_utils import is_valid_scenario, load_inputs_from_excel, neutralize_zero_coefficient_methods, strip_unit_suffix
+
+
+def _to_json_safe(obj):
+    """Recursively convert numpy/pandas types to plain Python so json.dumps works."""
+    if isinstance(obj, dict):
+        return {k: _to_json_safe(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_to_json_safe(v) for v in obj]
+    if isinstance(obj, pd.Series):
+        return obj.iloc[0] if len(obj) == 1 else obj.tolist()
+    if isinstance(obj, pd.DataFrame):
+        return obj.to_dict(orient="records")
+    if isinstance(obj, np.integer):
+        return int(obj)
+    if isinstance(obj, np.floating):
+        return float(obj)
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    return obj
 
 
 # ─── Input panels ────────────────────────────────────────────────────────────
@@ -59,11 +79,12 @@ def panel_load_from_excel():
     if st.button("↩️ Load inputs into all tabs", use_container_width=True):
         st.session_state.setdefault("input_file_name_suggestion", default_name)
         try:
-            resource_caps, constraints, costs, custom_resources = load_inputs_from_excel(uploaded)
+            resource_caps, constraints, costs, custom_resources, enabled_methods = load_inputs_from_excel(uploaded)
             st.session_state.resource_caps = resource_caps
             st.session_state.constraints = constraints
             st.session_state.costs = costs
             st.session_state.custom_resources = custom_resources
+            st.session_state.enabled_methods = enabled_methods
             clear_widget_keys()
             st.session_state.pop("latest_result", None)
             st.session_state.pop("scenario_loaded_file", None)
@@ -77,7 +98,17 @@ def panel_load_from_excel():
             st.error(f"Error loading file: {e}")
 
 def parse_zip_scenario(uploaded) -> dict | None:
-    """Reconstruct a scenario dict from a ZIP containing the 4 CSVs."""
+    """Reconstruct a scenario dict from a ZIP containing the exported CSVs.
+
+    Required: resource_caps.csv, method_constraints.csv, allocations.csv, method_costs.csv.
+    Optional: custom_resources.csv, enabled_methods.csv.
+
+    The detailed outputs (resource_usage, resource_used_total, resource_remaining) 
+    are NOT trusted from allocations.csv alone — they are
+    recomputed by re-running the optimizer on the reloaded inputs. This guarantees
+    the reloaded scenario is always internally consistent (and lets results pages
+    render without missing keys), instead of relying on whatever was exported.
+    """
 
     try:
         with zipfile.ZipFile(io.BytesIO(uploaded.read())) as zf:
@@ -153,16 +184,69 @@ def parse_zip_scenario(uploaded) -> dict | None:
                             "name": bname,
                             "group": str(df_b["group"].iloc[0]),
                             "amount": float(df_b["amount"].iloc[0]),
+                            "unit": str(df_b["unit"].iloc[0]) if "unit" in df_b.columns else "?",
                             "methods": methods,
                         })
 
+            # Load optional per-resource manual method allocation
+            enabled_methods = {}
+            if "enabled_methods.csv" in names:
+                df_enabled = pd.read_csv(io.BytesIO(zf.read("enabled_methods.csv")))
+                required_enabled = {"resource", "method", "enabled"}
+                if required_enabled.issubset(df_enabled.columns):
+                    for _, row in df_enabled.iterrows():
+                        enabled_methods.setdefault(str(row["resource"]), {})[str(row["method"])] = bool(row["enabled"])
+
+            safe_constraints = neutralize_zero_coefficient_methods(
+                st.session_state.costs, st.session_state.constraints
+            )
+            neutralized = [
+                m for m in safe_constraints
+                if safe_constraints[m].get("active") is False
+                and st.session_state.constraints.get(m, {}).get("active") is True
+            ]
+            
+            # Recompute detailed outputs from the reloaded inputs so the scenario
+            # is internally consistent (rather than trusting allocations.csv alone).
+            success, result = run_optimization(
+                resource_caps=resource_caps,
+                method_constraints=constraints,
+                method_costs=costs,
+                custom_resources=custom_resources,
+                enabled_methods=enabled_methods,
+            )
+
+            if neutralized:
+                st.info(
+                    f"ℹ️ {len(neutralized)} méthode(s) désactivée(s) automatiquement (aucune ressource active) : "
+                    + ", ".join(neutralized)
+                )
+
+            if success:
+                allocations = result["method_usage"]
+                total = result["total_removed"]
+                resource_usage = result["resource_usage"]
+                resource_used_total = result["resource_used_total"]
+                resource_remaining = result["resource_remaining"]
+            else:
+                # Fall back to the raw exported allocations if re-optimisation
+                # fails (e.g. incompatible inputs) — better than returning None.
+                allocations = df[col].to_dict()
+                total = sum(allocations.values())
+                resource_usage = {}
+                resource_used_total, resource_remaining = {}, {}
+
             return {
                 "summary": {"total_co2_removed": total, "total_cost": 0},
                 "allocations": allocations,
+                "resource_usage": resource_usage,
+                "resource_used_total": resource_used_total,
+                "resource_remaining": resource_remaining,
                 "resource_caps": resource_caps,
                 "method_constraints": constraints,
                 "method_costs": costs,
                 "custom_resources": custom_resources,
+                "enabled_methods": enabled_methods,
             }
         
     except Exception:
@@ -198,7 +282,7 @@ def panel_load_from_json_or_csv():
         if data is None:
             st.error(
                 "Invalid ZIP. Expected: resource_caps.csv, method_constraints.csv, "
-                "method_costs.csv, allocations.csv"
+                "method_costs.csv, allocations.csv, "
             )
             return
     
@@ -215,6 +299,7 @@ def panel_load_from_json_or_csv():
         st.session_state.costs = data["method_costs"].copy()
         # Restore custom resource batches if present in the scenario
         st.session_state.custom_resources = data.get("custom_resources", [])
+        st.session_state.enabled_methods = data.get("enabled_methods", {})
         clear_widget_keys()
         st.session_state["scenario_loaded_file"] = uploaded_json.name
         st.session_state["scenario_name"] = default_name
@@ -235,6 +320,7 @@ def clear_widget_keys():
 
 def run_and_store_result():
     custom_resources = st.session_state.get("custom_resources", [])
+    enabled_methods = st.session_state.get("enabled_methods", {}) # for custom standard resources
 
     # Check that at least some resource is non-zero (standard OR custom)
     std_total = sum(st.session_state.resource_caps.values())
@@ -243,12 +329,22 @@ def run_and_store_result():
     if std_total <= 0 and custom_total <= 0:
         st.warning("⚠️ All resources are set to 0. Please set resource availability or load a scenario / input data.")
         return
+    
+    safe_constraints = neutralize_zero_coefficient_methods(
+        st.session_state.costs, st.session_state.constraints
+    )
+    neutralized = [
+        m for m in safe_constraints
+        if safe_constraints[m].get("active") is False
+        and st.session_state.constraints.get(m, {}).get("active") is True
+    ]
 
     success, result = run_optimization(
         resource_caps=st.session_state.resource_caps,
         method_constraints=st.session_state.constraints,
         method_costs=st.session_state.costs,
         custom_resources=custom_resources,
+        enabled_methods=enabled_methods,
     )
 
     if not success:
@@ -256,6 +352,12 @@ def run_and_store_result():
         if "message" in result:
             st.error(result["message"])
         return
+    
+    if neutralized:
+        st.info(
+            f"ℹ️ {len(neutralized)} méthode(s) désactivée(s) automatiquement (aucune ressource active) : "
+            + ", ".join(neutralized)
+        )
 
     allocations = result["method_usage"]
     total_removed = result["total_removed"]
@@ -271,7 +373,6 @@ def run_and_store_result():
     st.session_state.latest_result = {
         "summary": {"total_co2_removed": total_removed, "total_cost": total_cost},
         "allocations": allocations,
-        "method_potential": result["method_potential"],
         "resource_usage": result["resource_usage"],
         "resource_used_total": result["resource_used_total"],
         "resource_remaining": result["resource_remaining"],
@@ -279,6 +380,7 @@ def run_and_store_result():
         "method_constraints": st.session_state.constraints,
         "method_costs": st.session_state.costs,
         "custom_resources": custom_resources,
+        "enabled_methods": enabled_methods,
     }
     if custom_resources:
         st.info(f"ℹ️ {len(custom_resources)} new resource(s) included in optimisation.")
@@ -324,9 +426,16 @@ def build_resource_usage_df(resource_usage):
     for r, methods in resource_usage.items():
         unit = resource_unit_map.get(resource_to_group.get(r))
         if unit is None:
-            for batch in st.session_state.custom_resources:
-                group = resource_to_group.get(batch["group"])
-                unit = resource_unit_map.get(group, '?')
+            # Custom resource — find the matching batch by name, not any batch
+            batch = next(
+                (b for b in st.session_state.get("custom_resources", []) if b["name"] == r),
+                None,
+            )
+            if batch:
+                group_name = resource_to_group.get(batch["group"])
+                unit = resource_unit_map.get(group_name, "?")
+            else:
+                unit = "?"
 
         for m, qty in methods.items():
             rows.append({
@@ -337,7 +446,7 @@ def build_resource_usage_df(resource_usage):
 
     return pd.DataFrame(rows)
 
-def build_results_df(allocations, method_potential=None, method_constraints=None):
+def build_results_df(allocations, method_constraints=None):
     df = pd.DataFrame.from_dict(allocations, orient="index", columns=[f"{CO2_UNIT} removed"])
 
     df[f"{CO2_UNIT} removed"] = pd.to_numeric(df[f"{CO2_UNIT} removed"], errors="coerce")
@@ -345,15 +454,6 @@ def build_results_df(allocations, method_potential=None, method_constraints=None
     if total > 0:
         df["Total share (%)"] = (df[f"{CO2_UNIT} removed"] / total * 100).round(2)
 
-    if method_potential:
-        df["Potential (" + CO2_UNIT + ")"] = pd.Series(method_potential)
-        # df["Allocated / Potential (%)"] = (
-        #     df[f"{CO2_UNIT} removed"] / df["Potential (" + CO2_UNIT + ")"] * 100
-        # ).round(1)
-        df["Potential (" + CO2_UNIT + ")"] = df[
-            "Potential (" + CO2_UNIT + ")"
-        ].map(lambda x: f"{x:,.2f}" if pd.notna(x) else x)
-
     if method_constraints:
         caps = {}
         for m in df.index:
@@ -378,26 +478,21 @@ def show_donut(df_result):
     st.plotly_chart(fig, use_container_width=True)
     register_chart_data("Method allocation (donut)", df_plot)
 
-def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None):
+def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None, resource_usage=None):
     # Normalize standard method_costs keys (strip legacy unit suffixes)
     normalized_costs = {
         m: {strip_unit_suffix(r): v for r, v in resources.items()}
         for m, resources in method_costs.items()
     }
 
-    # Inject custom resource coefficients (median)
-    for batch in (custom_resources or []):
-        for method, coefs in batch["methods"].items():
-            normalized_costs.setdefault(method, {})[batch["name"]] = coefs["median"]
-
     # Build complete caps — resource_caps may not contain custom batches
-    # if latest_result was generated before the enriched_caps fix
     full_caps = dict(resource_caps)
     for batch in (custom_resources or []):
         full_caps.setdefault(batch["name"], float(batch["amount"]))
 
     standard_available = [r for r in resource_order if full_caps.get(r, 0) > 0]
-    extra_available = [b["name"] for b in (custom_resources or [])]
+    custom_names = {b["name"] for b in (custom_resources or [])}
+    extra_available = [b["name"] for b in (custom_resources or []) if float(b["amount"]) > 0]
     available = standard_available + extra_available
 
     if not available:
@@ -406,11 +501,20 @@ def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None):
 
     matrix, y_labels = [], []
     for method in df_result.index:
-        row = [
-            (normalized_costs.get(method, {}).get(r, 0.0) * df_result.at[method, f"{CO2_UNIT} removed"]
-             / full_caps[r] * 100) if full_caps.get(r, 0) > 0 else 0
-            for r in available
-        ]
+        row = []
+        for r in available:
+            cap = full_caps.get(r, 0)
+            if cap <= 0:
+                row.append(0)
+                continue
+            if resource_usage is not None:
+                # Use actual LP usage (correctly handles z-split for custom batches
+                # and the reduced standard usage when a batch absorbs part of the load)
+                used = resource_usage.get(r, {}).get(method, 0.0)
+            else:
+                # Fallback for legacy scenarios without resource_usage
+                used = normalized_costs.get(method, {}).get(r, 0.0) * df_result.at[method, f"{CO2_UNIT} removed"]
+            row.append(used / cap * 100)
         matrix.append(row)
         y_labels.append(method)
 
@@ -430,37 +534,26 @@ def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None):
 
     register_chart_data("Resource usage heatmap (% of cap)", df_export)
 
-def show_absolute_usage(allocations, method_costs, custom_resources=None):
+def show_absolute_usage(allocations, method_costs, custom_resources=None, resource_usage=None):
     # Normalize method_costs keys: strip legacy unit suffixes
     normalized_costs = {
         m: {strip_unit_suffix(r): v for r, v in resources.items()}
         for m, resources in method_costs.items()
     }
-
     # Build resource_units from standard groups
     _resource_units = defaultdict(list)
+    resource_to_group = {r: group for group, resources in resource_groups.items() for r in resources}
     for cat, resources in resource_groups.items():
-        unit_key = f"{resource_unit_map[cat]}/MtCO2"
-        _resource_units[unit_key].extend(resources)
+        _resource_units[resource_unit_map[cat]].extend(resources)
 
-    resource_to_group = {
-        r: group
-        for group, resources in resource_groups.items()
-        for r in resources
-    }
-    
-    # Inject custom resource batches into the unit map
+    # Inject custom resource batches using the correct unit from their reference group
+    custom_batch_names = set()
     for batch in (custom_resources or []):
-        group = resource_to_group.get(batch["group"])
-        unit_key = f"{resource_unit_map.get(group, '?')}/MtCO2"
-        if batch["name"] not in _resource_units[unit_key]:
-            _resource_units[unit_key].append(batch["name"])
-        # Make sure the median coefficient is in normalized_costs
-        for method, coefs in batch["methods"].items():
-            if method in normalized_costs:
-                normalized_costs[method].setdefault(batch["name"], coefs["median"])
-            else:
-                normalized_costs[method] = {batch["name"]: coefs["median"]}
+        custom_batch_names.add(batch["name"])
+        group_name = resource_to_group.get(batch["group"])
+        correct_unit = resource_unit_map.get(group_name, "?")
+        if batch["name"] not in _resource_units[correct_unit]:
+            _resource_units[correct_unit].append(batch["name"])
 
     local_resource_units = dict(_resource_units)
 
@@ -468,9 +561,21 @@ def show_absolute_usage(allocations, method_costs, custom_resources=None):
     for m, co2 in allocations.items():
         for unit, resources in local_resource_units.items():
             for r in resources:
-                cost = normalized_costs.get(m, {}).get(r)
-                if cost is not None and cost * co2 > 0:
-                    rows.append({"Method": m, "Resource": r, "Used": cost * co2, "Unit": unit})
+                if r in custom_batch_names:
+                    # Use actual LP usage — coefficient × total_y_m overcounts when
+                    # standard and custom pools are split across z variables
+                    used_qty = (resource_usage or {}).get(r, {}).get(m, 0.0)
+                    if used_qty > 1e-9:
+                        rows.append({"Method": m, "Resource": r, "Used": used_qty, "Unit": unit})
+                else:
+                    if resource_usage is not None:
+                        used_qty = resource_usage.get(r, {}).get(m, 0.0)
+                        if used_qty > 1e-9:
+                            rows.append({"Method": m, "Resource": r, "Used": used_qty, "Unit": unit})
+                    else:
+                        cost = normalized_costs.get(m, {}).get(r)
+                        if cost is not None and cost * co2 > 0:
+                            rows.append({"Method": m, "Resource": r, "Used": cost * co2, "Unit": unit})
     if not rows:
         return
 
@@ -503,7 +608,7 @@ def show_resource_balance(latest):
     rows = []
     for r in resource_caps:
         group = resource_to_group.get(r)
-        unit = f"{resource_unit_map.get(group, '?')}"
+        unit = resource_unit_map.get(group)
         cap = resource_caps[r]
         if cap <= 0:
             continue
@@ -575,19 +680,19 @@ def export_scenario():
     name = st.session_state.get("scenario_name", "").strip()
     if not name or name not in st.session_state.scenarios:
         return
+    
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    } 
 
     scenario = st.session_state.scenarios[name]
-    # st.markdown(f"#### Scenario: {name}")
-    # df_saved = build_results_df(scenario["allocations"], method_constraints=scenario.get("method_constraints"))
-
-    # st.markdown(format_table_summary(df_saved,"cdr-table-res"), unsafe_allow_html=True)
-
     safe = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode("ascii")
     col_json, col_csv = st.columns(2)
-
     with col_json:
         st.download_button(
-            "Export JSON", data=json.dumps(scenario, indent=2),
+            "Export JSON", data=json.dumps(_to_json_safe(scenario), indent=2),
             file_name=f"{safe}.json", mime="application/json",
             use_container_width=True,
             icon=":material/download:"
@@ -608,12 +713,14 @@ def export_scenario():
                 "cap_type": "cap_type (percent or absolute)"
             }).to_csv()
         )
+
         zf.writestr("method_costs.csv",                      
                     pd.DataFrame.from_dict(scenario["method_costs"], orient="index").to_csv())
+        
         zf.writestr("allocations.csv",
                     pd.DataFrame.from_dict(scenario["allocations"], orient="index",
                                            columns=[f"{CO2_UNIT} removed"]).to_csv())
-        # Custom resource batches — one row per (batch × method)
+        
         custom_batches = scenario.get("custom_resources", [])
         if custom_batches:
             custom_rows = []
@@ -623,6 +730,7 @@ def export_scenario():
                         "name": batch["name"],
                         "group": batch["group"],
                         "amount": batch["amount"],
+                        "unit": resource_unit_map.get(resource_to_group.get(batch["group"])),
                         "method": method,
                         "min": coefs["min"],
                         "median": coefs["median"],
@@ -630,6 +738,33 @@ def export_scenario():
                     })
             zf.writestr("custom_resources.csv", pd.DataFrame(custom_rows).to_csv(index=False))
 
+        enabled_methods = scenario.get("enabled_methods", {})
+        if enabled_methods:
+            enabled_rows = [
+                {"resource": r, "method": m, "enabled": ok}
+                for r, methods in enabled_methods.items()
+                for m, ok in methods.items()
+            ]
+            zf.writestr("enabled_methods.csv", pd.DataFrame(enabled_rows).to_csv(index=False))
+
+        resource_used_total = scenario.get("resource_used_total", {})
+        resource_remaining = scenario.get("resource_remaining", {})
+        if resource_used_total or resource_remaining:
+            df_balance = pd.DataFrame({
+                "Used": pd.Series(resource_used_total),
+                "Remaining": pd.Series(resource_remaining),
+            })
+            zf.writestr("resource_balance.csv", df_balance.to_csv())
+
+        resource_usage = scenario.get("resource_usage", {})
+        if resource_usage:
+            usage_rows = [
+                {"resource": r, "method": m, "used": qty}
+                for r, methods in resource_usage.items()
+                for m, qty in methods.items()
+            ]
+            zf.writestr("resource_usage_detail.csv", pd.DataFrame(usage_rows).to_csv(index=False))
+
     with col_csv:
         st.download_button(
             "Export CSV (zip)", data=buf.getvalue(),
@@ -653,6 +788,12 @@ def export_inputs_only():
         st.session_state["input_file_name"] = suggested
         st.session_state["_input_file_name_source"] = suggested
 
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    } 
+
     col_text, col_btn = st.columns([3, 1])
     with col_text:
         st.text_input(
@@ -667,6 +808,11 @@ def export_inputs_only():
     if prepare:
         safe = st.session_state.get("input_file_name", "").strip() or suggested or "crra_inputs"
 
+        enabled_methods = st.session_state.get("enabled_methods", {})
+
+        def _is_allowed(method, resource):
+            return enabled_methods.get(resource, {}).get(method, True)
+
         wb = openpyxl.Workbook()
         ws1 = wb.active
         ws1.title = "resource_caps"
@@ -679,27 +825,40 @@ def export_inputs_only():
         for m, c in st.session_state.constraints.items():
             ws2.append([m, c.get("active", True), c.get("cap_type", "percent"), c.get("cap_value", 100)])
 
+        # Coefficients — a disabled (method, resource) pair is always exported
+        # as 0, regardless of whether the user ever opened it in tab3. This
+        # keeps the export consistent with what the optimizer actually uses.
         ws3 = wb.create_sheet("coefficients")
         ws3.append(["method", "resource", "value", "secondary"])
         for m, resources in st.session_state.costs.items():
             for r, v in resources.items():
-                ws3.append([m, r, v, (m, r) in secondary_resources])
+                value = 0.0 if not _is_allowed(m, r) else v
+                ws3.append([m, r, value, (m, r) in secondary_resources])
 
         ws4 = wb.create_sheet("custom_resources")
         ws4.append(["name", "group", "amount", "unit", "method", "min", "median", "max"])
         for batch in st.session_state.get("custom_resources", []):
+            unit = resource_unit_map.get(resource_to_group.get(batch["group"]))
             for method, c in batch["methods"].items():
                 ws4.append([
                     batch["name"],
                     batch["group"],
                     batch["amount"],
-                    resource_unit_map.get(batch["group"]),
+                    unit,
                     method,
                     c["min"],
                     c["median"],
                     c["max"],
                 ])
 
+        # Per-resource manual method allocation (objective 2) — which CDR
+        # methods are allowed to use each resource batch.
+        ws5 = wb.create_sheet("enabled_methods")
+        ws5.append(["resource", "method", "enabled"])
+        for r, methods in enabled_methods.items():
+            for m, ok in methods.items():
+                ws5.append([r, m, bool(ok)])
+
         buf = io.BytesIO()
         wb.save(buf)
 
@@ -716,8 +875,6 @@ def export_inputs_only():
             icon=":material/download:"
         )
 
-import zipfile
-
 def export_all_charts():
     st.markdown("### Export all chart data")
     st.markdown(
@@ -841,6 +998,8 @@ def render_tab():
         ("scenario_uploader_key", 0)
     ]:
         st.session_state.setdefault(key, default)
+    if "enabled_methods" not in st.session_state:
+        st.session_state.enabled_methods = {}
 
     # ── Two-column input area ──────────────────────────────────────────────
     st.markdown("""
@@ -884,7 +1043,6 @@ def render_tab():
     show_metrics(latest)
     df_result = build_results_df(
         allocations,
-        method_potential=latest.get("method_potential"),
         method_constraints=latest.get("method_constraints")
     )
 
@@ -895,22 +1053,9 @@ def render_tab():
     )
 
     st.subheader("Optimization Summary")
-    # st.markdown(
-    #     format_table_summary(df_display, "cdr-table-res"),
-    #     unsafe_allow_html=True
-    # )
 
     st.dataframe(
         df_display,
-        column_config={
-            "Potential (MtCO₂)": st.column_config.NumberColumn(
-                "Potential (MtCO₂)",
-                help="Maximum CO₂ this method could remove if limited only by "
-                    "resources and its own cap, without competition from other "
-                    "methods. For % caps, this value ignores the cap.",
-                format="%.0f",
-            ),
-        },
         use_container_width=True,
     )
 
@@ -918,10 +1063,14 @@ def render_tab():
     show_donut(df_result)
 
     st.markdown("### Resource usage heatmap (% of cap)")
-    show_heatmap(df_result, resource_caps, method_costs, custom_resources=latest.get("custom_resources", []))
+    show_heatmap(df_result, resource_caps, method_costs,
+                 custom_resources=latest.get("custom_resources", []),
+                 resource_usage=latest.get("resource_usage"))
 
     st.markdown("### Absolute resource usage by unit")
-    show_absolute_usage(allocations, method_costs, custom_resources=latest.get("custom_resources", []))
+    show_absolute_usage(allocations, method_costs,
+                        custom_resources=latest.get("custom_resources", []),
+                        resource_usage=latest.get("resource_usage"))
 
     show_resource_balance(latest)
     df_usage = build_resource_usage_df(latest["resource_usage"])

utils/data_utils.py

@@ -32,7 +32,7 @@ def render_resource_input(name_clean, r, tooltip=None):
     st.session_state.resource_caps[r] = cap
 
 def is_valid_scenario(scenario):
-    return (
+    base_ok = (
         isinstance(scenario, dict)
         and "allocations" in scenario
         and "resource_caps" in scenario
@@ -40,6 +40,18 @@ def is_valid_scenario(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)
@@ -52,20 +64,11 @@ def load_inputs_from_excel(file):
     constraints = {}
     if "constraints" in xl:
         for _, row in xl["constraints"].iterrows():
-            # Compatibility with older files that used `max_share`
-            # if "cap_type (percent or absolute)" in xl["constraints"].columns:
                 constraints[row["method"]] = {
                     "active": bool(row["active"]),
                     "cap_type": str(row["cap_type (percent or absolute)"]),
                     "cap_value": float(row["cap_value"])
                 }
-            # else:
-            #     constraints[row["method"]] = {
-            #         "active": bool(row["active"]),
-            #         "cap_type": "percent",
-            #         "cap_value": float(row["max_share"])
-            #     }
-
     costs = {}
     if "coefficients" in xl:
         for _, row in xl["coefficients"].iterrows():
@@ -73,33 +76,55 @@ def load_inputs_from_excel(file):
             costs.setdefault(m, {})[r] = v
 
     custom_resources = []
-    print("--------------------------------")
     if "custom_resources" in xl:
         df_custom = xl["custom_resources"]
-        if not df_custom.empty:
-            for name in df_custom["name"].unique():
-                df_b = df_custom[df_custom["name"] == name]
-                batch = {
-                    "name": name,
-                    "group": df_b["group"].iloc[0],
-                    "amount": float(df_b["amount"].iloc[0]),
-                    "unit": resource_unit_map.get(
-                        df_b["group"].iloc[0],
-                        ""
-                    ),
-                    "methods": {}
-                }
-
-                for _, row in df_b.iterrows():
-                    batch["methods"][row["method"]] = {
+        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]
+                methods = {
+                    row["method"]: {
                         "min": float(row["min"]),
                         "median": float(row["median"]),
                         "max": float(row["max"]),
                     }
-                custom_resources.append(batch)
+                    for _, row in df_b.iterrows()
+                }
+                custom_resources.append({
+                    "name": str(bname),
+                    "group": str(df_b["group"].iloc[0]),
+                    "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
+    return resource_caps, constraints, costs, custom_resources, enabled_methods
 
 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()
+    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
+
+    return safe_constraints

utils/ui_helpers.py

@@ -82,9 +82,6 @@ def format_table_summary(df: pd.DataFrame, class_name: str):
     
 def format_efficiency_summary(df: pd.DataFrame, df_default: pd.DataFrame):
     df_numeric = df.copy()
-
-    df_numeric.index.name = "Method"
-
     df_display = df_numeric.map(smart_display_format)
 
     # Highlight modified values
@@ -96,24 +93,17 @@ def format_efficiency_summary(df: pd.DataFrame, df_default: pd.DataFrame):
                     current = df_numeric.at[m, r]
                     default = df_default.at[m, r]
                     if abs(current - default) > 1e-6:
-                        styled.at[m, r] = 'background-color: #cce5ff'
+                        styled.at[m, r] = 'background-color: #ff5f4d'
                 except:
                     continue
         return styled
 
     # Table style
-    num_columns = df.shape[1]
-    styles = [
-        {"selector": "thead th", "props": [("background-color", background_color), ("color", "white"), ("font-weight", "bold")]},
-        {"selector": "th.row_heading", "props": [("text-align", "left"), ("font-weight", "bold"), ("width", "240px")]}
-    ]
-    for i in range(num_columns):
-        styles.append({
-            "selector": f"td.col{i}",
-            "props": [("text-align", "center"), ("width", "160px")]
-        })
-
-    return df_display.style.apply(highlight_changes, axis=None).set_table_styles(styles)
+    return (
+        df_display
+        .style
+        .apply(highlight_changes, axis=None)
+    )
 
 # -----------------------------
 # SLIDER GROUP HELPER