[FIX] Tab4: Deactivate methods with missing resources and fix batch coefficient injection for non-Other methods

tabs/tab4_optimization.py

@@ -425,6 +425,26 @@ def run_and_store_result():
         if m in applied_costs
     }
     safe_constraints = neutralize_zero_coefficient_methods(applied_costs, standard_constraints)
+
+    # Deactivate any method that requires a resource not provided in tab1.
+    # Hidden resources (e.g. "Other water") are never in resource_caps because
+    # they are not shown in tab1.  Without this check, methods that consume such
+    # resources go unconstrained in the LP and produce misleading results.
+    # A resource is "missing" when it is absent from resource_caps (not set by
+    # the user) AND has no custom batch covering it.
+    custom_batch_names_pre = {b["name"] for b in custom_resources}
+    available_resources = set(st.session_state.resource_caps) | custom_batch_names_pre
+    for m, costs in applied_costs.items():
+        if not safe_constraints.get(m, {}).get("active", True):
+            continue
+        missing = [
+            r for r, c in costs.items()
+            if c > 0 and r not in available_resources
+        ]
+        if missing:
+            safe_constraints.setdefault(m, {"active": True, "cap_type": "percent", "cap_value": 100})
+            safe_constraints[m] = {**safe_constraints[m], "active": False}
+
     neutralized = [
         m for m in safe_constraints
         if safe_constraints[m].get("active") is False
@@ -480,6 +500,31 @@ def run_and_store_result():
     # Display functions keep the full list so group/unit info is available.
     custom_resources_for_display = list(custom_resources)
 
+    # Non-"Other" methods that shared an expanded batch (e.g. "Mineral OAE" also
+    # used "Limestone") lost their z-variable when the batch was removed from
+    # custom_resources_for_lp.  Inject the batch as a standard resource coefficient
+    # into their applied_costs so the type-A constraint still applies to them.
+    #
+    # Also zero out the standard group resource coefficient when the standard pool
+    # is empty (cap = 0).  In the z-variable path the B-constraint allows
+    # "y_m - z_{m,n} ≤ 0", letting the batch fully cover the method.  In the
+    # standard-resource path that substitute mechanism is gone, so a method with
+    # cost(group) > 0 and cap(group) = 0 would be incorrectly forced to y = 0
+    # by the type-A constraint before it can use the batch at all.
+    for batch in custom_resources:
+        if batch["name"] not in expanded_batch_names:
+            continue
+        batch_group = batch.get("group", "")
+        group_cap_is_zero = resource_caps_for_lp.get(batch_group, 0.0) == 0.0
+        for method_name, coeff_dict in batch.get("methods", {}).items():
+            if method_name not in applied_costs:
+                continue  # "Other" method was already replaced by variants above
+            applied_costs[method_name][batch["name"]] = coeff_dict.get("median", 0.0)
+            # If the standard pool for this group is empty, zero its coefficient so
+            # the type-A constraint doesn't force the method's output to zero.
+            if group_cap_is_zero and batch_group in applied_costs[method_name]:
+                applied_costs[method_name][batch_group] = 0.0
+
     success, result = run_optimization(
         resource_caps=resource_caps_for_lp,
         method_constraints=safe_constraints,

utils/data_utils.py

@@ -260,5 +260,5 @@ def get_other_method_variants(method_name: str, custom_resources: list) -> list:
 
 
 def make_variant_name(method_name: str, batch_name: str) -> str:
-    """Build the display/LP name for a method variant: '<Method> - <Batch>'."""
+    """Build the display/LP name for a method variant: '<Method>: <Batch>'."""
     return f"{method_name}: {batch_name}"