refactor(process-solver): use Solution.combine() to merge configurations and track success

Author: olelod

src/libecalc/domain/process/process_solver/configuration.py

@@ -1,3 +1,4 @@
+from collections.abc import Sequence
 from dataclasses import dataclass
 from functools import total_ordering
 from typing import Generic, TypeVar
@@ -47,3 +48,13 @@ def __post_init__(self):
 
 
 OperatingConfiguration = SpeedConfiguration | ChokeConfiguration | RecirculationConfiguration
+
+
+def merge_configurations(
+    first_configurations: Sequence[Configuration[OperatingConfiguration]],
+    second_configurations: Sequence[Configuration[OperatingConfiguration]],
+) -> Sequence[Configuration[OperatingConfiguration]]:
+    """Merge two sequences; entries in second_configurations take precedence by simulation_unit_id."""
+    merged = {config.simulation_unit_id: config for config in first_configurations}
+    merged.update({config.simulation_unit_id: config for config in second_configurations})
+    return list(merged.values())

src/libecalc/domain/process/process_solver/multi_pressure_solver.py

@@ -85,19 +85,17 @@ def find_solution(
             simulation_unit_id=self._shaft_id,
             value=max(speed_configurations),
         )
-        all_configurations: dict = {self._shaft_id: shaft_config}
+        solution = Solution(success=True, configuration=[shaft_config])
 
         current_inlet = inlet_stream
-        overall_success = True
 
         for segment, target in zip(self._segments, pressure_targets):
             segment.runner.apply_configuration(shaft_config)
 
             segment.anti_surge_strategy.reset()
             anti_surge_solution = segment.anti_surge_strategy.apply(inlet_stream=current_inlet)
             segment.runner.apply_configurations(anti_surge_solution.configuration)
-            for config in anti_surge_solution.configuration:
-                all_configurations[config.simulation_unit_id] = config
+            solution = solution.combine(anti_surge_solution)
 
             outlet = segment.runner.run(inlet_stream=current_inlet)
 
@@ -106,18 +104,12 @@ def find_solution(
                     target_pressure=target,
                     inlet_stream=current_inlet,
                 )
-                for config in pressure_control_solution.configuration:
-                    all_configurations[config.simulation_unit_id] = config
+                solution = solution.combine(pressure_control_solution)
                 segment.runner.apply_configurations(pressure_control_solution.configuration)
                 outlet = segment.runner.run(inlet_stream=current_inlet)
-                if not pressure_control_solution.success:
-                    overall_success = False
             elif outlet.pressure_bara < target:
-                overall_success = False
+                solution = Solution(success=False, configuration=solution.configuration)
 
             current_inlet = outlet
 
-        return Solution(
-            success=overall_success,
-            configuration=list(all_configurations.values()),
-        )
+        return solution

src/libecalc/domain/process/process_solver/solver.py

@@ -3,7 +3,12 @@
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
-from libecalc.domain.process.process_solver.configuration import Configuration, OperatingConfiguration, SimulationUnitId
+from libecalc.domain.process.process_solver.configuration import (
+    Configuration,
+    OperatingConfiguration,
+    SimulationUnitId,
+    merge_configurations,
+)
 from libecalc.domain.process.value_objects.fluid_stream import FluidStream
 
 TConfiguration = TypeVar("TConfiguration")
@@ -24,6 +29,16 @@ def get_configuration(
                 return config.value  # type: ignore[return-value]
         raise ValueError(f"No configuration found for unit {unit_id}.")
 
+    def combine(
+        self: "Solution[Sequence[Configuration[OperatingConfiguration]]]",
+        other: "Solution[Sequence[Configuration[OperatingConfiguration]]]",
+    ) -> "Solution[Sequence[Configuration[OperatingConfiguration]]]":
+        """Combine two solutions: merge configurations and success flags."""
+        return Solution(
+            success=self.success and other.success,
+            configuration=merge_configurations(self.configuration, other.configuration),
+        )
+
 
 class Solver(abc.ABC, Generic[TConfiguration]):
     @abc.abstractmethod