fix(process): speed solver tolerates infeasible EOS probes

Treat speeds that make the EOS / fluid layer fail as infeasible probes
rather than letting the exception crash the run. Bisect down from the
max-speed probe when it's rejected by the EOS, and add an outer guard
that marks otherwise-unrecoverable timesteps as NOT_CALCULATED.

Author: olelod

src/libecalc/domain/process/compressor/core/results.py

@@ -80,6 +80,33 @@ def create_empty(cls) -> CompressorTrainStageResultSingleTimeStep:
             point_is_valid=True,
         )
 
+    @classmethod
+    def create_infeasible(cls) -> CompressorTrainStageResultSingleTimeStep:
+        """Sentinel for an infeasible operating point (EOS / chart-extrapolation failure).
+
+        Differs from ``create_empty`` in that ``point_is_valid=False`` and
+        ``rate_exceeds_maximum=True``, so the train reports
+        ``within_capacity=False`` / ``is_valid=False`` and an upstream solver
+        treats the proposal as infeasible rather than as a zero-power success.
+        """
+        return cls(
+            inlet_stream=None,
+            outlet_stream=None,
+            inlet_stream_including_asv=None,
+            outlet_stream_including_asv=None,
+            polytropic_head_kJ_per_kg=0.0,
+            polytropic_efficiency=1.0,
+            polytropic_enthalpy_change_kJ_per_kg=0.0,
+            polytropic_enthalpy_change_before_choke_kJ_per_kg=0.0,
+            power_megawatt=0.0,
+            chart_area_flag=ChartAreaFlag.NOT_CALCULATED,
+            rate_has_recirculation=False,
+            rate_exceeds_maximum=True,
+            pressure_is_choked=False,
+            head_exceeds_maximum=True,
+            point_is_valid=False,
+        )
+
     @property
     def inlet_actual_rate_m3_per_hour(self) -> float:
         """Actual inlet rate in Am3/hour."""
@@ -576,3 +603,18 @@ def create_empty(cls, number_of_stages: int) -> CompressorTrainResultSingleTimeS
             stage_results=[CompressorTrainStageResultSingleTimeStep.create_empty()] * number_of_stages,
             target_pressure_status=TargetPressureStatus.NOT_CALCULATED,
         )
+
+    @classmethod
+    def create_infeasible(cls, number_of_stages: int) -> CompressorTrainResultSingleTimeStep:
+        """Train-level counterpart of :meth:`CompressorTrainStageResultSingleTimeStep.create_infeasible`.
+
+        Reports ``within_capacity=False`` and ``is_valid=False`` so an upstream
+        speed/rate solver treats the proposal as infeasible.
+        """
+        return cls(
+            inlet_stream=None,
+            outlet_stream=None,
+            speed=np.nan,
+            stage_results=[CompressorTrainStageResultSingleTimeStep.create_infeasible()] * max(number_of_stages, 1),
+            target_pressure_status=TargetPressureStatus.NOT_CALCULATED,
+        )

src/libecalc/domain/process/compressor/core/train/compressor_train_common_shaft.py

@@ -142,6 +142,22 @@ def evaluate_given_constraints(
         self,
         constraints: CompressorTrainEvaluationInput,
         fixed_speed: float | None = None,  # TODO: not used?
+    ) -> CompressorTrainResultSingleTimeStep:
+        try:
+            return self._evaluate_given_constraints_impl(constraints=constraints, fixed_speed=fixed_speed)
+        except IllegalStateException as exc:
+            # Unrecoverable EOS / flash failure bubbled up — mark this timestep
+            # NOT_CALCULATED rather than crash the whole timeseries.
+            logger.warning(
+                "Compressor train evaluation failed for a timestep and was treated as NOT_CALCULATED: %s",
+                exc,
+            )
+            return CompressorTrainResultSingleTimeStep.create_empty(number_of_stages=len(self.stages))
+
+    def _evaluate_given_constraints_impl(
+        self,
+        constraints: CompressorTrainEvaluationInput,
+        fixed_speed: float | None = None,
     ) -> CompressorTrainResultSingleTimeStep:
         self.reset_rate_modifiers()
         self._validate_nonnegative_stage_rates(constraints)
@@ -1127,12 +1143,43 @@ def find_fixed_shaft_speed_given_constraints(
 
         def _calculate_compressor_train(_speed: float) -> CompressorTrainResultSingleTimeStep:
             self.shaft.set_speed(_speed)
-            return self.calculate_compressor_train(
-                constraints=constraints,
-            )
+            try:
+                return self.calculate_compressor_train(
+                    constraints=constraints,
+                )
+            except IllegalStateException as exc:
+                # EOS / fluid layer rejected this speed — surface as infeasible
+                # so the speed solver treats it like an out-of-capacity probe
+                # and tries something else.
+                logger.warning(
+                    "Compressor speed %.1f produced an infeasible state and will be treated "
+                    "as out-of-capacity (%s). The shaft-speed solver will try a different proposal.",
+                    _speed,
+                    exc,
+                )
+                return CompressorTrainResultSingleTimeStep.create_infeasible(number_of_stages=len(self.stages))
 
         train_result_for_maximum_speed = _calculate_compressor_train(_speed=maximum_speed)
 
+        # If the EOS rejected the max-speed probe (chart_area_flag NOT_CALCULATED
+        # rather than a real capacity flag), bisect down to find the highest
+        # speed we can actually evaluate at and continue the normal speed search
+        # from there.
+        max_speed_eos_failed = (
+            not train_result_for_maximum_speed.within_capacity
+            and len(train_result_for_maximum_speed.stage_results) > 0
+            and train_result_for_maximum_speed.stage_results[0].chart_area_flag == ChartAreaFlag.NOT_CALCULATED
+        )
+        if max_speed_eos_failed:
+            feasible_max_speed = maximize_x_given_boolean_condition_function(
+                x_min=minimum_speed,
+                x_max=maximum_speed,
+                bool_func=lambda s: _calculate_compressor_train(_speed=s).within_capacity,
+            )
+            if feasible_max_speed > minimum_speed:
+                maximum_speed = feasible_max_speed
+                train_result_for_maximum_speed = _calculate_compressor_train(_speed=maximum_speed)
+
         if not train_result_for_maximum_speed.within_capacity:
             # will not find valid result - the rate is above maximum rate, return invalid results at maximum speed
             self.shaft.set_speed(maximum_speed)