test(individual_asv_pressure): regression test for boundary collapse and success flag

Adds a test that fails on main with DidNotConvergeError([0, 0]) due to
two bugs in IndividualASVPressureControlStrategy that are fixed in the
companion commit:

1. Boundary collapse: _minimum_achievable_pressure sets recirculation
   to maximum, then run(to_id=compressor_id) traverses the mixer,
   returning a stream whose rate already includes max recirculation.
   This makes boundary.max = max_std - (inlet + max_recirc) = 0, so
   RecirculationSolver receives [0, 0] and raises DidNotConvergeError.

2. Success flag: outlet_stream == target_pressure compares FluidStream
   to FloatConstraint — the types are incompatible so it always returns
   False, making the strategy report failure even when the target is met.

Author: olelod

tests/libecalc/domain/process/process_solver/pressure_control/test_individual_asv_pressure_pressure_control_strategy.py

@@ -0,0 +1,115 @@
+"""Regression test for IndividualASVPressureControlStrategy success-flag bug.
+
+Bug: IndividualASVPressureControlStrategy.apply returned
+    Solution(success=outlet_stream == target_pressure, ...)
+where outlet_stream is a FluidStream and target_pressure is a FloatConstraint.
+Because these are different types, Python's equality check always returns False
+(no __eq__ override bridges them), so the strategy always reported success=False
+even when the recirculation was correctly adjusted and the target was met.
+
+Fix: compare outlet_stream.pressure_bara == target_pressure, which uses
+FloatConstraint.__eq__ (isclose, abs_tol=1e-3).
+
+Secondary bug also fixed (covered by the same test): the boundary for
+RecirculationSolver was computed via run(to_id=compressor_id), which traverses
+through the RecirculationLoop mixer and returns a stream whose rate already
+includes the current recirculation. After _minimum_achievable_pressure sets
+recirculation to its maximum, the boundary collapses to [0, 0], preventing
+the solver from finding a valid recirculation.
+Fix: use run(to_id=recirculation_loop_id) to stop before the mixer.
+"""
+
+import pytest
+
+from libecalc.domain.process.process_solver.float_constraint import FloatConstraint
+from libecalc.domain.process.value_objects.chart import ChartCurve
+
+
+@pytest.mark.parametrize("target_pressure_bara", [50.0, 70.0, 87.0])
+def test_individual_asv_pressure_control_reaches_target_pressure(
+    target_pressure_bara,
+    stream_factory,
+    chart_data_factory,
+    fluid_service,
+    stage_units_factory,
+    with_individual_asv,
+    process_runner_factory,
+    individual_asv_pressure_control_strategy_factory,
+):
+    """IndividualASVPressureControlStrategy must report success=True when the target is met.
+
+    On main: two bugs cause failure:
+    1. Boundary collapse: the per-stage boundary is computed via run(to_id=compressor_id),
+       which traverses through the RecirculationLoop mixer. After _minimum_achievable_pressure
+       sets recirculation to its maximum, the stream at the compressor already includes that
+       max recirculation, making boundary.max = max_std - (inlet + max_recirc) = 0. The
+       RecirculationSolver receives boundary=[0, 0] and raises DidNotConvergeError.
+    2. Wrong success flag: even if the solver ran, success=outlet_stream == target_pressure
+       compares FluidStream to FloatConstraint — always False.
+
+    With fix: stable boundary (run stops before mixer), correct type comparison.
+    """
+    temperature = 300.0
+    inlet_standard_rate = 500_000.0  # sm3/day
+    inlet_pressure = 30.0  # bara
+
+    inlet_stream = stream_factory(
+        standard_rate_m3_per_day=inlet_standard_rate,
+        pressure_bara=inlet_pressure,
+        temperature_kelvin=temperature,
+    )
+    q0 = float(inlet_stream.volumetric_rate_m3_per_hour)
+
+    # Chart: min_rate = 2*q0 (inlet is BELOW min → ASV recirculation always needed).
+    # At min speed (75 RPM):
+    #   - Outlet at surge flow (2*q0): head=head_hi=150k → outlet ≈ 89 bara
+    #   - Max recirculation: flow = 8*q0, head=head_lo=40k → outlet ≈ 41 bara
+    # All three target pressures (50, 70, 87) lie strictly between 41 and 89 bara.
+    chart_data = chart_data_factory.from_curves(
+        curves=[
+            ChartCurve(
+                speed_rpm=75.0,
+                rate_actual_m3_hour=[q0 * 2, q0 * 8],
+                polytropic_head_joule_per_kg=[150_000.0, 40_000.0],
+                efficiency_fraction=[0.75, 0.75],
+            ),
+            ChartCurve(
+                speed_rpm=105.0,
+                rate_actual_m3_hour=[q0 * 2, q0 * 8],
+                polytropic_head_joule_per_kg=[150_000.0 * 1.05, 40_000.0 * 1.05],
+                efficiency_fraction=[0.75, 0.75],
+            ),
+        ],
+        control_margin=0.0,
+    )
+
+    from libecalc.domain.process.entities.shaft import VariableSpeedShaft
+
+    shaft = VariableSpeedShaft()
+    shaft.set_speed(75.0)
+
+    units = stage_units_factory(chart_data=chart_data, shaft=shaft, temperature_kelvin=temperature)
+    wrapped_units, loop_ids, compressors = with_individual_asv(units)
+    runner = process_runner_factory(units=wrapped_units, shaft=shaft)
+
+    strategy = individual_asv_pressure_control_strategy_factory(
+        runner=runner,
+        recirculation_loop_ids=loop_ids,
+        compressors=compressors,
+    )
+
+    target = FloatConstraint(target_pressure_bara)
+    solution = strategy.apply(target_pressure=target, inlet_stream=inlet_stream)
+
+    assert solution.success is True, (
+        f"Expected success=True for target={target_pressure_bara} bara, got False. "
+        "This indicates IndividualASVPressureControlStrategy compared FluidStream == FloatConstraint "
+        "(always False) instead of outlet_stream.pressure_bara == target_pressure."
+    )
+
+    runner.apply_configurations(solution.configuration)
+    outlet = runner.run(inlet_stream=inlet_stream)
+
+    assert outlet.pressure_bara == pytest.approx(
+        target_pressure_bara, rel=1e-3
+    ), f"Expected outlet {target_pressure_bara} bara but got {outlet.pressure_bara:.4f} bara."