[FIX] Model: Updating the model calculation when a method is removed from tab one

optimization/optimization.py

@@ -43,19 +43,22 @@ def run_optimization(
     custom_batch_info = {}          # {batch_name: {"group": ref, "amount": Q}}
     for batch in (custom_resources or []):
         custom_batch_info[batch["name"]] = {
-            "group":  batch["group"],
-            "amount": float(batch["amount"]),
+            "group":           batch["group"],
+            "amount":          float(batch["amount"]),
+            "primary_methods": set(batch.get("methods", {}).keys()),
         }
     custom_names   = set(custom_batch_info)
     ref_to_batches = {}             # {standard_resource: [batch_name, ...]}
     for bname, info in custom_batch_info.items():
         ref_to_batches.setdefault(info["group"], []).append(bname)
-
-    # ── Inject primary batch coefficients (fallback) ─────────────────────────
-    # Tab 3 pre-init may have set the coefficient to 0 if it classified the
-    # link as secondary (or if the key already existed at 0 from a prior run).
-    # For methods explicitly listed in batch["methods"] (primary dialog links),
-    # fall back to the batch median so the LP can actually use the resource.
+        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.
     for batch in (custom_resources or []):
         bname = batch["name"]
         for method, coefs in batch["methods"].items():
@@ -84,22 +87,22 @@ def run_optimization(
         return False, {"message": "No active methods."}
 
     # ── Split-variable list ───────────────────────────────────────────────────
-    # z_{m,n}  exists when BOTH c_s[m] > 0 AND c_n[m] > 0.
-    # It represents CO₂ attributed to custom pool n for method m, substituting
-    # for an equal amount of output that would otherwise consume standard pool s.
-    #
-    # Guard: if the standard resource cap is 0 (user left it unset), the custom
-    # batch is also inactive — a batch supplements an existing resource, it doesn't
-    # enable a resource type that the user hasn't allocated.
+    # z_{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).
     z_pairs = []
     for bname, info in custom_batch_info.items():
-        ref = info["group"]
-        if resource_caps.get(ref, 0.0) <= 0:
-            continue  # standard resource unavailable → custom batch inactive too
+        ref             = info["group"]
+        primary_methods = info["primary_methods"]
+        if resource_caps.get(bname, 0.0) <= 0:
+            continue  # custom batch has no capacity → inactive
         for m in methods:
-            c_s = method_costs.get(m, {}).get(ref,   0.0)
+            if m not in primary_methods:
+                continue  # only methods explicitly linked to this batch in the dialog
             c_n = method_costs.get(m, {}).get(bname, 0.0)
-            if c_s > 0 and c_n > 0:
+            if c_n > 0:
                 z_pairs.append((m, bname))
 
     Z     = len(z_pairs)
@@ -139,31 +142,27 @@ def run_optimization(
             A_rows.append(row)
             b_rows.append(resource_caps[r])
 
-    # (C) Custom batch capacity constraints
-    # For substitutable pairs  (m, n) in z_idx  → c_n[m] * z_{m,n}
-    # For non-substitutable    (c_s = 0, c_n > 0) → c_n[m] * y_m  (method fully
-    #   relies on this batch since it has no access to the standard resource)
-    # Skip entirely when the standard resource cap is 0 (batch is inactive).
+    # (C) Custom batch capacity constraints: Σ_m c_n[m] * z_{m,n} ≤ Q_n
     for bname, info in custom_batch_info.items():
-        ref = info["group"]
-        if resource_caps.get(ref, 0.0) <= 0:
+        if resource_caps.get(bname, 0.0) <= 0:
             continue
         row = np.zeros(N)
         for j, m in enumerate(methods):
-            c_n_m = method_costs.get(m, {}).get(bname, 0.0)
-            if c_n_m <= 0:
+            if (m, bname) not in z_idx:
                 continue
-            c_s_m = method_costs.get(m, {}).get(ref, 0.0)
-            if c_s_m > 0 and (m, bname) in z_idx:
+            c_n_m = method_costs.get(m, {}).get(bname, 0.0)
+            if c_n_m > 0:
                 row[z_idx[(m, bname)]] = c_n_m
-            else:
-                row[j] = c_n_m          # entire y_m draws from this batch
         if np.any(row != 0):
             A_rows.append(row)
-            b_rows.append(info["amount"])
-
-    # (D) Coupling constraints per (method, standard-resource-type)
-    # Ensure  Σ_{n: ref(n)=s} z_{m,n}  ≤  y_m  so standard usage stays ≥ 0
+            b_rows.append(resource_caps.get(bname, 0.0))
+
+    # (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.
     coupling_done = set()
     for (m, bname) in z_pairs:
         ref = custom_batch_info[bname]["group"]
@@ -171,15 +170,27 @@ def run_optimization(
         if key in coupling_done:
             continue
         coupling_done.add(key)
-        j   = method_idx[m]
+        j     = method_idx[m]
+        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 bn in ref_to_batches.get(ref, []):
-            if (m, bn) in z_idx:
-                row[z_idx[(m, bn)]] = 1.0
+        for col in batch_cols:
+            row[col] = 1.0
         A_rows.append(row)
         b_rows.append(0.0)
 
+        # 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
+            for col in batch_cols:
+                row2[col] = -1.0
+            A_rows.append(row2)
+            b_rows.append(0.0)
+
     # (E) Method cap constraints (on y_m)
     for j, m in enumerate(methods):
         constraint = method_constraints.get(m, {})
@@ -242,18 +253,20 @@ def run_optimization(
                 if used > 1e-9:
                     resource_usage[r][m] = float(used)
 
-        # Custom batches
+        # Custom batches — only for methods explicitly linked in the dialog
         for bname, info in custom_batch_info.items():
-            ref = info["group"]
+            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
                 c_n_m = method_costs.get(m, {}).get(bname, 0.0)
                 if c_n_m <= 0:
                     continue
-                c_s_m = method_costs.get(m, {}).get(ref, 0.0)
-                if c_s_m > 0 and (m, bname) in z_idx:
+                if (m, bname) in z_idx:
                     used = c_n_m * sol[z_idx[(m, bname)]]
                 else:
-                    used = c_n_m * y[j]
+                    used = 0.0
                 if used > 1e-9:
                     resource_usage[bname][m] = float(used)
 

tabs/tab1_inputs.py

@@ -18,6 +18,8 @@ def init_custom_resources():
         st.session_state.custom_resources = []
     if "enabled_methods" not in st.session_state:
         st.session_state.enabled_methods = {}
+    if "auto_disabled_methods" not in st.session_state:
+        st.session_state.auto_disabled_methods = set()
     for batch in st.session_state.custom_resources:
         try:
             batch["amount"] = float(batch["amount"])
@@ -678,16 +680,38 @@ def render_tab(cost_sliders):
             if ok:
                 method_active_resource_count[m] += 1
 
+    # Custom batches are INDEPENDENT of the standard resource toggle: a method
+    # linked to a custom batch with capacity counts as having an active resource,
+    # even if it is disabled for the standard reference resource.
+    for batch in st.session_state.get("custom_resources", []):
+        if float(batch.get("amount") or 0) <= 0:
+            continue
+        for m_name in batch.get("methods", {}).keys():
+            method_active_resource_count.setdefault(m_name, 0)
+            method_active_resource_count[m_name] += 1
+
     methods_with_no_active_resource = [
         m for m in method_to_primary_resources
         if method_active_resource_count.get(m, 0) == 0
     ]
 
+    # Re-enable methods that were auto-disabled but now have at least one active resource
+    for m in list(st.session_state.auto_disabled_methods):
+        if method_active_resource_count.get(m, 0) > 0:
+            if m in st.session_state.constraints:
+                st.session_state.constraints[m]["active"] = True
+            toggle_key = f"toggle_{m}"
+            if toggle_key in st.session_state:
+                st.session_state[toggle_key] = True
+            st.session_state.auto_disabled_methods.discard(m)
+
+    # Auto-disable methods that now have no active primary resource
     newly_disabled = []
     for m in methods_with_no_active_resource:
         if st.session_state.constraints.get(m, {}).get("active", True):
             st.session_state.constraints.setdefault(m, {"active": True, "cap_type": "percent", "cap_value": 100})
             st.session_state.constraints[m]["active"] = False
+            st.session_state.auto_disabled_methods.add(m)
             newly_disabled.append(m)
             toggle_key = f"toggle_{m}"
             if toggle_key in st.session_state:

tabs/tab3_coefficients.py

@@ -27,24 +27,12 @@ def is_method_enabled(method, resource, enabled_methods):
 
 
 def _enforce_disabled_coefficients(method_order_, resource_order_, custom_resources, enabled_methods):
-    """Zero out st.session_state.costs[method][resource] for every (method, resource)
-    pair the user disabled in tab1 — even if that pair was never opened in this tab.
-    Without this, a disabled pair silently keeps its last/default coefficient and
-    gets exported/optimised as if it were still active."""
-    for r in resource_order_:
-        disallowed = {m for m, ok in enabled_methods.get(r, {}).items() if not ok}
-        if not disallowed:
-            continue
-        for m in disallowed:
-            if m in st.session_state.costs and r in st.session_state.costs[m]:
-                st.session_state.costs[m][r] = 0.0
-
-    for batch in custom_resources or []:
-        r = batch["name"]
-        disallowed = {m for m, ok in enabled_methods.get(r, {}).items() if not ok}
-        for m in disallowed:
-            if m in st.session_state.costs and r in st.session_state.costs[m]:
-                st.session_state.costs[m][r] = 0.0
+    # 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.
+    # The LP in optimization.py already applies enabled_methods at call time
+    # (zeroing only for that run, without mutating session state).
+    pass
 
 
 def render_tab(cost_sliders):
@@ -142,6 +130,21 @@ def render_tab(cost_sliders):
         sub_group = custom_resource_to_sub_group.get(custom_r)
         return sub_group is not None and (method_name, sub_group) in secondary_resources
 
+    # Build reverse index: custom resource name → set of valid methods
+    valid_methods_for_custom = {}
+    for m, resources in custom_sliders_by_method.items():
+        for r in resources:
+            valid_methods_for_custom.setdefault(r, set()).add(m)
+
+    # Remove stale session state entries: a method should not carry a custom
+    # resource coefficient if it is not linked to that batch (neither as
+    # explicit primary nor as secondary auto-injection).  Stale values can
+    # persist across reruns and cause the LP to create spurious z-pairs.
+    for r_name, valid in valid_methods_for_custom.items():
+        for m in list(st.session_state.get("costs", {}).keys()):
+            if r_name in st.session_state.costs.get(m, {}) and m not in valid:
+                del st.session_state.costs[m][r_name]
+
     # Pre-initialize costs for custom resources so the summary table shows the
     # correct value immediately, without needing to open the expander first.
     # Secondary custom resources start at 0 (like standard secondary resources).
@@ -202,7 +205,6 @@ def render_tab(cost_sliders):
                 enabled = is_method_enabled(method, r, enabled_methods)
                 if not enabled:
                     st.info(f"INFO: Method disabled for **{r}** (see Resource Inputs tab)")
-                    st.session_state.costs[method][r] = 0.0
                     continue
                 conf = method_sliders[r]
                 display_label = resource_display.get(r, r)
@@ -259,7 +261,6 @@ def render_tab(cost_sliders):
                 enabled = is_method_enabled(method, r, enabled_methods)
                 if not enabled:
                     st.info("INFO: Method disabled for this resource (see Resource Inputs tab)")
-                    st.session_state.costs.setdefault(method, {})[r] = 0.0
                     continue
 
                 _is_cust_secondary = is_custom_secondary(method, r)

tabs/tab4_optimization.py

@@ -330,8 +330,27 @@ def run_and_store_result():
         st.warning("⚠️ All resources are set to 0. Please set resource availability or load a scenario / input data.")
         return
     
+    # Apply enabled_methods overrides to a temporary copy so that
+    # neutralize_zero_coefficient_methods sees the effective coefficients
+    # (a method fully disabled for its only resource has all-zero coefficients
+    # and must be deactivated before the LP is built).
+    costs_effective = {m: dict(v) for m, v in st.session_state.costs.items()}
+    for _m, _resources in costs_effective.items():
+        for _r in list(_resources):
+            if not enabled_methods.get(_r, {}).get(_m, True):
+                costs_effective[_m][_r] = 0.0
+
+    # Inject custom batch coefficients into costs_effective so neutralize does
+    # not wrongly deactivate a method that only has custom-batch access.
+    # Custom pools are INDEPENDENT of the standard resource enable/disable toggle.
+    for _batch in custom_resources:
+        _bname = _batch["name"]
+        for _m, _coefs in _batch.get("methods", {}).items():
+            if _m in costs_effective and costs_effective[_m].get(_bname, 0.0) == 0.0:
+                costs_effective[_m][_bname] = _coefs.get("median", 0.0)
+
     safe_constraints = neutralize_zero_coefficient_methods(
-        st.session_state.costs, st.session_state.constraints
+        costs_effective, st.session_state.constraints
     )
     neutralized = [
         m for m in safe_constraints
@@ -341,7 +360,7 @@ def run_and_store_result():
 
     success, result = run_optimization(
         resource_caps=st.session_state.resource_caps,
-        method_constraints=st.session_state.constraints,
+        method_constraints=safe_constraints,
         method_costs=st.session_state.costs,
         custom_resources=custom_resources,
         enabled_methods=enabled_methods,