[FIX] tab5: exclude zero-cap resources and inactive methods from sensitivity selectors, remove redundant session state guards

tabs/tab5_sensitivity.py

@@ -27,8 +27,18 @@ def compute_baseline():
     )
     baseline_removed = baseline_result["total_removed"] if baseline_success else 0
 
-    custom_resource_names = [b["name"] for b in st.session_state.get("custom_resources", [])]
-    all_resources = [r for r in resource_order if r not in hidden_resource_names] + custom_resource_names
+    # Only offer resources that actually have a quantity set — sweeping a
+    # resource currently at 0 always gives 0 regardless of the % slider
+    # (any percentage of a 0 base cap is still 0), so it's never useful to
+    # compare.
+    custom_resource_names = [
+        b["name"] for b in st.session_state.get("custom_resources", [])
+        if float(b.get("amount", 0)) > 0
+    ]
+    all_resources = [
+        r for r in resource_order
+        if r not in hidden_resource_names and st.session_state.resource_caps.get(r, 0) > 0
+    ] + custom_resource_names
 
     resource_to_unit = get_resource_to_unit()
     for b in st.session_state.get("custom_resources", []):
@@ -121,7 +131,8 @@ def panel_method_sensitivity(baseline_removed):
 
     Sweeps each selected method's cap from 0 % to 100 % of its current value
     in 10 % steps, re-solves the LP at each point, and plots total CO₂ removed.
-    Skips methods whose current cap is 0.
+    Methods whose current cap is already 0 are excluded from the selector
+    entirely (sweeping "X% of 0" is always 0, never useful to compare).
 
     Args:
         baseline_removed (float): total CO₂ removed at current inputs.
@@ -138,14 +149,38 @@ def panel_method_sensitivity(baseline_removed):
     # independent variants (e.g. "Enhanced weathering - Other mineral: Ganite")
     # by run_expanded_optimization — offer those variants as selectable
     # entries too, alongside the standard method names, so their own cap can
-    # be swept just like any other method.
+    # be swept just like any other method. An "Other"-tagged method with NO
+    # batch attached has no variant AND can never produce any result on its
+    # own (its only resource is the hidden "Other X" pool, which is never
+    # directly settable) — skip it entirely rather than offer a sweep that
+    # would always show a flat 0 line.
+    #
+    # Same reasoning as the resource panel: a method whose current cap is
+    # already 0 would sweep to "X% of 0", always 0 regardless of the slider —
+    # never useful to compare — so it's excluded from the list up front
+    # instead of being selectable and only warned about afterwards. Same for
+    # a method that is simply inactive (missing resources, manually toggled
+    # off in Tab 2...): sweeping its cap_value doesn't touch "active", so the
+    # perturbed run stays forced to 0 regardless — just as pointless to offer.
+    def _current_cap(method_name):
+        constraint = st.session_state.constraints.get(method_name) or default_constraint()
+        cap_type = constraint.get("cap_type", "percent")
+        return constraint.get("cap_value", 100 if cap_type == "percent" else 0.0)
+
+    def _is_sweepable(method_name):
+        constraint = st.session_state.constraints.get(method_name) or default_constraint()
+        return constraint.get("active", True) and _current_cap(method_name) > 0
+
     custom_resources = st.session_state.get("custom_resources", [])
     method_options = []
     for m in method_order:
         variants = get_other_method_variants(m, custom_resources)
         if variants:
-            method_options.extend(make_variant_name(m, b["name"]) for b in variants)
-        else:
+            method_options.extend(
+                make_variant_name(m, b["name"]) for b in variants
+                if _is_sweepable(make_variant_name(m, b["name"]))
+            )
+        elif not is_other_method(m) and _is_sweepable(m):
             method_options.append(m)
 
     selected_methods = st.multiselect(
@@ -158,18 +193,11 @@ def panel_method_sensitivity(baseline_removed):
 
     percentages = list(range(0, 110, 10))
     all_data = []
-    skipped = []
 
     for method in selected_methods:
         constraint = st.session_state.constraints.get(method) or default_constraint()
         cap_type = constraint.get("cap_type", "percent")
-        current_cap = constraint.get(
-            "cap_value", 100 if cap_type == "percent" else 0.0
-        )
-
-        if current_cap <= 0:
-            skipped.append(method)
-            continue
+        current_cap = _current_cap(method)
 
         for pct in percentages:
             perturbed_constraints = copy.deepcopy(st.session_state.constraints)
@@ -198,9 +226,6 @@ def panel_method_sensitivity(baseline_removed):
                 f"CO₂ removed ({CO2_UNIT})": result["total_removed"] if success else 0,
             })
 
-    for m in skipped:
-        st.warning(f"Method **{m}** has a cap of 0 — set a value first to include it.", icon=":material/warning:")
-
     if not all_data:
         return
 
@@ -229,8 +254,8 @@ def render_tab():
 
     Computes a baseline optimisation from session state, then lets the user
     sweep one or more resources (or method caps) over a range and plots how
-    total CO₂ removed changes. Requires resource_caps, constraints, and costs
-    to be present in session state.
+    total CO₂ removed changes. resource_caps, constraints, and costs are
+    guaranteed present by app.py's shared init, which runs before any tab.
 
     Returns:
         None
@@ -247,14 +272,6 @@ def render_tab():
         unsafe_allow_html=True,
     )
 
-    if (
-        "resource_caps" not in st.session_state
-        or "constraints" not in st.session_state
-        or "costs" not in st.session_state
-    ):
-        st.warning("Please complete the setup in previous tabs before running sensitivity analysis.", icon=":material/warning:")
-        return
-
     baseline_removed, all_resources, resource_to_unit = compute_baseline()
 
     tab1, tab2 = st.tabs(["🔁 Resource sensitivity", "🔁 Method sensitivity"])