[FIX] Lower usage epsilon to 1e-14 and raise on unknown cap_type in LP builder

optimization/optimization.py

@@ -250,14 +250,19 @@ def build_constraint_matrix(
             A_rows.append(row)
             b_rows.append(cap_value)
             constraint_labels.append(("method_cap", m))
-        else:
-            cap_ratio = cap_value / 100.0
+        elif cap_type == "percent":
+            cap_ratio = cap_value / 100
             row = np.zeros(num_lp_vars)
             row[:num_methods] -= cap_ratio
             row[j]            += 1.0
             A_rows.append(row)
             b_rows.append(0.0)
             constraint_labels.append(("method_cap", m))
+        else:
+            raise ValueError(
+                f"Unknown cap_type '{cap_type}' for method '{m}'. "
+                "Expected 'percent' or 'absolute'."
+            )
 
     A_ub = np.array(A_rows) if A_rows else np.empty((0, num_lp_vars))
     b_ub = np.array(b_rows)
@@ -296,13 +301,14 @@ def extract_resource_usage(
     all_resource_names = standard_resources + list(custom_batch_names)
     resource_usage = {r: {} for r in all_resource_names}
 
-    # 1e-9 is a near-zero threshold: LP solvers return tiny floating-point residuals
-    # (e.g. 0.000000001) instead of exact 0. Values below this threshold are treated
-    # as zero so they don't appear as spurious resource usage in the output.
+    # LP solvers (HiGHS) return floating-point residuals on the order of 1e-14 to
+    # 1e-12, so 1e-14 safely filters out numerical noise while preserving
+    # legitimately tiny usage values (e.g. Non-arable land coefficient = 1e-11).
+    _USAGE_EPS = 1e-14
     for r in resources_no_batches:
         for j, m in enumerate(active_methods):
             used = method_costs.get(m, {}).get(r, 0.0) * method_outputs[j]
-            if used > 1e-9:
+            if used > _USAGE_EPS:
                 resource_usage[r][m] = float(used)
 
     for r in resources_with_batches:
@@ -314,7 +320,7 @@ def extract_resource_usage(
                 if (m, batch_name) in custom_pair_to_index
             )
             used = c_s_m * (method_outputs[j] - z_sum)
-            if used > 1e-9:
+            if used > _USAGE_EPS:
                 resource_usage[r][m] = float(used)
 
     for batch_name, specs in custom_batch_specs.items():
@@ -330,10 +336,10 @@ def extract_resource_usage(
                 if (m, batch_name) in custom_pair_to_index
                 else 0.0
             )
-            if used > 1e-9:
+            if used > _USAGE_EPS:
                 resource_usage[batch_name][m] = float(used)
 
-    _EPS = 1e-9
+    _EPS = 1e-14
     resource_used_total = {
         r: round(sum(v.values()), 10) for r, v in resource_usage.items()
     }
@@ -489,13 +495,16 @@ def run_optimization(
     resources_with_batches = [r for r in standard_resources if r in group_to_custom_batches]
     resources_no_batches   = [r for r in standard_resources if r not in group_to_custom_batches]
 
-    A_ub, b_ub, constraint_labels = build_constraint_matrix(
-        active_methods, method_to_index, num_lp_vars, num_methods,
-        resource_caps, method_costs, method_constraints,
-        custom_batch_specs, group_to_custom_batches,
-        resources_no_batches, resources_with_batches,
-        custom_usage_pairs, custom_pair_to_index,
-    )
+    try:
+        A_ub, b_ub, constraint_labels = build_constraint_matrix(
+            active_methods, method_to_index, num_lp_vars, num_methods,
+            resource_caps, method_costs, method_constraints,
+            custom_batch_specs, group_to_custom_batches,
+            resources_no_batches, resources_with_batches,
+            custom_usage_pairs, custom_pair_to_index,
+        )
+    except ValueError as e:
+        return False, {"message": str(e)}
 
     # linprog minimises by convention, so we negate the objective to maximise Σ y_m.
     objective_coefficients = np.zeros(num_lp_vars)