[FEAT] Objective 3 – Additional data: amount of CO₂ (MtCO₂) removed if one unit of each resource is added

optimization/optimization.py

@@ -117,7 +117,9 @@ def run_optimization(
     resources_no_batches   = [r for r in standard_resources if r not in ref_to_batches]
 
     # ── Build LP constraint matrix ────────────────────────────────────────────
-    A_rows, b_rows = [], []
+    # 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
     for r in resources_no_batches:
@@ -127,6 +129,7 @@ def run_optimization(
         if np.any(row[:M] != 0):
             A_rows.append(row)
             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
@@ -141,6 +144,7 @@ def run_optimization(
         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
     for bname, info in custom_batch_info.items():
@@ -156,6 +160,7 @@ def run_optimization(
         if np.any(row != 0):
             A_rows.append(row)
             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.
@@ -181,6 +186,7 @@ def run_optimization(
             row[col] = 1.0
         A_rows.append(row)
         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:
@@ -190,6 +196,7 @@ def run_optimization(
                 row2[col] = -1.0
             A_rows.append(row2)
             b_rows.append(0.0)
+            constraint_labels.append(("coupling_D2", (m, ref)))
 
     # (E) Method cap constraints (on y_m)
     for j, m in enumerate(methods):
@@ -201,6 +208,7 @@ def run_optimization(
             row[j]  = 1.0
             A_rows.append(row)
             b_rows.append(cap_value)
+            constraint_labels.append(("method_cap", m))
         else:
             cap_ratio  = cap_value / 100.0
             row        = np.zeros(N)
@@ -208,6 +216,7 @@ def run_optimization(
             row[j]    += 1.0
             A_rows.append(row)
             b_rows.append(0.0)
+            constraint_labels.append(("method_cap", m))
 
     A_ub = np.array(A_rows) if A_rows else np.empty((0, N))
     b_ub = np.array(b_rows)
@@ -276,14 +285,34 @@ def run_optimization(
                              **{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)
+
+        # ── 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.
+        resource_actual_gain = {}
+        for i, (ctype, cid) in enumerate(constraint_labels):
+            if ctype not in ("resource", "custom_batch"):
+                continue
+            b_perturbed = b_ub.copy()
+            b_perturbed[i] += 1.0
+            try:
+                perturbed = linprog(
+                    c_obj, A_ub=A_ub, b_ub=b_perturbed, bounds=bounds, method="highs"
+                )
+                if perturbed.success:
+                    new_total = float(perturbed.x[:M].sum())
+                    resource_actual_gain[cid] = max(new_total - total_removed, 0.0)
+            except Exception:
+                pass
 
         return True, {
-            "total_removed":      total_removed,
-            "method_usage":       method_usage,
-            "resource_usage":     resource_usage,
-            "resource_used_total":resource_used_total,
-            "resource_remaining": resource_remaining,
+            "total_removed":        total_removed,
+            "method_usage":         method_usage,
+            "resource_usage":       resource_usage,
+            "resource_used_total":  resource_used_total,
+            "resource_remaining":   resource_remaining,
+            "resource_actual_gain": resource_actual_gain,
         }
 
     except Exception as e:

tabs/tab1_inputs.py

@@ -2,9 +2,9 @@ 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, secondary_resources)
+                           resource_unit_map, method_groups, CO2_UNIT, secondary_resources)
 from utils.data_utils import render_resource_input, strip_unit_suffix
-from utils.ui_helpers import format_resource_summary, format_table_summary, show_bar
+from utils.ui_helpers import format_resource_summary, show_bar
 from io import BytesIO
 
 # ─── Custom resource helpers ──────────────────────────────────────────────────
@@ -588,14 +588,14 @@ def render_tab(cost_sliders):
         unit = resource_unit_map.get(group, "")
         with st.expander(f"**{group}** ({unit})", expanded=True):
 
-            cols = st.columns(3)
+            cols = st.columns(4)
 
             for i, r in enumerate(rlist):
 
                 tooltip = resource_tooltips.get(r, None)
                 name_clean = r.split(" (")[0]
 
-                with cols[i % 3]:
+                with cols[i % 4]:
 
                     render_resource_input(name_clean, r, tooltip=tooltip)
 

tabs/tab2_constraints.py

@@ -4,7 +4,7 @@ import pandas as pd
 import streamlit as st
 
 from config.config import CO2_UNIT, method_groups, method_order, method_tooltips
-from utils.ui_helpers import format_table_summary, show_bar
+from utils.ui_helpers import show_bar
 
 
 # ─── Helpers ─────────────────────────────────────────────────────────────────
@@ -60,6 +60,7 @@ def render_method(m, cols, i):
             format_func=lambda x: "% of total potential"
             if x == "percent"
             else f"Absolute ({CO2_UNIT}/yr)",
+            label_visibility="collapsed",
         )
 
         st.session_state.constraints[m]["cap_type"] = cap_type
@@ -167,6 +168,18 @@ def render_tab():
     )
     df = build_summary_df()
     if df is not None:
-        st.markdown(format_table_summary(df,"cdr-table"), unsafe_allow_html=True)
+        df_display = df.reset_index().rename(columns={"index": "CDR Method"})
+        df_display = df_display[["CDR Method", "Cap value"]]
+        num_rows = len(df_display)
+        st.dataframe(
+            df_display,
+            use_container_width=True,
+            hide_index=True,
+            height=(num_rows * 36 + 10),
+            column_config={
+                "CDR Method": st.column_config.TextColumn("CDR Method", width="large"),
+                "Cap value": st.column_config.TextColumn("Cap value"),
+            },
+        )
     else:
         st.warning("No active methods selected.")

tabs/tab3_coefficients.py

@@ -25,8 +25,22 @@ def _get_slider_params(conf: dict) -> tuple:
 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):
+def _make_sync_s_to_m(slider_key, manual_key):
+    """on_change for slider: mirror its value into the number_input."""
+    def _sync():
+        st.session_state[manual_key] = st.session_state[slider_key]
+    return _sync
+
+def _make_sync_m_to_s(slider_key, manual_key, min_val, max_val):
+    """on_change for number_input: clamp to [min, max] and sync both widgets."""
+    def _sync():
+        clamped = max(min_val, min(max_val, st.session_state[manual_key]))
+        st.session_state[manual_key] = clamped
+        st.session_state[slider_key] = clamped
+    return _sync
+
+
+def _enforce_disabled_coefficients():
     # Intentionally a no-op: disabling a method for a resource must NOT permanently
     # zero the stored coefficient in session state, because re-enabling would then
     # see an existing key at 0 and the pre-init would skip restoration.
@@ -73,7 +87,7 @@ def render_tab(cost_sliders):
     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)
+    _enforce_disabled_coefficients()
 
     # Normalize cost_sliders once: strip unit suffixes from resource keys
     # cost_sliders_norm[method][resource_name] = {min, median, max}
@@ -231,6 +245,11 @@ def render_tab(cost_sliders):
 
                 if slider_key not in st.session_state:
                     st.session_state[slider_key] = current_val
+                if manual_key not in st.session_state:
+                    st.session_state[manual_key] = st.session_state[slider_key]
+
+                if st.session_state.get("resource_caps", {}).get(r, 0) <= 0:
+                    st.info(f"No available quantity set for **{r}** in Resource Inputs tab: **{method}** won't be used in the optimization.", icon=":material/info:")
 
                 col1, col2 = st.columns([3, 1])
                 with col1:
@@ -241,18 +260,20 @@ def render_tab(cost_sliders):
                         step=step,
                         format=fmt,
                         key=slider_key,
+                        on_change=_make_sync_s_to_m(slider_key, manual_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,
+                        on_change=_make_sync_m_to_s(slider_key, manual_key, conf["min"], conf["max"]),
                     )
 
-                st.session_state.costs[method][r] = manual_val if manual_val != slider_val else slider_val
+                st.session_state.costs[method][r] = st.session_state.get(manual_key, slider_val)
+
 
             # ── New (custom) resources linked to this method ────────────────
 
@@ -286,6 +307,12 @@ def render_tab(cost_sliders):
 
                 if slider_key not in st.session_state:
                     st.session_state[slider_key] = current_val
+                if manual_key not in st.session_state:
+                    st.session_state[manual_key] = st.session_state[slider_key]
+
+                batch_amount = next((float(b.get("amount", 0)) for b in custom_resources if b["name"] == r), 0.0)
+                if batch_amount <= 0:
+                    st.info(f"No available quantity set for **{r}** in Resource Inputs — this method won't be used in the optimization.", icon=":material/info:")
 
                 col1, col2 = st.columns([3, 1])
                 with col1:
@@ -296,19 +323,20 @@ def render_tab(cost_sliders):
                         step=step,
                         format=fmt,
                         key=slider_key,
+                        on_change=_make_sync_s_to_m(slider_key, manual_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,
+                        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] = manual_val if manual_val != slider_val else slider_val
+                st.session_state.costs[method][r] = st.session_state.get(manual_key, slider_val)
 
 
         # ── Reset buttons ────────────────────────────────────────────────────
@@ -362,12 +390,14 @@ def render_tab(cost_sliders):
     df_current = df_current.rename(columns=resource_display_full)
 
     styled = format_efficiency_summary(df_current, df_default)
+    num_rows = len(df_current)
     st.dataframe(
         data=styled, 
+        height=(num_rows*36 + 15),
         use_container_width=True, 
         column_config={
             "_index": st.column_config.TextColumn(
                 "Method",
-                # width="large"
-        )
+                width="large"
+        ),
     })

tabs/tab4_optimization.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+import datetime
 import io
 import json
 import re
@@ -13,7 +14,7 @@ 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.ui_helpers import apply_chart_style, register_chart_data, show_bar
 from utils.data_utils import is_valid_scenario, load_inputs_from_excel, neutralize_zero_coefficient_methods, strip_unit_suffix
 
 
@@ -395,6 +396,7 @@ def run_and_store_result():
         "resource_usage": result["resource_usage"],
         "resource_used_total": result["resource_used_total"],
         "resource_remaining": result["resource_remaining"],
+        "resource_actual_gain": result.get("resource_actual_gain", {}),
         "resource_caps": st.session_state.resource_caps.copy(),
         "method_constraints": st.session_state.constraints,
         "method_costs": st.session_state.costs,
@@ -664,6 +666,40 @@ def show_resource_balance(latest):
         st.dataframe(df, use_container_width=True, hide_index=True)
     register_chart_data("Resource balance (used vs remaining)", df)
 
+def show_bottleneck_analysis(latest):
+    st.markdown("### Resource sensitivity")
+    st.markdown(
+        '<p class="caption">'
+        'For every resource: actual CDR gain if you add exactly +1 unit, recomputed with all other constraints in place.'
+        '</p>',
+        unsafe_allow_html=True,
+    )
+
+    resource_to_group = {
+        r: group for group, resources in resource_groups.items() for r in resources
+    }
+    custom_batch_lookup = {b["name"]: b for b in latest.get("custom_resources", [])}
+
+    actual_gains = latest.get("resource_actual_gain", {})
+    if actual_gains:
+        sp_rows = []
+        for r, gain in sorted(actual_gains.items(), key=lambda x: -x[1]):
+            if r in custom_batch_lookup:
+                unit = resource_unit_map.get(resource_to_group.get(custom_batch_lookup[r]["group"]), "?")
+            else:
+                unit = resource_unit_map.get(resource_to_group.get(r), "?")
+            sp_rows.append({
+                "Resource": r,
+                "Unit": unit,
+                f"CDR gain for +1 unit ({CO2_UNIT})": round(gain, 4),
+            })
+        df_sp = pd.DataFrame(sp_rows)
+        with st.expander("📊 View / download resource sensitivity", expanded=True):
+            st.dataframe(df_sp, use_container_width=True, hide_index=True)
+        register_chart_data("Resource sensitivity (CDR gain per +1 unit)", df_sp)
+    else:
+        st.info("No resources to analyse.")
+
 # ─── Save / export / reset ───────────────────────────────────────────────────────────
 
 def save_scenario(latest):
@@ -736,9 +772,20 @@ def export_scenario():
         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())
+        alloc_df = pd.DataFrame.from_dict(scenario["allocations"], orient="index",
+                                          columns=[f"{CO2_UNIT} removed"])
+        alloc_df[f"{CO2_UNIT} removed"] = pd.to_numeric(alloc_df[f"{CO2_UNIT} removed"], errors="coerce")
+        alloc_total = alloc_df[f"{CO2_UNIT} removed"].sum()
+        if alloc_total > 0:
+            alloc_df["Total share (%)"] = (alloc_df[f"{CO2_UNIT} removed"] / alloc_total * 100).round(2)
+        _method_constraints = scenario.get("method_constraints", {})
+        alloc_df["Cap constraint"] = pd.Series({
+            m: (f"{c['cap_value']:,.2f} {CO2_UNIT}/yr" if c.get("cap_type") == "absolute"
+                else f"{int(c.get('cap_value', 100))}% of potential")
+            for m, c in _method_constraints.items()
+        })
+        alloc_df = alloc_df.sort_values(f"{CO2_UNIT} removed", ascending=False)
+        zf.writestr("allocations.csv", alloc_df.to_csv())
         
         custom_batches = scenario.get("custom_resources", [])
         if custom_batches:
@@ -768,22 +815,67 @@ def export_scenario():
 
         resource_used_total = scenario.get("resource_used_total", {})
         resource_remaining = scenario.get("resource_remaining", {})
+        _all_caps = dict(scenario.get("resource_caps", {}))
+        _custom_batches_map = {b["name"]: b for b in scenario.get("custom_resources", [])}
+        for _bn, _bi in _custom_batches_map.items():
+            _all_caps.setdefault(_bn, float(_bi["amount"]))
         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())
