[FEAT] optimization: add tiebreak pass to prefer the more efficient resource in standard/custom pooling pairs

optimization/optimization.py

@@ -357,6 +357,65 @@ def extract_resource_usage(
     return resource_usage, resource_used_total, resource_remaining
 
 
+def resolve_pooling_tiebreak(
+    num_methods, num_lp_vars, method_outputs, custom_usage_pairs,
+    custom_pair_to_index, custom_batch_specs, method_costs, A_ub, b_ub, bounds,
+):
+    """Re-solve the LP with each method's output pinned, preferring the more
+    efficient resource within each standard/custom pooling pair.
+
+    The main LP (run_optimization) maximises total CO2 removed only — nothing
+    in its objective distinguishes a standard resource from a custom batch
+    that substitutes for it, so when both could satisfy the same demand the
+    solver picks an arbitrary split. This second pass fixes that: it pins
+    every active method's output y_m to its pass-1 value (so total_removed and
+    method_usage never change) and minimises Σ (c_n - c_s) · z_{m,n} across all
+    (method, batch) pooling pairs — i.e. it prefers fully using whichever
+    resource (standard or custom) has the lower coefficient (more MtCO2
+    removed per unit of resource) before drawing on the less efficient one.
+
+    Args:
+        num_methods (int): number of y_m variables.
+        num_lp_vars (int): total LP variable count (pass-1 sizing).
+        method_outputs (np.ndarray): y_m values from the pass-1 solution.
+        custom_usage_pairs (list): [(method, batch_name)] with non-zero coefficient.
+        custom_pair_to_index (dict): {(method, batch_name): lp_column_index}.
+        custom_batch_specs (dict): {batch_name: {group, amount, primary_methods}}.
+        method_costs (dict): {method: {resource: coefficient}}.
+        A_ub, b_ub: pass-1 constraint matrix/vector (reused unchanged — pass-1's
+            own solution already satisfies them, so this second LP is always feasible).
+        bounds: pass-1 variable bounds (reused unchanged).
+
+    Returns:
+        np.ndarray | None: the tie-broken solution vector, or None if there are
+            no pooling pairs to break ties on, or if the second solve fails
+            (in which case the caller should fall back to the pass-1 solution).
+    """
+    if not custom_usage_pairs:
+        return None
+
+    A_eq = np.zeros((num_methods, num_lp_vars))
+    for j in range(num_methods):
+        A_eq[j, j] = 1.0
+    b_eq = np.array(method_outputs, dtype=float)
+
+    objective2 = np.zeros(num_lp_vars)
+    for (m, batch_name) in custom_usage_pairs:
+        ref = custom_batch_specs[batch_name]["group"]
+        c_s = method_costs.get(m, {}).get(ref, 0.0)
+        c_n = method_costs.get(m, {}).get(batch_name, 0.0)
+        objective2[custom_pair_to_index[(m, batch_name)]] = c_n - c_s
+
+    try:
+        result = linprog(
+            objective2, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq,
+            bounds=bounds, method="highs",
+        )
+    except Exception:
+        return None
+    return result.x if result.success else None
+
+
 def run_perturbation(constraint_labels, A_ub, b_ub, objective_coefficients, bounds, num_methods, total_removed):
     """Compute marginal CDR gain per unit for each binding resource constraint.
 
@@ -524,8 +583,14 @@ def run_optimization(
             for j in range(num_methods) if method_outputs[j] > 1e-9
         }
 
+        tiebreak_solution = resolve_pooling_tiebreak(
+            num_methods, num_lp_vars, method_outputs, custom_usage_pairs,
+            custom_pair_to_index, custom_batch_specs, method_costs, A_ub, b_ub, bounds,
+        )
+        lp_solution_for_usage = tiebreak_solution if tiebreak_solution is not None else lp_solution
+
         resource_usage, resource_used_total, resource_remaining = extract_resource_usage(
-            active_methods, num_methods, method_outputs, lp_solution, method_costs,
+            active_methods, num_methods, method_outputs, lp_solution_for_usage, method_costs,
             resource_caps, custom_batch_specs, group_to_custom_batches,
             custom_pair_to_index, standard_resources,
             resources_no_batches, resources_with_batches, custom_batch_names,