[FIX] Geologic storage fixed coeff + template improvements + UI fixes

assets/styles.css

@@ -376,7 +376,8 @@ h1.custom-title {
 [data-testid="stTextArea"] label p,
 [data-testid="stSelectbox"] label p,
 [data-testid="stMultiSelect"] label p,
-[data-testid="stSlider"] label p {
+[data-testid="stSlider"] label p,
+[class="crra-resource-name"] {
     font-weight: 600 !important;
     color: var(--brown-grey) !important;
     font-size: 0.85rem !important;
@@ -440,6 +441,7 @@ h1.custom-title {
 /* Slider help text */
 [class*="slider_"] p,
 [class*="manual_"] p,
+[class="crra-resource-name"],
 [data-testid="stSlider"] p {
     font-style: italic;
     color: var(--grey);
@@ -586,12 +588,18 @@ section[data-testid="stExpander"] summary p {
 }
 
 /* ── 16. Button container layout ────────────────────────────── */
-.st-key-container-btn {
+.st-key-container-btn{
     display: flex;
     flex-direction: row;
     gap: 1.125%;
 }
 
+.st-key-container-btn-new {
+    display: flex;
+    flex-direction: row-reverse;
+    gap: 1.125%;
+}
+
 /* ── 17. Scrollbar ──────────────────────────────────────────── */
 ::-webkit-scrollbar {
     width: 6px;
@@ -608,3 +616,57 @@ section[data-testid="stExpander"] summary p {
 ::-webkit-scrollbar-thumb:hover {
     background: var(--brown-grey);
 }
+
+/* ── 18. Welcome page titles ─────────────────────────────────── */
+h3.wt {
+    font-weight: 700 !important;
+    font-size: clamp(13px, 3vw, 20px) !important;
+    text-transform: uppercase;
+    letter-spacing: 0.12em;
+    margin: 28px 0 10px 0 !important;
+    padding: 6px 0 6px 14px;
+    border-left: 4px solid;
+    line-height: 1.3;
+    font-style: normal !important;
+}
+h3.wt-1 { color: #124216 !important;           border-left-color: #124216;           }
+h3.wt-2 { color: var(--green-dark) !important; border-left-color: var(--green-dark); }
+h3.wt-3 { color: var(--green) !important;      border-left-color: var(--green);      }
+h3.wt-4 { color: var(--green-light) !important; border-left-color: var(--green-light); }
+
+/* ── 19. Tabs ────────────────────────────────────────────────── */
+[data-baseweb="tab-list"] {
+    gap: 4px;
+    border-bottom: 2px solid var(--off-white);
+    padding-bottom: 0;
+}
+
+[data-baseweb="tab"] {
+    padding: 10px 20px;
+    font-size: 0.875rem;
+    font-weight: 600;
+    letter-spacing: 0.02em;
+    border-radius: 6px 6px 0 0;
+    background-color: var(--off-white);
+    color: var(--brown-grey);
+    border: none;
+    transition: background-color 0.15s ease, color 0.15s ease;
+}
+
+[data-baseweb="tab"]:hover {
+    background-color: #e8e8e8;
+    color: var(--black);
+}
+
+[aria-selected="true"][data-baseweb="tab"] {
+    background-color: var(--black);
+    color: var(--white);
+}
+
+[data-baseweb="tab-highlight"] {
+    display: none;
+}
+
+[data-baseweb="tab-border"] {
+    display: none;
+}

data/cost_sliders.json

@@ -19,11 +19,6 @@
     }
   },
   "BioCCS with anaerobic digestion/fermentation": {
-    "Arable land (Mha/MtCO2)": {
-      "min": 0.022803,
-      "median": 0.058844,
-      "max": 0.454545
-    },
     "Non-forest biomass (Mt/MtCO2)": {
       "min": 1.315,
       "median": 1.561743,
@@ -38,6 +33,11 @@
       "min": 0.368182,
       "median": 0.565909,
       "max": 0.913636
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "BioCCS with combustion": {
@@ -70,6 +70,11 @@
       "min": 0.00063,
       "median": 0.201625,
       "max": 1.296342
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Coastal revegetation (mangrove, seaweeds, etc.)": {
@@ -123,6 +128,11 @@
       "min": 0.001,
       "median": 0.005,
       "max": 0.027
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Electrochemical OAE": {
@@ -174,6 +184,11 @@
       "min": 5e-09,
       "median": 0.0047,
       "max": 0.05
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Low-temp DACCS (solid-sorbent/liquid-solvent)": {
@@ -196,6 +211,11 @@
       "min": -0.002,
       "median": 0.001008,
       "max": 0.015
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Mineral OAE / Ocean liming": {
@@ -250,6 +270,11 @@
       "min": 0.0,
       "median": 0.0002,
       "max": 0.026714
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Mineralization ex-situ": {
@@ -299,6 +324,11 @@
       "min": -0.00015,
       "median": 0.000427,
       "max": 0.001
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Pasture management": {
@@ -335,6 +365,11 @@
       "min": 0.217391,
       "median": 6.608696,
       "max": 13.0
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Bio-char - Forest biomass": {
@@ -536,6 +571,11 @@
       "min": 0.00063,
       "median": 0.201625,
       "max": 1.296342
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "BioCCS with anaerobic digestion/fermentation & growing biomass": {
@@ -548,6 +588,11 @@
       "min": 0.368182,
       "median": 0.565909,
       "max": 0.913636
+    },
+    "Geologic storage (Mt/MtCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   }
 }

data/generate_cost_matrix.py

@@ -33,7 +33,7 @@ def create_sliders_inputs():
         But set the other two to zero, and keep the values in the other resources intact
         """
         resource = row["Resource"] + " (" + row["Unit"] + ")"
-        if row["min"] == row["max"]:
+        if row["min"] == row["max"] and row["Resource"] != "Geologic storage":
             row["min"] = row["min"] * .5
         entry = {
             "min": float(row["min"]),
@@ -85,7 +85,7 @@ def create_sliders_inputs():
     pop_by_name(cost_sliders["BioCCS with combustion & growing biomass"], "Unspecified biomass")
     
     cost_sliders["BioCCS with anaerobic digestion/fermentation & growing biomass"] = cost_sliders["BioCCS with anaerobic digestion/fermentation"].copy()
-    pop_by_name(cost_sliders["BioCCS with anaerobic digestion/fermentation"], "Arable land (ha/tCO2)")
+    pop_by_name(cost_sliders["BioCCS with anaerobic digestion/fermentation"], "Arable land")
     pop_by_name(cost_sliders["BioCCS with anaerobic digestion/fermentation & growing biomass"], "Non-forest biomass")
     pop_by_name(cost_sliders["BioCCS with anaerobic digestion/fermentation & growing biomass"], "Unspecified biomass")
     

data/generate_input_template.py

@@ -25,9 +25,42 @@ resource_to_unit = {
     for r in resources
 }
 
+# instructions
+ws0 = wb.active
+ws0.title = "instructions"
+ws0.column_dimensions["A"].width = 25
+ws0.column_dimensions["B"].width = 80
+header_font = Font(bold=True)
+ws0.append(["Sheet", "Description", "Columns to edit", "Do not modify"])
+ws0["A1"].font = header_font
+ws0["B1"].font = header_font
+ws0["C1"].font = header_font
+ws0["D1"].font = header_font
+ws0.column_dimensions["C"].width = 35
+ws0.column_dimensions["D"].width = 30
+ws0.append(["resource_caps",
+    "Total available quantities of each resource for 1 year of optimization. Leave blank to exclude a resource.",
+    "Available Amount",
+    "Resource, Unit"])
+ws0.append(["constraints",
+    "Which CDR methods are active and their maximum deployment cap (percent of total potential, or absolute value in MtCO2/yr).",
+    "active (TRUE/FALSE), cap_type (percent or absolute), cap_value",
+    "method"])
+ws0.append(["coefficients",
+    "Resource usage coefficients for each CDR method. Adjust to reflect your country conditions.",
+    "value",
+    "method, resource, secondary"])
+ws0.append(["custom_resources",
+    "User-defined resource batches: sub-types of an existing resource group (e.g. 'Forest biomass - Eucalyptus' within 'Forest biomass'), with their own availability and per-method coefficients. Add one row per method linked to the resource.",
+    "All columns (add new rows)",
+    "—"])
+ws0.append(["enabled_methods",
+    "Which CDR methods are allowed to use each standard resource. Set to FALSE to prevent a method from using a resource.",
+    "enabled (TRUE/FALSE)",
+    "resource, method"])
+
 # resource_caps
-ws1 = wb.active
-ws1.title = "resource_caps"
+ws1 = wb.create_sheet("resource_caps")
 ws1.append(["Resource", "Unit", "Available Amount"])
 ws1["A1"].font = Font(bold=True)
 ws1["B1"].font = Font(bold=True)
@@ -55,7 +88,19 @@ for m in method_order:
         ws3.append([m, strip_unit_suffix(r), conf["median"], True if is_secondary else False])
 
 ws4 = wb.create_sheet("custom_resources")
-ws4.append(["name", "group", "amount", "method", "min", "median", "max"])
+ws4.append(["name", "group", "amount", "unit", "method", "min", "median", "max"])
+for cell in ws4[1]:
+    cell.font = Font(bold=True)
+ws4.append(["(Example) Forest biomass - Eucalyptus", "Forest biomass", 5.0, "Mt", "Bio-char - Forest biomass", 0.33, 0.37, 0.82])
+
+ws5 = wb.create_sheet("enabled_methods")
+ws5.append(["resource", "method", "enabled"])
+for cell in ws5[1]:
+    cell.font = Font(bold=True)
+for m in method_order:
+    for r_with_unit in cost_sliders.get(m, {}):
+        r = strip_unit_suffix(r_with_unit)
+        ws5.append([r, m, True])
 
 wb.save("data/inputs_template.xlsx")
 print("Template generated: data/inputs_template.xlsx")

data/inputs_aggregated.csv

@@ -73,4 +73,12 @@ Reforestation,Unspecified land,Physical,Mha/MtCO2,34,0.044459,1.564102,0.094927,
 Reforestation,Unspecified water,Physical,bcm/MtCO2,2,0.092,0.092,0.092,0.092,0,0.092,0.092
 pH swing,Electrical energy,Energy,MWh/MtCO2,28,980000,2205112,1768000,3302500,1381909,660000,4670000
 pH swing,Salt water,Physical,bcm/MtCO2,4,0.435,4.78,4.78,9.125,5.017174,0.435,9.125
-pH swing,Unspecified water,Physical,bcm/MtCO2,4,0.217391,6.608696,6.608696,13,7.380043,0.217391,13
+pH swing,Unspecified water,Physical,bcm/MtCO2,4,0.217391,6.608696,6.608696,13,7.380043,0.217391,13
+BioCCS with combustion,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+BioCCS with anaerobic digestion/fermentation,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+Electrochemical DACCS,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+Low-temp DACCS (solid-sorbent/liquid-solvent),Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+High-temp DACCS (solid-sorbent/liquid-solvent),Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+Mineral looping DACCS,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+Moisture swing DACCS,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1
+pH swing,Geologic storage,Physical,Mt/MtCO2,1,1,1,1,1,0,1,1

optimization/optimization.py

@@ -12,35 +12,25 @@ def run_optimization(
     """
     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)
+    LP variables:
+      y_m    = CO₂ removed by method m  (indices 0..M-1)
+      z_{m,n} = CO₂ drawn from custom batch n by method m  (indices M..N-1)
     """
 
     resource_caps = dict(resource_caps)
     method_costs  = {m: dict(v) for m, v in method_costs.items()}
+    print("first enabled_methods ----------- ")
 
     # ── Apply manual allocation overrides ─────────────────────────────────────
     enabled_methods = enabled_methods or {}
+    print(enabled_methods)
     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}}
+    custom_batch_info = {}
     for batch in (custom_resources or []):
         custom_batch_info[batch["name"]] = {
             "group":           batch["group"],
@@ -48,17 +38,13 @@ def run_optimization(
             "primary_methods": set(batch.get("methods", {}).keys()),
         }
     custom_names   = set(custom_batch_info)
-    ref_to_batches = {}             # {standard_resource: [batch_name, ...]}
+    ref_to_batches = {}
     for bname, info in custom_batch_info.items():
         ref_to_batches.setdefault(info["group"], []).append(bname)
         if bname not in resource_caps:
             resource_caps[bname] = info["amount"]
 
-    # Inject primary batch coefficients (fallback) ─────────────────────────────
-    # Tab 3 pre-init may have set the coefficient to 0; fall back to batch median.
-    # Custom pools are INDEPENDENT of the standard resource enable/disable toggle:
-    # a method can access a custom batch even if it is disabled for the standard
-    # reference resource — the D2 coupling constraint (y_m ≤ Σ z) bounds the LP.
+    # ── Inject primary batch coefficients (fallback: use batch median if coef=0)
     for batch in (custom_resources or []):
         bname = batch["name"]
         for method, coefs in batch["methods"].items():
@@ -74,40 +60,36 @@ def run_optimization(
         for method in batch["methods"]:
             coef = method_costs.get(method, {}).get(r_key)
             print(f"      method_costs['{method}']['{r_key}'] = {coef}")
+    print(method_costs)
     print(f"Total resources in matrix: {len(resource_caps)}")
     print(f"Total resources in matrix: {resource_caps}")
     print(f"Resources: {list(resource_caps.keys())}")
     print(f"{'='*50}\n")
 
-    # ── Active method list ────────────────────────────────────────────────────
+    # ── Active methods ────────────────────────────────────────────────────────
     methods    = [m for m in method_costs if method_constraints.get(m, {}).get("active", True)]
     M          = len(methods)
     method_idx = {m: j for j, m in enumerate(methods)}
     if not M:
         return False, {"message": "No active methods."}
 
-    # ── Split-variable list ───────────────────────────────────────────────────
-    # z_{m,n} is the CO₂ from method m drawn from custom pool n.
-    # y_m - Σ_n z_{m,n} is what method m draws from the standard pool.
-    # Custom pools are INDEPENDENT: a method can use a custom pool even when
-    # the standard resource is 0 or disabled for that method.
-    # Guard: skip batch if the batch itself has no capacity (Q_n = 0).
+    # ── Split variables z_{m,n} ───────────────────────────────────────────────
     z_pairs = []
     for bname, info in custom_batch_info.items():
         ref             = info["group"]
         primary_methods = info["primary_methods"]
         if resource_caps.get(bname, 0.0) <= 0:
-            continue  # custom batch has no capacity → inactive
+            continue
         for m in methods:
             if m not in primary_methods:
-                continue  # only methods explicitly linked to this batch in the dialog
+                continue
             c_n = method_costs.get(m, {}).get(bname, 0.0)
             if 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}]
+    N     = M + Z
 
     print(f"z_pairs ({Z}): {z_pairs}")
 
@@ -117,11 +99,9 @@ def run_optimization(
     resources_no_batches   = [r for r in standard_resources if r not in ref_to_batches]
 
     # ── Build LP constraint matrix ────────────────────────────────────────────
-    # constraint_labels tracks (type, identifier) for each row added to A_rows,
-    # enabling shadow-price extraction after the solve.
     A_rows, b_rows, constraint_labels = [], [], []
 
-    # (A) Standard resources with NO custom batch substitutes — unchanged rows
+    # (A) Standard resources — no custom substitutes
     for r in resources_no_batches:
         row = np.zeros(N)
         for j, m in enumerate(methods):
@@ -131,8 +111,8 @@ def run_optimization(
             b_rows.append(resource_caps[r])
             constraint_labels.append(("resource", r))
 
-    # (B) Standard resources that DO have custom batch substitutes
-    # Constraint: Σ_m  c_s[m] * (y_m - Σ_n z_{m,n})  ≤ Q_s
+    # (B) Standard resources — with custom substitutes (subtract z contribution)
+    # Σ_m cost(m,r) · (y_m − Σ_n z_{m,n}) ≤ cap(r)
     for r in resources_with_batches:
         row = np.zeros(N)
         for j, m in enumerate(methods):
@@ -140,13 +120,13 @@ def run_optimization(
             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
+                    row[z_idx[(m, bname)]] -= c_s_m
         if np.any(row != 0):
             A_rows.append(row)
             b_rows.append(resource_caps[r])
             constraint_labels.append(("resource", r))
 
-    # (C) Custom batch capacity constraints: Σ_m c_n[m] * z_{m,n} ≤ Q_n
+    # (C) Custom batch capacity: Σ_m cost(m,n) · z_{m,n} ≤ Q_n
     for bname, info in custom_batch_info.items():
         if resource_caps.get(bname, 0.0) <= 0:
             continue
@@ -162,12 +142,9 @@ def run_optimization(
             b_rows.append(resource_caps.get(bname, 0.0))
             constraint_labels.append(("custom_batch", bname))
 
-    # (D1) Coupling lower bound: Σ_{n: ref(n)=r} z_{m,n} ≤ y_m
-    # Keeps standard resource usage non-negative.
-    # (D2) Coupling upper bound when c_s = 0: y_m ≤ Σ z_{m,n}
-    # When a method has no access to the standard resource (disabled or coef=0),
-    # its entire output must come from custom batches — prevents y_m from being
-    # unbounded. Together with D1 this forces y_m = Σ z when c_s = 0.
+    # (D1) Σ z_{m,n} ≤ y_m  — keeps standard resource usage non-negative
+    # (D2) y_m ≤ Σ z_{m,n}  — only when c_s=0: entire output must come from batch
+    #      D1 + D2 together force y_m = Σz when the standard resource is unavailable
     coupling_done = set()
     for (m, bname) in z_pairs:
         ref = custom_batch_info[bname]["group"]
@@ -179,7 +156,6 @@ def run_optimization(
         c_s_m = method_costs.get(m, {}).get(ref, 0.0)
         batch_cols = [z_idx[(m, bn)] for bn in ref_to_batches.get(ref, []) if (m, bn) in z_idx]
 
-        # D1: Σ z ≤ y_m  →  Σ z - y_m ≤ 0
         row = np.zeros(N)
         row[j] = -1.0
         for col in batch_cols:
@@ -188,7 +164,6 @@ def run_optimization(
         b_rows.append(0.0)
         constraint_labels.append(("coupling_D1", (m, ref)))
 
-        # D2 (only when c_s = 0): y_m ≤ Σ z  →  y_m - Σ z ≤ 0
         if c_s_m == 0:
             row2 = np.zeros(N)
             row2[j] = 1.0
@@ -198,7 +173,7 @@ def run_optimization(
             b_rows.append(0.0)
             constraint_labels.append(("coupling_D2", (m, ref)))
 
-    # (E) Method cap constraints (on y_m)
+    # (E) Method caps
     for j, m in enumerate(methods):
         constraint = method_constraints.get(m, {})
         cap_type   = constraint.get("cap_type",  "percent")
@@ -221,7 +196,7 @@ def run_optimization(
     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)
+    # Objective: maximize Σ y_m  →  minimize ���Σ y_m
     c_obj         = np.zeros(N)
     c_obj[:M]     = -1.0
     bounds        = [(0, None)] * N
@@ -233,7 +208,7 @@ def run_optimization(
             return False, {"message": result.message}
 
         sol = result.x
-        y   = sol[:M]   # total CO₂ per method
+        y   = sol[:M]
 
         total_removed = float(y.sum())
         method_usage  = {methods[j]: float(y[j]) for j in range(M) if y[j] > 1e-9}
@@ -242,14 +217,12 @@ def run_optimization(
         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)
@@ -262,34 +235,26 @@ def run_optimization(
                 if used > 1e-9:
                     resource_usage[r][m] = float(used)
 
-        # Custom batches — only for methods explicitly linked in the dialog
         for bname, info in custom_batch_info.items():
-            ref             = info["group"]
             primary_methods = info["primary_methods"]
             for j, m in enumerate(methods):
                 if m not in primary_methods:
-                    continue  # ignore stale session-state coefficients
+                    continue
                 c_n_m = method_costs.get(m, {}).get(bname, 0.0)
                 if c_n_m <= 0:
                     continue
-                if (m, bname) in z_idx:
-                    used = c_n_m * sol[z_idx[(m, bname)]]
-                else:
-                    used = 0.0
+                used = c_n_m * sol[z_idx[(m, bname)]] if (m, bname) in z_idx else 0.0
                 if used > 1e-9:
                     resource_usage[bname][m] = float(used)
 
         resource_used_total = {r: sum(v.values()) for r, v in resource_usage.items()}
 
-        all_caps          = {**resource_caps,
-                             **{bn: info["amount"] for bn, info in custom_batch_info.items()}}
+        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}
 
-        # ── Actual CDR gain per +1 unit (perturbation analysis) ──────────────
-        # For every resource, re-solve the LP with b_ub[i] += 1 (same constraint
-        # matrix, only the RHS changes) and measure the real gain. This correctly
-        # accounts for all simultaneously binding constraints.
+        # ── Perturbation analysis: marginal CO₂ gain per +1 unit of each resource
         resource_actual_gain = {}
         for i, (ctype, cid) in enumerate(constraint_labels):
             if ctype not in ("resource", "custom_batch"):

tabs/tab0_welcome.py

@@ -1,6 +1,5 @@
 import streamlit as st
 from config.config import CO2_UNIT
-from utils.ui_helpers import show_bar
 
 def render_tab():
     st.markdown(f"""
@@ -8,23 +7,23 @@ def render_tab():
 
     This tool helps you optimize your carbon direct removal portfolio by adjusting resource usage and constraints.
 
-    <b>Required:</b>
+    <h3 class="wt wt-1">Required:</h3>
     <ol>
         <li><b>Resource inputs</b>: provide the total available quantities of resources for 1 year.</li>
     </ol>
 
-    <b>Optional:</b>
+    <h3 class="wt wt-2">Optional:</h3>
     <ol start="2">
         <li><b>Method constraints</b>: select which carbon removal methods are active and set their <b>maximum deployment cap</b> (as % of total potential or absolute value in {CO2_UNIT}/yr).</li>
         <li><b>Resource efficiency coefficients</b>: adjust the resource usage for each method.</li>
     </ol>
 
-    <b>Outputs:</b>
+    <h3 class="wt wt-3">Outputs:</h3>
     <ol start="4">
         <li><b>Portfolio generation</b>: run the optimization to find the best portfolio: how much CO₂ is removed, what methods are used, and in what proportions.</li>
     </ol>
 
-    <b>Explore:</b>
+    <h3 class="wt wt-4">Explore:</h3>
     <ol start="5">
         <li><b>Sensitivity analysis</b>: analyze how changes in method caps or resource availability affect the portfolio.</li>
         <li><b>Scenario comparison</b>: compare different scenarios based on the optimization results.</li>

tabs/tab1_inputs.py

@@ -41,6 +41,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
     if edit_index is not None and not st.session_state.get(f"_dlg_initialized_{edit_index}"):
         for key in list(st.session_state.keys()):
             if key.startswith(("_dlg_existing_enable_",
+                            "_dlg_existing_min_", "_dlg_existing_med_", "_dlg_existing_max_",
                             "_dlg_new_chk_", "_dlg_new_min_", "_dlg_new_med_", "_dlg_new_max_")):
                 del st.session_state[key]
         st.session_state[f"_dlg_initialized_{edit_index}"] = True
@@ -94,7 +95,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
     group = resource_to_group.get(batch_group)
     unit = resource_unit_map.get(group, "?")
 
-    st.markdown(f'<p class="caption">Unit for this group: <strong>{unit}</strong> (per MtCO₂ for coefficients)</p>', unsafe_allow_html=True)
+    st.markdown(f'<p class="caption">Unit for this group: <strong>{unit}</strong></p>', unsafe_allow_html=True)
 
     st.markdown('<p class="dialog-title">2 — Available quantity</p>', unsafe_allow_html=True)
 
@@ -102,9 +103,10 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
         f"Available amount ({unit})",
         min_value=0.0,
         format="%.2f",
-        value=float(existing.get("amount", 0.0)),
+        value=float(existing["amount"]) if existing.get("amount") and existing.get("amount") != 0.0 else None,
         help=f"Total quantity available for 1 year, in {unit}.",
-        key="label-input-amount"
+        key="label-input-amount",
+        placeholder="0.0"
     )
 
     st.markdown('<p class="dialog-title">3 — Existing CDR methods for this resource</p>', unsafe_allow_html=True)
@@ -161,16 +163,39 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
                 if not enabled:
                     continue
 
-                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()
+                existing_coeff = existing.get("methods", {}).get(m, coeff)
+
+                st.info("Modifying these values only affects this resource batch: the base method coefficients are unchanged.")
+                col_min, col_med, col_max = st.columns(3)
+                with col_min:
+                    e_min = st.number_input(
+                        f"Min ({unit}/{CO2_UNIT})",
+                        min_value=0.0,
+                        format="%.10g",
+                        value=float(existing_coeff["min"]),
+                        key=f"_dlg_existing_min_{m}",
+                    )
+                with col_med:
+                    e_med = st.number_input(
+                        f"Median ({unit}/{CO2_UNIT})",
+                        min_value=0.0,
+                        format="%.10g",
+                        value=float(existing_coeff["median"]),
+                        key=f"_dlg_existing_med_{m}",
+                    )
+                with col_max:
+                    e_max = st.number_input(
+                        f"Max ({unit}/{CO2_UNIT})",
+                        min_value=0.0,
+                        format="%.10g",
+                        value=float(existing_coeff["max"]),
+                        key=f"_dlg_existing_max_{m}",
+                    )
+                method_configs[m] = {
+                    "min": e_min,
+                    "median": e_med,
+                    "max": e_max,
+                }
 
     if secondary_related:
         names = "\n".join(f"- **{m}**" for m in secondary_related)
@@ -206,24 +231,30 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
                     col_min, col_med, col_max = st.columns(3)
                     with col_min:
                         v_min = st.number_input(
-                            "Min",
+                            f"Min ({unit}/{CO2_UNIT})",
                             min_value=0.0,
-                            format="%.4f",
+                            value=None,
+                            format="%.10g",
                             key=f"_dlg_new_min_{m}",
+                            placeholder="0.0000",
                         )
                     with col_med:
                         v_med = st.number_input(
-                            "Median ★",
+                            f"Median ({unit}/{CO2_UNIT})",
                             min_value=0.0,
-                            format="%.4f",
+                            value=None,
+                            format="%.10g",
                             key=f"_dlg_new_med_{m}",
+                            placeholder="0.0000",
                         )
                     with col_max:
                         v_max = st.number_input(
-                            "Max",
+                            f"Ma ({unit}/{CO2_UNIT})",
                             min_value=0.0,
-                            format="%.4f",
+                            value=None,
+                            format="%.10g",
                             key=f"_dlg_new_max_{m}",
+                            placeholder="0.0000",
                         )
                     method_configs[m] = {
                         "min": v_min,
@@ -245,11 +276,14 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
             errors.append(f"**{batch_name}** matches a standard resource name. Choose a different name.")
         elif batch_name.strip() in existing_names:
             errors.append(f"**{batch_name}** already exists. Choose a different name.")
-        if batch_amount <= 0:
+        if not batch_amount or batch_amount <= 0:
             errors.append("Available amount must be greater than 0.")
         # if not method_configs:
         #     errors.append("Select at least one CDR method.")
         for m, c in method_configs.items():
+            if any(v is None for v in [c["min"], c["median"], c["max"]]):
+                errors.append(f"**{m}**: all coefficient fields (min, median, max) are required.")
+                continue
             if c["min"] > c["max"]:
                 errors.append(f"**{m}**: min ({c['min']}) cannot be greater than max ({c['max']}).")
             if not (c["min"] <= c["median"] <= c["max"]):
@@ -307,7 +341,7 @@ def to_excel_bytes(batches: list) -> bytes:
 
 def _parse_custom_excel(file) -> list:
     df = pd.read_excel(file, sheet_name=0)
-    required = {"name", "group", "amount", "method", "min", "median", "max"}
+    required = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
     if not required.issubset(df.columns):
         raise ValueError(f"Missing columns: {required - set(df.columns)}")
     batches = []
@@ -394,7 +428,7 @@ def _render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
     amount_val = float(batch["amount"])
     batch["unit"] = unit  # keep in sync for Excel export
 
-    st.markdown(f"🆕 **{batch['name']}** — CDR methods: **{n_methods}**")
+    # 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:
@@ -403,7 +437,7 @@ def _render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
         col_amount, _, _, _ = st.columns(4)
         with col_amount:
             new_amount = st.number_input(
-                f"Available amount ({unit})",
+                f"{batch['name']}",
                 min_value=0.0,
                 format="%.2f",
                 key=key_amount,
@@ -437,17 +471,16 @@ def _render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
             },
         )
 
-        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, 
-                         type="secondary", 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:"):
+        with st.container(key="container-btn-new"):
+            if st.button("Delete", key=f"del_batch_{global_idx}",
+                            type="primary", icon=":material/delete:"):
                 st.session_state.custom_resources.pop(global_idx)
                 st.session_state.pop("latest_result", None)
                 st.rerun()
+            if st.button("Edit", key=f"edit_batch_{global_idx}", 
+                            type="secondary", icon=":material/edit:"):
+                dialog_add_custom_resource(cost_sliders, edit_index=global_idx)
+
 
 
 def panel_custom_resources_controls(cost_sliders):
@@ -524,7 +557,6 @@ def render_tab(cost_sliders):
                 label="Download Excel Template",
                 data=f,
                 file_name="resource_template.xlsx",
-                # use_container_width=True,
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                 icon=":material/download:",
                 key="download_button_resource_template"

tabs/tab2_constraints.py

@@ -89,12 +89,14 @@ def render_method(m, cols, i):
                 f"Max cap ({CO2_UNIT}/yr)",
                 min_value=0.0,
                 format="%.2f",
+                value=None,
+                placeholder="0.00",
                 key=manual_key,
             )
 
-            st.session_state.constraints[m]["cap_value"] = float(value)
+            st.session_state.constraints[m]["cap_value"] = float(value) if value is not None else 0.0
 
-            if value == 0:
+            if not value:
                 st.warning(f"Cap is 0 {CO2_UNIT}/yr but method is active.", icon=":material/warning:")
 
 def reset_all_constraints():
@@ -148,7 +150,7 @@ def render_tab():
         unsafe_allow_html=True,
     )
 
-    with st.expander("Manage methods", expanded=False, icon=":material/settings:"):
+    with st.expander("Manage methods", expanded=True, icon=":material/settings:"):
         for group, method_list in method_groups.items():
             st.markdown(f"""
                 <p class="crra-group-name">{group}</p>""",

tabs/tab3_coefficients copy.py

@@ -1,164 +0,0 @@
-import pandas as pd
-import streamlit as st
-
-from config.config import (method_groups, method_order, resource_groups,
-                           resource_order, secondary_resources)
-from utils.ui_helpers import format_efficiency_summary
-
-
-def render_tab(cost_sliders):
-    # Initialize costs
-    if "costs" not in st.session_state:
-        st.session_state.costs = {}
-    for m in cost_sliders:
-        if m not in st.session_state.costs:
-            st.session_state.costs[m] = {}
-        for r in cost_sliders[m]:
-            if r not in st.session_state.costs[m]:
-                st.session_state.costs[m][r] = cost_sliders[m][r]["median"]
-
-    st.header("Resource efficiency coefficients")
-
-    st.info("""
-    **Objective:**
-
-    This section lets you adjust the resource usage coefficients for each CDR method to best fit your country conditions.
-
-    - Select a method using the dropdown
-    - Adjust the resource usage coefficients (e.g., land, energy) using sliders
-    - Optionally override the slider using a manual input (even outside bounds)
-    - Disable secondary resources (e.g., water, chemicals) if needed
-    - Reset a single method or all methods with the reset buttons
-    - View a summary table of coefficients used in the model
-    """)
-    st.info("""
-    **Information:**
-
-    Data used in this section is based on 
-    """)
-    st.warning("Blue cells in the table highlight coefficients modified from their **default median values**.")
-
-    # Combined dropdown for group + method
-    method_choices = []
-    method_lookup = {}
-    for group, methods in method_groups.items():
-        for method in methods:
-            label = f"{group} | {method}"
-            method_choices.append(label)
-            method_lookup[label] = method
-
-    selected_label = st.selectbox("Select a method:", method_choices)
-    method_selected = method_lookup[selected_label]
-
-    with st.expander(f"Manage resources for the {method_selected} method", expanded=True):
-        for group_name, rlist in resource_groups.items():
-            used = [r for r in rlist if r in cost_sliders[method_selected]]
-            if not used:
-                continue
-
-            st.markdown(f"### {group_name}")
-            for r in used:
-                conf = cost_sliders[method_selected][r]
-                default_val = conf["median"]
-                min_val = conf["min"]
-                max_val = conf["max"]
-                if min_val < 0.01:
-                    step = 0.0001
-                    fmt = "%.4f"
-                elif min_val < 1:
-                    step = 0.001
-                    fmt = "%.3f"
-                elif min_val < 100:
-                    step = 0.01
-                    fmt = "%.2f"
-                else:
-                    step = 1.0
-                    fmt = "%.0f"
-
-                slider_key = f"slider_{method_selected}_{r}".replace(" ", "_").lower()
-                manual_key = f"manual_{method_selected}_{r}".replace(" ", "_").lower()
-                toggle_key = f"toggle_{method_selected}_{r}".replace(" ", "_").lower()
-
-                is_secondary = (method_selected, r) in secondary_resources
-                if is_secondary and toggle_key not in st.session_state:
-                    st.session_state[toggle_key] = False
-
-                enabled = True
-                if is_secondary:
-                    enabled = st.checkbox(f"Use {r}", key=toggle_key)
-
-                if enabled:
-                    col1, col2 = st.columns([3, 1])
-                    with col1:
-                        slider_val = st.slider(
-                            label=r,
-                            min_value=min_val,
-                            max_value=max_val,
-                            value=st.session_state.costs[method_selected].get(r, default_val),
-                            step=step,
-                            format=fmt,
-                            key=slider_key
-                        )
-                    with col2:
-                        manual_val = st.number_input(
-                            label="",
-                            value=slider_val,
-                            key=manual_key,
-                            help="Manual override (optional, any value)"
-                        )
-
-                    # Manual overrides slider if changed
-                    final_val = manual_val if manual_val != slider_val else slider_val
-                    st.session_state.costs[method_selected][r] = final_val
-                else:
-                    st.session_state.costs[method_selected][r] = 0.0
-                    st.markdown("**DISABLED**")
-
-        # Reset buttons
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("🔄 Reset selected method"):
-                for r in cost_sliders[method_selected]:
-                    default_val = cost_sliders[method_selected][r]["median"]
-                    st.session_state.costs[method_selected][r] = default_val
-
-                    # Clear UI state
-                    for suffix in ["slider", "manual", "toggle"]:
-                        key = f"{suffix}_{method_selected}_{r}".replace(" ", "_").lower()
-                        if key in st.session_state:
-                            del st.session_state[key]
-
-                st.success(f"{method_selected} reset to default values.")
-                st.rerun()
-
-        with col2:
-            if st.button("🔄 Reset all methods"):
-                for m in method_order:
-                    for r in cost_sliders.get(m, {}):
-                        default_val = cost_sliders[m][r]["median"]
-                        st.session_state.costs[m][r] = default_val
-
-                        for suffix in ["slider", "manual", "toggle"]:
-                            key = f"{suffix}_{m}_{r}".replace(" ", "_").lower()
-                            if key in st.session_state:
-                                del st.session_state[key]
-
-                st.success("All methods reset to default values.")
-                st.rerun()
-
-    # Summary table
-    st.subheader("Summary table: resource usage coefficients in the model")
-
-    df_default = pd.DataFrame(index=method_order, columns=resource_order)
-    df_current = pd.DataFrame(index=method_order, columns=resource_order)
-
-    for m in method_order:
-        for r in resource_order:
-            df_default.at[m, r] = cost_sliders.get(m, {}).get(r, {}).get("median", 0.0)
-            df_current.at[m, r] = st.session_state.costs.get(m, {}).get(r, 0.0)
-
-    df_default = df_default.astype(float)
-    df_current = df_current.astype(float)
-
-    styled = format_efficiency_summary(df_current, df_default)
-    st.table(styled)

tabs/tab3_coefficients.py

@@ -34,7 +34,10 @@ def _make_sync_s_to_m(slider_key, manual_key):
 def _make_sync_m_to_s(slider_key, manual_key, min_val, max_val):
     """on_change for number_input: clamp to [min, max] and sync both widgets."""
     def _sync():
-        clamped = max(min_val, min(max_val, st.session_state[manual_key]))
+        val = st.session_state[manual_key]
+        if val is None:
+            return
+        clamped = max(min_val, min(max_val, val))
         st.session_state[manual_key] = clamped
         st.session_state[slider_key] = clamped
     return _sync
@@ -199,11 +202,13 @@ def render_tab(cost_sliders):
     # ── Resource sliders ─────────────────────────────────────────────────────
     with st.expander(f"Manage resources for **{method}**", expanded=True):
         method_sliders = cost_sliders_norm.get(method, {})
+        print(method_sliders)
         method_costs_norm = _normalize_costs(st.session_state.costs.get(method, {}))
         custom_for_method = custom_sliders_by_method.get(method, {})
 
         for group_name, rlist in resource_groups.items():
             used = [r for r in rlist if r in method_sliders]
+            print(used)
             custom_in_group = [
                 r for r in custom_for_method
                 if custom_resource_to_group.get(r) == group_name
@@ -243,11 +248,18 @@ def render_tab(cost_sliders):
                         st.session_state.costs[method][r] = conf["median"]
                         current_val = conf["median"]
 
+                if conf["min"] == conf["max"]:
+                    st.markdown(f"""<p class="crra-resource-name">{display_label} = <strong>{conf['median']}</strong> (fixed)</p>""", unsafe_allow_html=True)
+                    st.session_state.costs[method][r] = conf["median"]
+                    if st.session_state.get("resource_caps", {}).get(r, 0) <= 0:
+                        st.info(f"No available quantity set for **{r}** in Resource Inputs tab: **{method}** won't be used in the optimization.", icon=":material/info:")
+                    continue
+
                 if slider_key not in st.session_state:
                     st.session_state[slider_key] = current_val
                 if manual_key not in st.session_state:
                     st.session_state[manual_key] = st.session_state[slider_key]
-
+                print(r)
                 if st.session_state.get("resource_caps", {}).get(r, 0) <= 0:
                     st.info(f"No available quantity set for **{r}** in Resource Inputs tab: **{method}** won't be used in the optimization.", icon=":material/info:")
 
@@ -263,16 +275,19 @@ def render_tab(cost_sliders):
                         on_change=_make_sync_s_to_m(slider_key, manual_key),
                     )
                 with col2:
-                    manual_val = st.number_input(
+                    st.number_input(
                         label="label",
                         label_visibility="collapsed",
                         key=manual_key,
                         help="Manual override (optional, any value)",
                         format=fmt,
+                        value=None,
+                        placeholder=str(round(slider_val, 4)),
                         on_change=_make_sync_m_to_s(slider_key, manual_key, conf["min"], conf["max"]),
                     )
 
-                st.session_state.costs[method][r] = st.session_state.get(manual_key, slider_val)
+                _mv = st.session_state.get(manual_key)
+                st.session_state.costs[method][r] = slider_val if _mv is None else _mv
 
 
             # ── New (custom) resources linked to this method ────────────────
@@ -326,17 +341,20 @@ def render_tab(cost_sliders):
                         on_change=_make_sync_s_to_m(slider_key, manual_key),
                     )
                 with col2:
-                    manual_val = st.number_input(
+                    st.number_input(
                         label="label",
                         label_visibility="collapsed",
                         key=manual_key,
                         help="Manual override (optional, any value)",
                         format=fmt,
+                        value=None,
+                        placeholder=str(round(slider_val, 4)),
                         on_change=_make_sync_m_to_s(slider_key, manual_key, conf["min"], conf["max"]),
                     )
 
                 st.session_state.costs.setdefault(method, {})
-                st.session_state.costs[method][r] = st.session_state.get(manual_key, slider_val)
+                _mv = st.session_state.get(manual_key)
+                st.session_state.costs[method][r] = slider_val if _mv is None else _mv
 
 
         # ── Reset buttons ───────────────────────────────────────────────��────

tabs/tab4_optimization copy.py

@@ -1,199 +0,0 @@
-import io
-import json
-import zipfile
-
-import matplotlib.pyplot as plt
-import pandas as pd
-import plotly.graph_objects as go
-import seaborn as sns
-import streamlit as st
-
-from config.config import method_order, resource_order, resource_units
-from optimization.optimization import run_optimization
-from utils.ui_helpers import format_results_summary
-
-
-def render_tab():
-    st.header("Portfolio generation")
-    st.caption("Tab 4 - Seaborn fallback for vertical histograms")
-
-    st.info("""
-    **Objective:**
-    Run the optimization tool, explore results, and save scenarios for comparison or export.
-    """)
-
-    if "constraints" not in st.session_state or "costs" not in st.session_state or "resource_caps" not in st.session_state:
-        st.error("Missing inputs. Please complete previous steps.")
-        return
-
-    if "scenarios" not in st.session_state:
-        st.session_state.scenarios = {}
-
-    if sum(st.session_state.resource_caps.values()) <= 0:
-        st.warning("\u26a0\ufe0f All resources are currently set to 0. Please increase availability.")
-        return
-
-    if st.button("Run Optimization"):
-        success, result = run_optimization(
-            resource_caps=st.session_state.resource_caps,
-            method_constraints=st.session_state.constraints,
-            method_costs=st.session_state.costs,
-        )
-
-        if success:
-            allocations = result["method_usage"]
-            total_removed = result["total_removed"]
-
-            if total_removed <= 0:
-                st.warning("\u274c Optimization removed 0 tCO₂. Relax constraints or increase resources.")
-                return
-
-            total_cost = sum(
-                allocations[m] * sum(st.session_state.costs[m].values())
-                for m in allocations
-            )
-
-            st.session_state.latest_result = {
-                "summary": {
-                    "total_co2_removed": total_removed,
-                    "total_cost": total_cost
-                },
-                "allocations": allocations,
-                "resource_caps": st.session_state.resource_caps.copy(),
-                "method_constraints": st.session_state.constraints,
-                "method_costs": st.session_state.costs,
-            }
-
-            st.success(f"\u2705 Optimization successful: {total_removed:,.0f} tCO₂ removed")
-        else:
-            st.error("\u274c Optimization failed")
-            if "message" in result:
-                st.error(result["message"])
-
-    if "latest_result" not in st.session_state:
-        return
-
-    latest = st.session_state.latest_result
-    allocations = latest["allocations"]
-    resource_caps = latest["resource_caps"]
-    method_costs = latest["method_costs"]
-
-    if not allocations or sum(allocations.values()) == 0:
-        return
-
-    col1, col2 = st.columns(2)
-    col1.metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.0f} t")
-    col2.metric("Methods Used", len(allocations))
-
-    st.subheader("Optimization Summary")
-    df_result = pd.DataFrame.from_dict(allocations, orient="index", columns=["tCO₂ removed"])
-    df_result["tCO₂ removed"] = pd.to_numeric(df_result["tCO₂ removed"], errors="coerce")
-    total = df_result["tCO₂ removed"].sum()
-    if total > 0:
-        df_result["Share (%)"] = (df_result["tCO₂ removed"] / total * 100).round(2)
-    df_result = df_result.sort_values(by="tCO₂ removed", ascending=False)
-    st.table(format_results_summary(df_result))
-
-    st.markdown("### Method allocation breakdown")
-    fig_donut = go.Figure(data=[go.Pie(
-        labels=df_result.index.tolist(),
-        values=df_result["tCO₂ removed"].tolist(),
-        hole=0.4,
-        textinfo="label+percent",
-        textposition="outside",
-        marker=dict(line=dict(color="#000000", width=1)),
-        showlegend=False
-    )])
-    fig_donut.update_layout(margin=dict(t=10, b=10))
-    st.plotly_chart(fig_donut, use_container_width=True)
-
-    st.markdown("### Resource usage heatmap (% of cap)")
-    heatmap_matrix, heatmap_y = [], []
-    available_resources = [r for r in resource_order if resource_caps.get(r, 0) > 0]
-    for method in df_result.index:
-        row = [((method_costs.get(method, {}).get(r, 0.0) * allocations.get(method, 0.0)) / resource_caps[r]) * 100 if resource_caps[r] > 0 else 0 for r in available_resources]
-        heatmap_matrix.append(row)
-        heatmap_y.append(method)
-    fig_heatmap = go.Figure(data=go.Heatmap(
-        z=heatmap_matrix,
-        x=available_resources,
-        y=heatmap_y,
-        colorscale="Blues",
-        hovertemplate="Method: %{y}<br>Resource: %{x}<br>% Used: %{z:.2f}%<extra></extra>",
-    ))
-    fig_heatmap.update_layout(title="Resource Usage vs. Cap", xaxis_title="Resource", yaxis_title="Method", height=400)
-    st.plotly_chart(fig_heatmap, use_container_width=True)
-
-    st.markdown("### Absolute resource usage by unit (Seaborn)")
-    df_abs = []
-    for m, co2_removed in allocations.items():
-        for unit, resources in resource_units.items():
-            for r in resources:
-                if r in method_costs.get(m, {}):
-                    used = method_costs[m][r] * co2_removed
-                    if used > 0:
-                        df_abs.append({"Method": m, "Resource": r, "Used": used, "Unit": unit})
-
-    if df_abs:
-        df_abs = pd.DataFrame(df_abs)
-        for unit in df_abs["Unit"].unique():
-            st.markdown(f"#### Resources in {unit}")
-            df_unit = df_abs[df_abs["Unit"] == unit]
-            fig, ax = plt.subplots(figsize=(8, 4 + 0.3 * df_unit["Resource"].nunique()))
-            sns.barplot(data=df_unit, x="Resource", y="Used", hue="Method", ax=ax)
-            ax.set_ylabel(f"Used ({unit})")
-            ax.set_xlabel("Resource")
-            ax.tick_params(axis='x', rotation=45)
-            ax.legend(title="Method", bbox_to_anchor=(1.05, 1), loc='upper left')
-            st.pyplot(fig)
-
-    st.markdown("### Save scenario")
-    st.text_input("Scenario name", key="scenario_name")
-
-    if st.button("Save Scenario"):
-        name = st.session_state.get("scenario_name", "").strip()
-        if not name:
-            st.warning("Please enter a name before saving.")
-        elif name in st.session_state.scenarios:
-            st.warning("Scenario name already exists.")
-        else:
-            st.session_state.scenarios[name] = latest
-            st.success(f"Scenario '{name}' saved.")
-
-    current_name = st.session_state.get("scenario_name", "").strip()
-    if current_name and current_name in st.session_state.scenarios:
-        scenario = st.session_state.scenarios[current_name]
-        st.markdown(f"#### Scenario: {current_name}")
-        df_saved = pd.DataFrame.from_dict(scenario["allocations"], orient="index", columns=["tCO₂ removed"])
-        df_saved["tCO₂ removed"] = pd.to_numeric(df_saved["tCO₂ removed"], errors="coerce")
-        total = df_saved["tCO₂ removed"].sum()
-        if total > 0:
-            df_saved["Share (%)"] = (df_saved["tCO₂ removed"] / total * 100).round(2)
-        df_saved = df_saved.sort_values(by="tCO₂ removed", ascending=False)
-        st.table(format_results_summary(df_saved))
-
-        # Export as JSON
-        json_data = json.dumps({current_name: scenario}, indent=2)
-        st.download_button("Download Scenario as JSON", data=json_data, file_name=f"{current_name}_scenario.json", mime="application/json")
-
-        # Export as CSV zip
-        df_alloc = pd.DataFrame.from_dict(scenario["allocations"], orient="index", columns=["tCO₂ removed"])
-        df_alloc.index.name = "Method"
-        df_alloc.reset_index(inplace=True)
-        df_caps = pd.DataFrame(list(scenario["resource_caps"].items()), columns=["Resource", "Cap"])
-        constraints_list = []
-        for method, values in scenario["method_constraints"].items():
-            entry = {"Method": method, "min_share": values.get("min_share", ""), "max_share": values.get("max_share", ""), "resources": values.get("resources", {})}
-            constraints_list.append(entry)
-        df_constraints = pd.json_normalize(constraints_list, sep=".").fillna("")
-        zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED) as zf:
-            zf.writestr("allocations.csv", df_alloc.to_csv(index=False))
-            zf.writestr("resource_caps.csv", df_caps.to_csv(index=False))
-            zf.writestr("method_constraints.csv", df_constraints.to_csv(index=False))
-        st.download_button(
-            label="\ud83d\udcc5 Download Scenario as CSV (ZIP)",
-            data=zip_buffer.getvalue(),
-            file_name=f"{current_name}_scenario.zip",
-            mime="application/zip"
-        )

tabs/tab4_optimization.py

@@ -69,6 +69,8 @@ def panel_load_from_excel():
 
     if "excel_loaded_file" in st.session_state:
         st.success(f"Loaded: **{st.session_state['excel_loaded_file']}** - All tabs updated.", icon="✅")
+    for w in st.session_state.pop("import_warnings", []):
+        st.warning(w, icon=":material/search:")
 
     uploaded = st.file_uploader("Upload inputs (.xlsx)", type=["xlsx"], key=f"inputs_loader_{st.session_state.excel_uploader_key}")
 
@@ -80,7 +82,7 @@ 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, enabled_methods = load_inputs_from_excel(uploaded)
+            resource_caps, constraints, costs, custom_resources, enabled_methods, import_warnings = load_inputs_from_excel(uploaded)
             st.session_state.resource_caps = resource_caps
             st.session_state.constraints = constraints
             st.session_state.costs = costs
@@ -94,6 +96,7 @@ def panel_load_from_excel():
             st.session_state["excel_loaded_file"] = uploaded.name
             st.session_state["input_file_name"] = default_name
             st.session_state["scenario_uploader_key"] += 1 # force reload in scenario uploader
+            st.session_state["import_warnings"] = import_warnings
             st.rerun()
         except Exception as e:
             st.error(f"Error loading file: {e}")
@@ -520,40 +523,60 @@ def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None,
         st.info("No resources with non-zero availability to display.")
         return
 
-    matrix, y_labels = [], []
+    matrix_pct, matrix_exact, y_labels = [], [], []
     for method in df_result.index:
-        row = []
+        row_pct, row_exact = [], []
         for r in available:
             cap = full_caps.get(r, 0)
             if cap <= 0:
-                row.append(0)
+                row_pct.append(0)
+                row_exact.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)
+            row_pct.append(used / cap * 100)
+            row_exact.append(used)
+        matrix_pct.append(row_pct)
+        matrix_exact.append(row_exact)
         y_labels.append(method)
 
-    df_heat = pd.DataFrame(matrix, index=y_labels, columns=available)
+    df_heat = pd.DataFrame(matrix_pct, index=y_labels, columns=available)
+    df_exact = pd.DataFrame(matrix_exact, index=y_labels, columns=available)
 
     fig = px.imshow(
         df_heat, color_continuous_scale=PLOTLY_HEATMAP_SCALE, text_auto=".1f",
         labels=dict(x="Resource", y="Method", color="% Used"),
     )
+    matrix_exact_fmt = [[f"{v:.4f}" for v in row] for row in matrix_exact]
+    fig.update_traces(
+        customdata=matrix_exact_fmt,
+        hovertemplate="<b>%{y}</b><br>%{x}<br>% of cap: %{z:.1f}%<br>Exact: %{customdata}<extra></extra>",
+    )
     apply_chart_style(fig, height=max(400, 60 + 30 * len(df_heat.index)))
     st.plotly_chart(fig, use_container_width=True)
 
-    df_export = df_heat.reset_index().rename(columns={"index": "Method"})
-    
+    resource_to_group = {r: g for g, rlist in resource_groups.items() for r in rlist}
+    unit_map = {r: resource_unit_map.get(resource_to_group.get(r), "?") for r in available}
+    for batch in (custom_resources or []):
+        unit_map[batch["name"]] = resource_unit_map.get(
+            resource_to_group.get(batch["group"]), batch.get("unit", "?")
+        )
+    col_rename = {r: f"{r} ({unit_map.get(r, '?')})" for r in available}
+
+    df_export_pct = df_heat.reset_index().rename(columns={"index": "Method"})
+    df_export_exact = (
+        df_exact.reset_index()
+        .rename(columns={"index": "Method"})
+        .rename(columns=col_rename)
+    )
+
     with st.expander("📊 View / download chart data"):
-        st.dataframe(df_export, use_container_width=True, hide_index=True)
+        st.dataframe(df_export_exact, use_container_width=True, hide_index=True)
 
-    register_chart_data("Resource usage heatmap (% of cap)", df_export)
+    register_chart_data("Resource usage heatmap (% of cap)", df_export_pct)
+    register_chart_data("Resource usage exact values", df_export_exact)
 
 def show_absolute_usage(allocations, method_costs, custom_resources=None, resource_usage=None):
     # Normalize method_costs keys: strip legacy unit suffixes
@@ -615,7 +638,7 @@ def show_absolute_usage(allocations, method_costs, custom_resources=None, resour
     register_chart_data("Absolute resource usage by method", df)
 
 def show_resource_balance(latest):
-    st.markdown("### Resource balance: used vs available")
+    st.markdown('<p class="crra-sub-heading">Resource balance: used vs available</p>', unsafe_allow_html=True)
     resource_caps = latest["resource_caps"]
     used_total = latest["resource_used_total"]
     remaining = latest["resource_remaining"]
@@ -667,7 +690,7 @@ def show_resource_balance(latest):
     register_chart_data("Resource balance (used vs remaining)", df)
 
 def show_bottleneck_analysis(latest):
-    st.markdown("### Resource sensitivity")
+    st.markdown('<p class="crra-sub-heading">Resource sensitivity</p>', unsafe_allow_html=True)
     st.markdown(
         '<p class="caption">'
         'For every resource: actual CDR gain if you add exactly +1 unit, recomputed with all other constraints in place.'
@@ -703,7 +726,7 @@ def show_bottleneck_analysis(latest):
 # ─── Save / export / reset ───────────────────────────────────────────────────────────
 
 def save_scenario(latest):
-    st.markdown("### Save scenario")
+    st.markdown('<p class="crra-sub-heading">Save scenario</p>', unsafe_allow_html=True)
     st.markdown('<p class="caption">Save the current scenario with inputs and outputs for comparison and/or export.</p>', unsafe_allow_html=True)
 
     suggested = st.session_state.get("scenario_loaded_file", "").rsplit(".", 1)[0]
@@ -890,7 +913,7 @@ def export_inputs_only():
         for group, resources in resource_groups.items()
         for r in resources
     }
-    st.markdown("### Export inputs")
+    st.markdown('<p class="crra-sub-heading">Export inputs</p>', unsafe_allow_html=True)
     st.markdown('<p class="caption">Export only the resource capabilities, method constraints and coefficients — without results.</p>', unsafe_allow_html=True)
 
     suggested = st.session_state.get("excel_loaded_file", "").rsplit(".", 1)[0]
@@ -987,7 +1010,7 @@ def export_inputs_only():
         )
 
 def export_all_charts():
-    st.markdown("### Export all chart data")
+    st.markdown('<p class="crra-sub-heading">Export all chart data</p>', unsafe_allow_html=True)
     st.markdown(
         '<p class="caption">Download a single file containing the underlying data '
         'of every chart shown in this session.</p>',
@@ -1047,9 +1070,10 @@ def export_all_charts():
         )
 
 def clear_all_data():
-    for key in ["resource_caps", "constraints", "costs", "scenarios", 
-                "latest_result", "scenario_loaded_file", "scenario_name", 
-                "excel_loaded_file", "input_file_name", "resource_last_loaded_file", "resource_uploader_key"]:
+    for key in ["resource_caps", "constraints", "costs", "scenarios",
+                "latest_result", "scenario_loaded_file", "scenario_name",
+                "excel_loaded_file", "input_file_name", "resource_last_loaded_file",
+                "resource_uploader_key", "custom_resources"]:
         st.session_state.pop(key, None)
 
     for uploader_key in ["resource_uploader_key", "excel_uploader_key", "scenario_uploader_key"]:
@@ -1073,7 +1097,7 @@ def confirm_clear_all():
 
 def reset_scenario():
     st.divider()
-    st.markdown("### Reset")
+    st.markdown('<p class="crra-sub-heading">Reset</p>', unsafe_allow_html=True)
     st.markdown('<p class="caption">Clear all current inputs, results and saved scenarios from the session.</p>', unsafe_allow_html=True)
 
     if st.button("Clear all data", key="reset_scenario", use_container_width=False, type="primary", icon=":material/delete:"):
@@ -1152,47 +1176,46 @@ def render_tab():
 
     # ── Results ────────────────────────────────────────────────────────────
     show_metrics(latest)
+
     df_result = build_results_df(
         allocations,
         method_constraints=latest.get("method_constraints")
     )
-
     df_display = df_result.copy()
-
     df_display[f"{CO2_UNIT} removed"] = df_display[f"{CO2_UNIT} removed"].map(
-        lambda x: f"{x:,.2f}" if pd.notna(x) else x
+        lambda x: f"{x:,.4f}" if pd.notna(x) else x
     )
 
-    st.subheader("Optimization Summary")
-
-    st.dataframe(
-        df_display,
-        use_container_width=True,
-    )
-
-    st.markdown("### Method allocation breakdown")
-    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", []),
-                 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", []),
-                        resource_usage=latest.get("resource_usage"))
-
-    show_resource_balance(latest)
-    show_bottleneck_analysis(latest)
-    df_usage = build_resource_usage_df(latest["resource_usage"])
-
-    st.markdown("### Detailed resource usage by method")
-    st.dataframe(df_usage.pivot(index="Resource", columns="Method", values="Used").fillna(0), use_container_width=True)
-
-    # ── Save & export & reset ───────────────────────────────────────────────────────
-    save_scenario(latest)
-    export_scenario()
-    export_inputs_only()
-    export_all_charts()
-    reset_scenario()
+    tab_results, tab_resources, tab_bottleneck, tab_export = st.tabs([
+        "📊 Method allocation",
+        "🌿 Resource usage",
+        "🔍 Bottleneck analysis",
+        "💾 Export & Save",
+    ])
+
+    with tab_results:
+        st.markdown('<p class="crra-sub-heading">Optimization Summary</p>', unsafe_allow_html=True)
+        st.dataframe(df_display, use_container_width=True)
+        st.markdown('<p class="crra-sub-heading">Method allocation breakdown</p>', unsafe_allow_html=True)
+        show_donut(df_result)
+
+    with tab_resources:
+        st.markdown('<p class="crra-sub-heading">Resource usage heatmap (% of cap)</p>', unsafe_allow_html=True)
+        show_heatmap(df_result, resource_caps, method_costs,
+                     custom_resources=latest.get("custom_resources", []),
+                     resource_usage=latest.get("resource_usage"))
+        st.markdown('<p class="crra-sub-heading">Absolute resource usage by unit</p>', unsafe_allow_html=True)
+        show_absolute_usage(allocations, method_costs,
+                            custom_resources=latest.get("custom_resources", []),
+                            resource_usage=latest.get("resource_usage"))
+        show_resource_balance(latest)
+
+    with tab_bottleneck:
+        show_bottleneck_analysis(latest)
+
+    with tab_export:
+        save_scenario(latest)
+        export_scenario()
+        export_inputs_only()
+        export_all_charts()
+        reset_scenario()

tabs/tab5_sensitivity.py

@@ -1,10 +1,9 @@
-import matplotlib.pyplot as plt
+import copy
 import pandas as pd
-import seaborn as sns
 import streamlit as st
 import plotly.express as px
 
-from config.config import CO2_UNIT, method_order, resource_order
+from config.config import CO2_UNIT, method_order, resource_groups, resource_order, resource_unit_map
 from optimization.optimization import run_optimization
 from utils.ui_helpers import register_chart_data, show_bar
 
@@ -42,10 +41,17 @@ def render_tab():
     )
     baseline_removed = baseline_result["total_removed"] if baseline_success else 0
 
-    all_resources = resource_order
+    custom_resource_names = [b["name"] for b in st.session_state.get("custom_resources", [])]
+    all_resources = resource_order + custom_resource_names
+
+    resource_to_unit = {
+        r: resource_unit_map[group]
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
+    for b in st.session_state.get("custom_resources", []):
+        resource_to_unit[b["name"]] = b.get("unit", "")
 
-    print(resource_order)
-    print(st.session_state.get("custom_resources", []))
     tab1, tab2 = st.tabs(["🔁 Resource sensitivity", "🔁 Method sensitivity"])
 
     with tab1:
@@ -53,7 +59,7 @@ def render_tab():
             <p class="crra-sub-heading">Impact of resource availability</p>""",
             unsafe_allow_html=True,
         )
-        selected_resources = st.multiselect("Select one or more resources:", resource_order,key="crra-select-resource")
+        selected_resources = st.multiselect("Select one or more resources:", all_resources, key="crra-select-resource")
 
         if not selected_resources:
             st.warning("Please select at least one resource to run the sensitivity analysis.")
@@ -61,11 +67,18 @@ def render_tab():
             percentages = list(range(0, 210, 10))
             all_data = []
 
+            custom_amount_by_name = {
+                b["name"]: float(b.get("amount", 0))
+                for b in st.session_state.get("custom_resources", [])
+            }
+
             for resource in selected_resources:
+                unit = resource_to_unit.get(resource, "")
+                base_cap = st.session_state.resource_caps.get(resource) or custom_amount_by_name.get(resource, 0)
                 for pct in percentages:
                     temp_caps = st.session_state.resource_caps.copy()
-                    base_cap = st.session_state.resource_caps.get(resource, 1)
-                    temp_caps[resource] = base_cap * pct / 100
+                    actual_amount = base_cap * pct / 100
+                    temp_caps[resource] = actual_amount
 
                     success, result = run_optimization(
                         resource_caps=temp_caps,
@@ -78,105 +91,95 @@ def render_tab():
                     all_data.append({
                         "Input": resource,
                         "% of cap": pct,
+                        "Actual amount": round(actual_amount, 4),
+                        "Unit": unit,
                         f"CO₂ removed ({CO2_UNIT})": co2_removed
                     })
 
             df = pd.DataFrame(all_data)
             st.markdown("#### Sensitivity to resource availability")
-            fig = px.line(df, x="% of cap", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True)
+            fig = px.line(
+                df, x="% of cap", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True,
+                hover_data={"Actual amount": ":.4f", "Unit": True},
+            )
+            fig.update_layout(
+                xaxis_title="Resource availability (% of current cap)",
+                yaxis_title=f"Total portfolio CO₂ removal ({CO2_UNIT})",
+            )
             fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
                         annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
             st.plotly_chart(fig, use_container_width=True)
             with st.expander("📊 View / download chart data"):
                 st.dataframe(df, use_container_width=True, hide_index=True)
-            register_chart_data("Sensitivity to resource availability)", df)
+            register_chart_data("Sensitivity to resource availability", df)
 
     with tab2:
-        st.subheader("Impact of max allocation per method")
+        st.markdown("""
+            <p class="crra-sub-heading">Impact of max allocation per method</p>""",
+            unsafe_allow_html=True,
+        )
         selected_methods = st.multiselect("Select one or more methods:", method_order, key="crra-select-method")
 
         if not selected_methods:
             st.warning("Please select at least one method to run the sensitivity analysis.")
         else:
-            percent_methods = [m for m in selected_methods if st.session_state.constraints[m].get("cap_type", "percent") == "percent"]
-            absolute_methods = [m for m in selected_methods if st.session_state.constraints[m].get("cap_type") == "absolute"]
-
-            if percent_methods:
-                st.markdown("#### Sensitivity to % cap")
-                percentages = list(range(0, 110, 10))
-                all_data = []
-
-                for method in percent_methods:
-                    for pct in percentages:
-                        temp_constraints = st.session_state.constraints.copy()
-                        temp_constraints[method]["cap_type"] = "percent"
-                        temp_constraints[method]["cap_value"] = pct
-
-                        success, result = run_optimization(
-                            resource_caps=st.session_state.resource_caps,
-                            method_constraints=temp_constraints,
-                            method_costs=st.session_state.costs,
-                            custom_resources=st.session_state.get("custom_resources", []),
-                        )
-                        co2_removed = result["total_removed"] if success else 0
-                        all_data.append({
-                            "Input": method,
-                            "% max allocation": pct,
-                            f"CO₂ removed ({CO2_UNIT})": co2_removed
-                        })
+            percentages = list(range(0, 110, 10))
+            all_data = []
+            skipped = []
 
+            for method in selected_methods:
+                cap_type = st.session_state.constraints[method].get("cap_type", "percent")
+                current_cap = st.session_state.constraints[method].get("cap_value", 100 if cap_type == "percent" else 0.0)
+
+                if current_cap <= 0:
+                    skipped.append(method)
+                    continue
+
+                for pct in percentages:
+                    temp_constraints = copy.deepcopy(st.session_state.constraints)
+                    if cap_type == "percent":
+                        actual_cap = min(100, current_cap * pct / 100)
+                        temp_constraints[method]["cap_value"] = actual_cap
+                        cap_label = f"{actual_cap:.0f}% of potential"
+                    else:
+                        actual_cap = current_cap * pct / 100
+                        temp_constraints[method]["cap_value"] = actual_cap
+                        cap_label = f"{actual_cap:.2f} {CO2_UNIT}/yr"
+
+                    success, result = run_optimization(
+                        resource_caps=st.session_state.resource_caps,
+                        method_constraints=temp_constraints,
+                        method_costs=st.session_state.costs,
+                        custom_resources=st.session_state.get("custom_resources", []),
+                    )
+                    co2_removed = result["total_removed"] if success else 0
+                    all_data.append({
+                        "Method": method,
+                        "Cap type": cap_type,
+                        "% of current cap": pct,
+                        "Actual cap": cap_label,
+                        f"CO₂ removed ({CO2_UNIT})": co2_removed,
+                    })
+
+            for m in skipped:
+                st.warning(f"Method **{m}** has a cap of 0 — set a value first to include it.", icon="⚠️")
+
+            if all_data:
                 df = pd.DataFrame(all_data)
-                # fig, ax = plt.subplots(figsize=(8, 5))
-                # sns.lineplot(data=df, x="% max allocation", y=f"CO₂ removed ({CO2_UNIT})", hue="Input", ax=ax)
-                # ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
-                # ax.legend()
-                # st.pyplot(fig)
-
-                fig = px.line(df, x="% max allocation", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True)
-                fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
-                            annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
+                fig = px.line(
+                    df, x="% of current cap", y=f"CO₂ removed ({CO2_UNIT})",
+                    color="Method", markers=True,
+                    hover_data={"Actual cap": True, "Cap type": True},
+                )
+                fig.add_hline(
+                    y=baseline_removed, line_dash="dash", line_color="lightgray",
+                    annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}",
+                )
+                fig.update_layout(
+                    xaxis_title="% of current cap setting",
+                    yaxis_title=f"Total portfolio CO₂ removal ({CO2_UNIT})",
+                )
                 st.plotly_chart(fig, use_container_width=True)
                 with st.expander("📊 View / download chart data"):
                     st.dataframe(df, use_container_width=True, hide_index=True)
-                register_chart_data("Sensitivity to % cap", df)
-
-            if absolute_methods:
-                st.markdown(f"#### Sensitivity to absolute cap ({CO2_UNIT}/yr)")
-                all_data = []
-
-                for method in absolute_methods:
-                    current_cap = st.session_state.constraints[method].get("cap_value", 0.0)
-                    # Varier de 0 à 200% de la valeur actuelle en 11 points
-                    if current_cap > 0:
-                        values = [current_cap * pct / 100 for pct in range(0, 210, 20)]
-                    else:
-                        st.warning(f"Method **{method}** has an absolute cap of 0 — set a value first.", icon="⚠️")
-                        continue
-
-                    for val in values:
-                        temp_constraints = st.session_state.constraints.copy()
-                        temp_constraints[method]["cap_type"] = "absolute"
-                        temp_constraints[method]["cap_value"] = val
-
-                        success, result = run_optimization(
-                            resource_caps=st.session_state.resource_caps,
-                            method_constraints=temp_constraints,
-                            method_costs=st.session_state.costs,
-                            custom_resources=st.session_state.get("custom_resources", []),
-                        )
-                        co2_removed = result["total_removed"] if success else 0
-                        all_data.append({
-                            "Input": method,
-                            f"Cap ({CO2_UNIT}/yr)": val,
-                            f"CO₂ removed ({CO2_UNIT})": co2_removed
-                        })
-
-                if all_data:
-                    df = pd.DataFrame(all_data)
-                    fig = px.line(df, x="Cap ({CO2_UNIT}/yr)", y=f"CO₂ removed ({CO2_UNIT})", color="Input", markers=True)
-                    fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
-                                annotation_text=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
-                    st.plotly_chart(fig, use_container_width=True)
-                    with st.expander("📊 View / download chart data"):
-                        st.dataframe(df, use_container_width=True, hide_index=True)
-                    register_chart_data("Sensitivity to absolute cap", df)
+                register_chart_data("Sensitivity to method cap", df)

tabs/tab6_scenarios.py

@@ -1,8 +1,7 @@
 import json
 
-import matplotlib.pyplot as plt
 import pandas as pd
-import seaborn as sns
+import plotly.express as px
 import streamlit as st
 from config.config import CO2_UNIT
 from utils.data_utils import is_valid_scenario
@@ -94,13 +93,10 @@ def _prepare_comparison_data(selected):
 def _show_method_allocations(df):
     if df.empty:
         return
-    st.subheader("Method Allocations")
-    fig, ax = plt.subplots(figsize=(10, 4))
-    sns.barplot(data=df, x="Method", y=f"{CO2_UNIT}", hue="Scenario", ax=ax)
-    ax.set_xlabel("Method")
-    ax.set_ylabel(f"{CO2_UNIT}")
-    plt.xticks(rotation=45, ha="right")
-    st.pyplot(fig)
+    st.markdown("""<p class="crra-sub-heading">Method Allocations</p>""", unsafe_allow_html=True)
+    fig = px.bar(df, x="Method", y=f"{CO2_UNIT}", color="Scenario", barmode="group")
+    fig.update_layout(xaxis_tickangle=-45)
+    st.plotly_chart(fig, use_container_width=True)
 
     
 
@@ -110,25 +106,18 @@ def _show_resource_usage(df):
         st.info("No resource usage data available (method_costs missing from scenarios?).")
         return
 
-    st.subheader("Resource Use per Method")
+    st.markdown("""<p class="crra-sub-heading">Resource Use per Method</p>""", unsafe_allow_html=True)
     for method in df["Method"].unique():
         df_m = df[df["Method"] == method]
-        fig, ax = plt.subplots(figsize=(8, 3))
-        sns.barplot(data=df_m, x="Resource", y="Used", hue="Scenario", ax=ax)
-        ax.set_title(method)
-        ax.set_xlabel("Resource")
-        ax.set_ylabel("Used")
-        plt.xticks(rotation=45, ha="right")
-        st.pyplot(fig)
-
-    st.subheader("Total Resource Use per Scenario")
+        fig = px.bar(df_m, x="Resource", y="Used", color="Scenario", barmode="group", title=method)
+        fig.update_layout(xaxis_tickangle=-45)
+        st.plotly_chart(fig, use_container_width=True)
+
+    st.markdown("""<p class="crra-sub-heading">Total Resource Use per Scenario</p>""", unsafe_allow_html=True)
     df_total = df.groupby(["Scenario", "Resource"]).sum(numeric_only=True).reset_index()
-    fig, ax = plt.subplots(figsize=(10, 4))
-    sns.barplot(data=df_total, x="Scenario", y="Used", hue="Resource", ax=ax)
-    ax.set_xlabel("Scenario")
-    ax.set_ylabel("Total Used")
-    plt.xticks(rotation=45, ha="right")
-    st.pyplot(fig)
+    fig = px.bar(df_total, x="Scenario", y="Used", color="Resource", barmode="group")
+    fig.update_layout(xaxis_tickangle=-45)
+    st.plotly_chart(fig, use_container_width=True)
 
 
 # ─── Main tab entry point ─────────────────────────────────────────────────────
@@ -146,7 +135,7 @@ def render_tab():
         return
 
     # Select & manage scenarios
-    st.markdown("### Select Scenarios to Compare")
+    st.markdown("""<p class="crra-sub-heading">Select Scenarios to Compare</p>""", unsafe_allow_html=True)
     scenario_names = list(st.session_state.scenarios.keys())
     selected = st.multiselect("Select scenarios", scenario_names, default=scenario_names)
 
@@ -166,7 +155,7 @@ def render_tab():
     # Comparison
     df_summary, df_methods, df_resources = _prepare_comparison_data(selected)
 
-    st.subheader("Summary Table")
+    st.markdown("""<p class="crra-sub-heading">Summary Table</p>""", unsafe_allow_html=True)
     st.dataframe(df_summary.style.format(na_rep="-", thousands=","), use_container_width=True)
     st.download_button(
         "Export Comparison CSV",

utils/data_utils.py

@@ -5,7 +5,7 @@ import pandas as pd
 import streamlit as st
 import openpyxl
 from openpyxl.styles import PatternFill, Font
-from config.config import resource_unit_map
+from config.config import resource_unit_map, resource_order, method_order
 
 @st.cache_data
 def load_slider_data():
@@ -19,17 +19,20 @@ def render_resource_input(name_clean, r, tooltip=None):
     widget_key = f"cap_{r}"
 
     if widget_key not in st.session_state:
-        st.session_state[widget_key] = st.session_state.resource_caps.get(r, 0.0)
+        existing = st.session_state.resource_caps.get(r, 0.0)
+        st.session_state[widget_key] = existing if existing else None
 
     cap = st.number_input(
         label=name_clean,
         min_value=0.0,
         format="%.2f",
+        value=None,
+        placeholder="0.00",
         key=widget_key,
         help=tooltip
     )
 
-    st.session_state.resource_caps[r] = cap
+    st.session_state.resource_caps[r] = cap if cap is not None else 0.0
 
 def is_valid_scenario(scenario):
     base_ok = (
@@ -76,23 +79,33 @@ def load_inputs_from_excel(file):
             costs.setdefault(m, {})[r] = v
 
     custom_resources = []
+    warnings = []
+    valid_resources = set(resource_order)
+    valid_methods = set(method_order)
     if "custom_resources" in xl:
         df_custom = xl["custom_resources"]
         required_custom = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
         if required_custom.issubset(df_custom.columns):
             for bname in df_custom["name"].dropna().unique():
                 df_b = df_custom[df_custom["name"] == bname]
-                methods = {
-                    row["method"]: {
+                group = str(df_b["group"].iloc[0])
+                if group not in valid_resources:
+                    warnings.append(f"New resource \"{bname}\" - group \"{group}\" not found: check spelling.")
+                    continue
+                methods = {}
+                for _, row in df_b.iterrows():
+                    m = str(row["method"])
+                    if m not in valid_methods:
+                        warnings.append(f"New resource \"{bname}\" - method \"{m}\" not found: check spelling.")
+                        continue
+                    methods[m] = {
                         "min": float(row["min"]),
                         "median": float(row["median"]),
                         "max": float(row["max"]),
                     }
-                    for _, row in df_b.iterrows()
-                }
                 custom_resources.append({
                     "name": str(bname),
-                    "group": str(df_b["group"].iloc[0]),
+                    "group": group,
                     "amount": float(df_b["amount"].iloc[0]),
                     "unit": str(df_b["unit"].iloc[0]),
                     "methods": methods,
@@ -110,7 +123,7 @@ def load_inputs_from_excel(file):
                 r, m = row["resource"], row["method"]
                 enabled_methods.setdefault(r, {})[m] = bool(row["enabled"])
 
-    return resource_caps, constraints, costs, custom_resources, enabled_methods
+    return resource_caps, constraints, costs, custom_resources, enabled_methods, warnings
 
 def strip_unit_suffix(resource_name: str) -> str:
     """Remove legacy unit suffix from resource name, e.g. 'Unspecified land (ha/tCO2)' -> 'Unspecified land'"""