+            balance_rows = []
+            for r, cap in _all_caps.items():
+                if cap <= 0:
+                    continue
+                if r in _custom_batches_map:
+                    _unit = resource_unit_map.get(resource_to_group.get(_custom_batches_map[r]["group"]), "?")
+                else:
+                    _unit = resource_unit_map.get(resource_to_group.get(r), "?")
+                used = resource_used_total.get(r, 0.0)
+                balance_rows.append({
+                    "Resource": r,
+                    "Unit": _unit,
+                    "Available amount": cap,
+                    "Quantity used": used,
+                    "Quantity remaining": resource_remaining.get(r, cap),
+                    "% used": round(used / cap * 100, 1) if cap > 0 else 0,
+                })
+            zf.writestr("resource_balance.csv", pd.DataFrame(balance_rows).to_csv(index=False))
 
         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()
-            ]
+            usage_rows = []
+            for r, methods in resource_usage.items():
+                if r in _custom_batches_map:
+                    _u = resource_unit_map.get(resource_to_group.get(_custom_batches_map[r]["group"]), "?")
+                else:
+                    _u = resource_unit_map.get(resource_to_group.get(r), "?")
+                for m, qty in methods.items():
+                    usage_rows.append({"resource": r, "unit": _u, "method": m, "used": qty})
             zf.writestr("resource_usage_detail.csv", pd.DataFrame(usage_rows).to_csv(index=False))
 
+        _actual_gains = scenario.get("resource_actual_gain", {})
+        if _actual_gains:
+            sens_rows = []
+            for r, gain in sorted(_actual_gains.items(), key=lambda x: -x[1]):
+                if r in _custom_batches_map:
+                    _u = resource_unit_map.get(resource_to_group.get(_custom_batches_map[r]["group"]), "?")
+                else:
+                    _u = resource_unit_map.get(resource_to_group.get(r), "?")
+                sens_rows.append({
+                    "resource": r,
+                    "unit": _u,
+                    f"CDR_gain_for_+1_unit_{CO2_UNIT}": round(gain, 4),
+                })
+            zf.writestr("resource_sensitivity.csv", pd.DataFrame(sens_rows).to_csv(index=False))
+
+        _summary = scenario.get("summary", {})
+        summary_rows = [
+            {"metric": "Scenario name",                    "value": name,                                        "unit": ""},
+            {"metric": "Export timestamp",                 "value": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "unit": ""},
+            {"metric": f"Total {CO2_UNIT} removed",        "value": _summary.get("total_co2_removed", ""),       "unit": CO2_UNIT},
+            {"metric": "Total cost (resource units sum)",  "value": _summary.get("total_cost", ""),              "unit": "mixed"},
+            {"metric": "Methods used",                     "value": len(scenario.get("allocations", {})),        "unit": "count"},
+        ]
+        zf.writestr("summary.csv", pd.DataFrame(summary_rows).to_csv(index=False))
+
     with col_csv:
         st.download_button(
             "Export CSV (zip)", data=buf.getvalue(),
@@ -1032,7 +1124,7 @@ def render_tab():
             <p class="crra-sub-sub-heading">From inputs</p>""",
             unsafe_allow_html=True,
         )
-        run_clicked = st.button("▶️ Run Optimization", use_container_width=True)
+        run_clicked = st.button("Run Optimization", icon=":material/play_arrow:", key="btn-run-optimization", type="primary")
         panel_run_from_tabs()
         panel_load_from_excel()
 
@@ -1092,6 +1184,7 @@ def render_tab():
                         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")

tabs/tab6_scenarios.py

@@ -142,7 +142,7 @@ def render_tab():
     panel_load_scenario()
 
     if not st.session_state.scenarios:
-        st.info("No scenarios saved yet. Run an optimization in tab 4 or load a file above.")
+        st.info("No scenarios saved yet. Run an optimization in **Portfolio Optimization** tab or load a file above.")
         return
 
     # Select & manage scenarios